firefox/xpcom/tests/gtest/MozPromiseExamples.cpp

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/* 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 https://mozilla.org/MPL/2.0/. */

#include <chrono>
#include <thread>
#include "ErrorList.h"
#include "gtest/gtest.h"
#include "mozilla/MozPromise.h"
#include "mozilla/SpinEventLoopUntil.h"
#include "nsISupportsImpl.h"
#include "nsThreadUtils.h"

using namespace mozilla;

// Simple function to be able to distinguish threads in output
size_t tid() {
  return std::hash<std::thread::id>{}(std::this_thread::get_id());
}

// Invoking something on a background thread, but getting the completion on the
// main thread.
TEST(MozPromiseExamples, InvokeAsync)
{
  bool done = false;
  InvokeAsync(
      GetCurrentSerialEventTarget(), __func__,
      []() {
        printf("[%zu] Doing some work on a background thread...\n", tid());
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        printf("[%zu] Done...\n", tid());

        // Simulate various outcomes:
        srand(getpid());
        switch (rand() % 4) {
          case 0:
            return GenericPromise::CreateAndResolve(true, __func__);
          case 1:
            return GenericPromise::CreateAndResolve(false, __func__);
          case 2:
            return GenericPromise::CreateAndReject(NS_ERROR_OUT_OF_MEMORY,
                                                   __func__);
          default:
            return GenericPromise::CreateAndReject(NS_ERROR_FAILURE, __func__);
        }
      })
      ->Then(
          GetMainThreadSerialEventTarget(), __func__,
          [&done](GenericPromise::ResolveOrRejectValue&& aResult) {
            if (aResult.IsReject()) {
              printf("[%zu] Back on the main thread, the task failed: 0x%x\n",
                     tid(), (unsigned int)aResult.RejectValue());
              done = true;
              return;
            }
            printf("[%zu] back on the main thread, sucess, return value: %s\n",
                   tid(), aResult.ResolveValue() ? "true" : "false");
            done = true;
          });

  // Process all events and check that `done` was effectively set to true. This
  // is just for the purpose of this test.
  MOZ_ALWAYS_TRUE(SpinEventLoopUntil(
      "xpcom:TEST(MozPromiseExamples, OneOff)"_ns, [&done]() { return done; }));
  EXPECT_TRUE(done);
}

class Something final {
 public:
  explicit Something(uint32_t aMilliseconds = 100)
      : mMilliseconds(aMilliseconds) {}
  RefPtr<GenericPromise> DoIt() {
    // Do no dispatch the async task twice if still underway.
    if (mPromise) {
      return mPromise;
    }
    mPromise = mHolder.Ensure(__func__);
    // Kick off some work to another thread...
    std::thread([self = RefPtr{this}, this] {
      printf("[%zu] Working...\n", tid());
      std::this_thread::sleep_for(std::chrono::milliseconds(mMilliseconds));
      printf("[%zu] Resolving from background thread\n", tid());
      self->mHolder.Resolve(true, __func__);
    }).detach();
    return mPromise;
  }

 private:
  ~Something() = default;
  const uint32_t mMilliseconds;
  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(Something)
  RefPtr<GenericPromise> mPromise;
  MozPromiseHolder<GenericPromise> mHolder{};
};

// Waiting for something asynchronous to complete, from outside the instance
TEST(MozPromiseExamples, OneOff)
{
  RefPtr<Something> thing(new Something);
  bool done = false;

  thing->DoIt()->Then(
      GetCurrentSerialEventTarget(), __func__,
      [&done, thing](bool aResult) {
        printf("[%zu] Success: %s\n", tid(), aResult ? "true" : "false");
        done = true;
      },
      [&done](nsresult aError) {
        printf("[%zu] Failure: 0x%x\n", tid(), (unsigned)aError);
        done = true;
      });

  // Process all events and check that `done` was effectively set to true. This
  // is just for the purpose of this test.
  MOZ_ALWAYS_TRUE(SpinEventLoopUntil(
      "xpcom:TEST(MozPromiseExamples, OneOff)"_ns, [&done]() { return done; }));
}

class SomethingCancelable final {
 public:
  RefPtr<GenericPromise> DoIt() {
    if (mPromise) {
      return mPromise;
    }
    mPromise = mHolder.Ensure(__func__);
    // Kick off some work to another thread...
    std::thread([self = RefPtr{this}] {
      printf("[%zu] Working...\n", tid());
      std::this_thread::sleep_for(std::chrono::milliseconds(100));
      // This is printed: despite being canceled, the thread runs normally and
      // resolves its promise.
      printf("[%zu] Resolving from background thread\n", tid());
      self->mHolder.Resolve(true, __func__);
    }).detach();
    return mPromise;
  }

 private:
  ~SomethingCancelable() = default;
  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(SomethingCancelable)
  MozPromiseHolder<GenericPromise> mHolder{};
  RefPtr<GenericPromise> mPromise;
  MozPromiseRequestHolder<GenericPromise> mRequest;
};

// Kick of an asynchronous job, and cancel it
TEST(MozPromiseExamples, OneOffCancelable)
{
  RefPtr<SomethingCancelable> thing(new SomethingCancelable);

  // Start a job that takes 100ms
  MozPromiseRequestHolder<GenericPromise> holder;
  thing->DoIt()
      ->Then(GetCurrentSerialEventTarget(), __func__,
             [&holder] {
               holder.Complete();
               // This is never printed: in this example we disconnect the
               // request before completion.
               printf("[%zu] Async work finished", tid());
             })
      ->Track(holder);
  // But cancel it after just 10ms
  std::this_thread::sleep_for(std::chrono::milliseconds(10));
  holder.Disconnect();
}

// Waiting for multiple asynchronous tasks to complete, from outside the
// instance
TEST(MozPromiseExamples, MultipleWaits)
{
  nsTArray<RefPtr<Something>> things;
  uint32_t count = 10;
  while (count--) {
    things.AppendElement(new Something(count * 10));
  }
  bool done = false;

  nsTArray<RefPtr<GenericPromise>> promises;
  for (auto& thing : things) {
    promises.AppendElement(thing->DoIt());
  }

  GenericPromise::All(GetCurrentSerialEventTarget(), promises)
      ->Then(
          GetCurrentSerialEventTarget(), __func__,
          [&done](nsTArray<bool>&& aResults) {
            nsCString results;
            for (auto b : aResults) {
              results.AppendPrintf("%s, ", b ? "true" : "false");
            }
            printf("[%zu] All succeeded: %s\n", tid(), results.get());
            done = true;
          },
          [&done](nsresult aError) {
            printf("[%zu] One failed: 0x%x\n", tid(), (unsigned)aError);
            done = true;
          });

  // Process all events and check that `done` was effectively set to true. This
  // is just for the purpose of this test.
  MOZ_ALWAYS_TRUE(SpinEventLoopUntil(
      "xpcom:TEST(MozPromiseExamples, OneOff)"_ns, [&done]() { return done; }));
}

RefPtr<GenericPromise> SyncOperation(uint32_t aConstraint) {
  printf("[%zu] SyncOperation(%" PRIu32 ")\n", tid(), aConstraint);
  if (aConstraint > 5) {
    return GenericPromise::CreateAndReject(NS_ERROR_UNEXPECTED, __func__);
  }

  return GenericPromise::CreateAndResolve(true, __func__);
}

// This test uses various MozPromise facilities and prints a message to the
// console, to show how the scheduling works.
TEST(MozPromiseExamples, SyncReturn)
{
  bool done = false;
  // Dispatch a runnable to the current even loop, for the sole purpose of
  // understanding ordering.
  NS_DispatchToCurrentThread(NS_NewRunnableFunction("Initial runnable", [] {
    printf("[%zu] Dispatched before sync promise operation\n", tid());
  }));
  // SyncOperation synchronously returns a resolved promise. However, `Then`
  // works by dispatching so the printf will happen after InitialRunnable.
  SyncOperation(3)->Then(
      GetCurrentSerialEventTarget(), __func__,
      [](bool aResult) {
        printf("[%zu] Sync promise value: %s\n", tid(),
               aResult ? "true" : "false");
      },
      [](nsresult aError) {
        printf("[%zu] Error: 0x%x\n", tid(), (unsigned)aError);
      });
  // Now call the same method, but invoke it async on the current event queue.
  // The resolve will also be in its own event loop task. It follows that this
  // will be printed after the "Final Runnable" below.
  // MozPromise can be put in tail dispatch mode,or sync mode, and in those
  // cases, the ordering will be different.
  InvokeAsync(GetCurrentSerialEventTarget(), __func__,
              []() { return SyncOperation(4); })
      ->Then(
          GetCurrentSerialEventTarget(), __func__,
          [&done](bool aResult) {
            printf("[%zu] Sync promise value (InvokeAsync): %s\n", tid(),
                   aResult ? "true" : "false");
            done = true;
          },
          [](nsresult aError) {
            printf("[%zu] Error (InvokeAsync): 0x%x\n", tid(),
                   (unsigned)aError);
          });
  // Dispatch a runnable to the current even loop, for the sole purpose of
  // understanding ordering.
  NS_DispatchToCurrentThread(NS_NewRunnableFunction("Final runnable", [] {
    printf("[%zu] Dispatched after sync promise operation\n", tid());
  }));

  // The output will be as such (omitting the thread ids):
  // [...] SyncOperation(3)
  // [...] Dispatched before sync promise operation
  // [...] Sync promise value: true
  // [...] SyncOperation(4)
  // [...] Dispatched after sync promise operation
  // [...] Sync promise value (InvokeAsync): true

  // Process all events and check that `done` was effectively set to true. This
  // is just for the purpose of this test.
  MOZ_ALWAYS_TRUE(SpinEventLoopUntil(
      "xpcom:TEST(MozPromiseExamples, OneOff)"_ns, [&done]() { return done; }));
}

using IntPromise = MozPromise<int, nsresult, true>;
using UintPromise = MozPromise<unsigned, nsresult, true>;

class SomethingSync {
 public:
  RefPtr<GenericPromise> DoSomethingSync() {
    return GenericPromise::CreateAndResolve(true, "Returning true");
  }
};

TEST(MozPromiseExamples, Chaining)
{
  bool done = false;
  SomethingSync s;
  // Do something that returns a bool, then chain it to a promise that returns
  // an int, then to a promise that returns an unsigned.
  s.DoSomethingSync()
      ->Then(GetCurrentSerialEventTarget(), __func__,
             [](GenericPromise::ResolveOrRejectValue&& aValue) {
               if (aValue.IsResolve()) {
                 // Depending on the value of the bool, find the proper signed
                 // integer value.
                 return IntPromise::CreateAndResolve(
                     aValue.ResolveValue() ? 3 : 5,
                     "Example IntPromise Resolver");
               }
               return IntPromise::CreateAndReject(
                   aValue.RejectValue(), "Example IntPromise Rejecter");
             })
      ->Then(GetCurrentSerialEventTarget(), __func__,
             [&done](IntPromise::ResolveOrRejectValue&& aValue) {
               if (aValue.IsResolve()) {
                 // Depending on the value of the signed integer, find the
                 // proper unsigned integer value.
                 done = true;
                 return UintPromise::CreateAndResolve(
                     static_cast<unsigned>(aValue.ResolveValue()),
                     "Example UintPromise Resolver");
               }
               return UintPromise::CreateAndReject(
                   aValue.RejectValue(), "Example UintPromise Rejecter");
             });

  // Process all events and check that `done` was effectively set to true. This
  // is just for the purpose of this test.
  MOZ_ALWAYS_TRUE(
      SpinEventLoopUntil("xpcom:TEST(MozPromiseExamples, Chaining)"_ns,
                         [&done]() { return done; }));
}

// - converting an async legacy callback interface to a modern MozPromise
// version with MozPromiseHolder.