Quelle TestThreadUtils.cpp Sprache: C

/* 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(©Counter);
        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(©Counter))
                   : RunnableFactory::Create("TestNewRunnableFunction",
                                             TestCopyWithNoMove(©Counter));
      }
      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(©Counter);
        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(©Counter, &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(©Counter, &moveCounter))
                   : RunnableFactory::Create(
                         "TestNewRunnableFunction",
                         TestCopyMove(©Counter, &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(©Counter);
        // 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(©Counter);
        // 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(©Counter, &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 < std::size(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 < std::size(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(std::is_same_v<int, mozilla::RemoveSmartPointer<int>>,
                "RemoveSmartPointer should be int");
  static_assert(std::is_same_v<int*, mozilla::RemoveSmartPointer<int*>>,
                "RemoveSmartPointer should be int*");
  static_assert(std::is_same_v<UniquePtr<int>,
                               mozilla::RemoveSmartPointer<UniquePtr<int>>>,
                "RemoveSmartPointer> should be UniquePtr");
  static_assert(std::is_same_v<int, mozilla::RemoveSmartPointer<RefPtr<int>>>,
                "RemoveSmartPointer> should be int");
  static_assert(
      std::is_same_v<int, mozilla::RemoveSmartPointer<const RefPtr<int>>>,
      "RemoveSmartPointer> should be int");
  static_assert(
      std::is_same_v<int, mozilla::RemoveSmartPointer<volatile RefPtr<int>>>,
      "RemoveSmartPointer> should be int");
  static_assert(
      std::is_same_v<int,
                     mozilla::RemoveSmartPointer<const volatile RefPtr<int>>>,
      "RemoveSmartPointer> should be int");
  static_assert(std::is_same_v<int, mozilla::RemoveSmartPointer<nsCOMPtr<int>>>,
                "RemoveSmartPointer> should be int");
  static_assert(
      std::is_same_v<int, mozilla::RemoveSmartPointer<const nsCOMPtr<int>>>,
      "RemoveSmartPointer> should be int");
  static_assert(
      std::is_same_v<int, mozilla::RemoveSmartPointer<volatile nsCOMPtr<int>>>,
      "RemoveSmartPointer> should be int");
  static_assert(
      std::is_same_v<int,
                     mozilla::RemoveSmartPointer<const volatile nsCOMPtr<int>>>,
      "RemoveSmartPointer> should be int");

  static_assert(std::is_same_v<int, mozilla::RemoveRawOrSmartPointer<int>>,
                "RemoveRawOrSmartPointer should be int");
  static_assert(
      std::is_same_v<UniquePtr<int>,
                     mozilla::RemoveRawOrSmartPointer<UniquePtr<int>>>,
      "RemoveRawOrSmartPointer> should be UniquePtr");
  static_assert(std::is_same_v<int, mozilla::RemoveRawOrSmartPointer<int*>>,
                "RemoveRawOrSmartPointer should be int");
  static_assert(
      std::is_same_v<const int, mozilla::RemoveRawOrSmartPointer<const int*>>,
      "RemoveRawOrSmartPointer should be const int");
  static_assert(
      std::is_same_v<volatile int,
                     mozilla::RemoveRawOrSmartPointer<volatile int*>>,
      "RemoveRawOrSmartPointer should be volatile int");
  static_assert(
      std::is_same_v<const volatile int,
                     mozilla::RemoveRawOrSmartPointer<const volatile int*>>,
      "RemoveRawOrSmartPointer should be const "
      "volatile int");
  static_assert(
      std::is_same_v<int, mozilla::RemoveRawOrSmartPointer<RefPtr<int>>>,
      "RemoveRawOrSmartPointer> should be int");
  static_assert(
      std::is_same_v<int, mozilla::RemoveRawOrSmartPointer<const RefPtr<int>>>,
      "RemoveRawOrSmartPointer> should be int");
  static_assert(
      std::is_same_v<int,
                     mozilla::RemoveRawOrSmartPointer<volatile RefPtr<int>>>,
      "RemoveRawOrSmartPointer> should be int");
  static_assert(
      std::is_same_v<
          int, mozilla::RemoveRawOrSmartPointer<const volatile RefPtr<int>>>,
      "RemoveRawOrSmartPointer> should be "
      "int");
  static_assert(
      std::is_same_v<int, mozilla::RemoveRawOrSmartPointer<nsCOMPtr<int>>>,
      "RemoveRawOrSmartPointer> should be int");
  static_assert(
      std::is_same_v<int,
                     mozilla::RemoveRawOrSmartPointer<const nsCOMPtr<int>>>,
      "RemoveRawOrSmartPointer> should be int");
  static_assert(
      std::is_same_v<int,
                     mozilla::RemoveRawOrSmartPointer<volatile nsCOMPtr<int>>>,
      "RemoveRawOrSmartPointer> should be int");
  static_assert(
      std::is_same_v<
          int, mozilla::RemoveRawOrSmartPointer<const volatile nsCOMPtr<int>>>,
      "RemoveRawOrSmartPointer> 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<StoreCopyPassByConstLRef<int>>::value,
      "StoreCopyPassByConstLRef should be recognized as Storage Class");
  static_assert(
      IsParameterStorageClass<StoreCopyPassByRRef<int>>::value,
      "StoreCopyPassByRRef should be recognized as Storage Class");
  static_assert(
      IsParameterStorageClass<StoreRefPassByLRef<int>>::value,
      "StoreRefPassByLRef should be recognized as Storage Class");
  static_assert(
      IsParameterStorageClass<StoreConstRefPassByConstLRef<int>>::value,
      "StoreConstRefPassByConstLRef should be recognized as Storage "
      "Class");
  static_assert(
      IsParameterStorageClass<StoreRefPtrPassByPtr<int>>::value,
      "StoreRefPtrPassByPtr should be recognized as Storage Class");
  static_assert(IsParameterStorageClass<StorePtrPassByPtr<int>>::value,
                "StorePtrPassByPtr should be recognized as Storage Class");
  static_assert(
      IsParameterStorageClass<StoreConstPtrPassByConstPtr<int>>::value,
      "StoreConstPtrPassByConstPtr 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::Type should be "
                "StoreCopyPassByConstLRef");

  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::Type should be StorePtrPassByPtr");
  static_assert(std::is_same_v<::detail::ParameterStorage<int* const>::Type,
                               StorePtrPassByPtr<int>>,
                "detail::ParameterStorage::Type should be "
                "StorePtrPassByPtr");
  static_assert(std::is_same_v<::detail::ParameterStorage<int* volatile>::Type,
                               StorePtrPassByPtr<int>>,
                "detail::ParameterStorage::Type should be "
                "StorePtrPassByPtr");
  static_assert(
      std::is_same_v<::detail::ParameterStorage<int* const volatile>::Type,
                     StorePtrPassByPtr<int>>,
      "detail::ParameterStorage::Type should be "
      "StorePtrPassByPtr");
  static_assert(
      std::is_same_v<::detail::ParameterStorage<int*>::Type::stored_type, int*>,
      "detail::ParameterStorage::Type::stored_type should be int*");
  static_assert(
      std::is_same_v<::detail::ParameterStorage<int*>::Type::passed_type, int*>,
      "detail::ParameterStorage::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::Type should be "
                "StoreConstPtrPassByConstPtr");
  static_assert(
      std::is_same_v<::detail::ParameterStorage<const int* const>::Type,
                     StoreConstPtrPassByConstPtr<int>>,
      "detail::ParameterStorage::Type should be "
      "StoreConstPtrPassByConstPtr");
  static_assert(
      std::is_same_v<::detail::ParameterStorage<const int* volatile>::Type,
                     StoreConstPtrPassByConstPtr<int>>,
      "detail::ParameterStorage::Type should be "
      "StoreConstPtrPassByConstPtr");
  static_assert(std::is_same_v<
                    ::detail::ParameterStorage<const int* const volatile>::Type,
                    StoreConstPtrPassByConstPtr<int>>,
                "detail::ParameterStorage::Type "
                "should be StoreConstPtrPassByConstPtr");
  static_assert(
      std::is_same_v<::detail::ParameterStorage<const int*>::Type::stored_type,
                     const int*>,
      "detail::ParameterStorage::Type::stored_type should be const "
      "int*");
  static_assert(
      std::is_same_v<::detail::ParameterStorage<const int*>::Type::passed_type,
                     const int*>,
      "detail::ParameterStorage::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);
  }

  // nsRefPtr to pointer.
  static_assert(
      std::is_same_v<::detail::ParameterStorage<
                         StoreRefPtrPassByPtr<SpyWithISupports>>::Type,
                     StoreRefPtrPassByPtr<SpyWithISupports>>,
      "ParameterStorage>::Type should "
      "be StoreRefPtrPassByPtr");
  static_assert(
      std::is_same_v<::detail::ParameterStorage<SpyWithISupports*>::Type,
                     StoreRefPtrPassByPtr<SpyWithISupports>>,
      "ParameterStorage::Type should be "
      "StoreRefPtrPassByPtr");
  static_assert(
      std::is_same_v<StoreRefPtrPassByPtr<SpyWithISupports>::stored_type,
                     RefPtr<SpyWithISupports>>,
      "StoreRefPtrPassByPtr::stored_type should be "
      "RefPtr");
  static_assert(
      std::is_same_v<StoreRefPtrPassByPtr<SpyWithISupports>::passed_type,
                     SpyWithISupports*>,
      "StoreRefPtrPassByPtr::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>,
                "ThreadUtilsRefCountedFinal has AddRef() and Release()");
  static_assert(
      std::is_same_v<
          ::detail::ParameterStorage<ThreadUtilsRefCountedFinal*>::Type,
          StoreRefPtrPassByPtr<ThreadUtilsRefCountedFinal>>,
      "ParameterStorage::Type should be "
      "StoreRefPtrPassByPtr");
  static_assert(::detail::HasRefCountMethods<ThreadUtilsRefCountedBase>,
                "ThreadUtilsRefCountedBase has AddRef() and Release()");
  static_assert(
      std::is_same_v<
          ::detail::ParameterStorage<ThreadUtilsRefCountedBase*>::Type,
          StoreRefPtrPassByPtr<ThreadUtilsRefCountedBase>>,
      "ParameterStorage::Type should be "
      "StoreRefPtrPassByPtr");
  static_assert(::detail::HasRefCountMethods<ThreadUtilsRefCountedDerived>,
                "ThreadUtilsRefCountedDerived has AddRef() and Release()");
  static_assert(
      std::is_same_v<
          ::detail::ParameterStorage<ThreadUtilsRefCountedDerived*>::Type,
          StoreRefPtrPassByPtr<ThreadUtilsRefCountedDerived>>,
      "ParameterStorage::Type should be "
      "StoreRefPtrPassByPtr");

  static_assert(!::detail::HasRefCountMethods<ThreadUtilsNonRefCounted>,
                "ThreadUtilsNonRefCounted doesn't have AddRef() and Release()");
  static_assert(!std::is_same_v<
                    ::detail::ParameterStorage<ThreadUtilsNonRefCounted*>::Type,
                    StoreRefPtrPassByPtr<ThreadUtilsNonRefCounted>>,
                "ParameterStorage::Type should NOT "
                "be StoreRefPtrPassByPtr");

  // Lvalue reference.
  static_assert(
      std::is_same_v<::detail::ParameterStorage<int&>::Type,
                     StoreRefPassByLRef<int>>,
      "ParameterStorage::Type should be StoreRefPassByLRef");
  static_assert(
      std::is_same_v<::detail::ParameterStorage<int&>::Type::stored_type,
                     StoreRefPassByLRef<int>::stored_type>,
      "ParameterStorage::Type::stored_type should be "
      "StoreRefPassByLRef::stored_type");
  static_assert(
      std::is_same_v<::detail::ParameterStorage<int&>::Type::stored_type, int&>,
      "ParameterStorage::Type::stored_type should be int&");
  static_assert(
      std::is_same_v<::detail::ParameterStorage<int&>::Type::passed_type, int&>,
      "ParameterStorage::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::Type should be StoreCopyPassByRRef");
  static_assert(
      std::is_same_v<::detail::ParameterStorage<int&&>::Type::stored_type,
                     StoreCopyPassByRRef<int>::stored_type>,
      "ParameterStorage::Type::stored_type should be "
      "StoreCopyPassByRRef::stored_type");
  static_assert(
      std::is_same_v<::detail::ParameterStorage<int&&>::Type::stored_type, int>,
      "ParameterStorage::Type::stored_type should be int");
  static_assert(
      std::is_same_v<::detail::ParameterStorage<int&&>::Type::passed_type,
                     int&&>,
      "ParameterStorage::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&&>::Type should be "
                "StoreCopyPassByRRef>");
  static_assert(
      std::is_same_v<::detail::ParameterStorage<
                         mozilla::UniquePtr<int>&&>::Type::stored_type,
                     StoreCopyPassByRRef<mozilla::UniquePtr<int>>::stored_type>,
      "ParameterStorage&&>::Type::stored_type should be "
      "StoreCopyPassByRRef>::stored_type");
  static_assert(
      std::is_same_v<::detail::ParameterStorage<
                         mozilla::UniquePtr<int>&&>::Type::stored_type,
                     mozilla::UniquePtr<int>>,
      "ParameterStorage&&>::Type::stored_type should be "
      "UniquePtr");
  static_assert(
      std::is_same_v<::detail::ParameterStorage<
                         mozilla::UniquePtr<int>&&>::Type::passed_type,
                     mozilla::UniquePtr<int>&&>,
      "ParameterStorage&&>::Type::passed_type should be "
      "UniquePtr&&");
  {
    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>>::Type::stored_"
      "type should be StoreCopyPassByRRef>::stored_type");
  static_assert(
      std::is_same_v<::detail::ParameterStorage<StoreCopyPassByRRef<
                         mozilla::UniquePtr<int>>>::Type::stored_type,
                     StoreCopyPassByRRef<mozilla::UniquePtr<int>>::stored_type>,
      "ParameterStorage>>::Type::stored_"
      "type should be StoreCopyPassByRRef>::stored_type");
  static_assert(
      std::is_same_v<::detail::ParameterStorage<StoreCopyPassByRRef<
                         mozilla::UniquePtr<int>>>::Type::stored_type,
                     mozilla::UniquePtr<int>>,
      "ParameterStorage>>::Type::stored_"
      "type should be UniquePtr");
  static_assert(
      std::is_same_v<::detail::ParameterStorage<StoreCopyPassByRRef<
                         mozilla::UniquePtr<int>>>::Type::passed_type,
                     mozilla::UniquePtr<int>&&>,
      "ParameterStorage>>::Type::passed_"
      "type should be UniquePtr&&");
  {
    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 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>(&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>(&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>(&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>(&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(&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 s(new SpyWithISupports(45))\n",
               __LINE__);
      }
      RefPtr<SpyWithISupports> s(new SpyWithISupports(45));
      ptr = s.get();
--> --------------------

--> maximum size reached

--> --------------------

quality99%

¤ Dauer der Verarbeitung: 0.40 Sekunden ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.