react-native-tvos 0.76.6-0 → 0.77.0-0

package/ReactCommon/react/performance/timeline/tests/PerformanceEntryReporterTest.cpp

@@ -11,6 +11,8 @@
 
 #include "../PerformanceEntryReporter.h"
 
+using namespace facebook::react;
+
 namespace facebook::react {
 
 [[maybe_unused]] static bool operator==(
@@ -27,342 +29,324 @@ namespace facebook::react {
     std::ostream& os,
     const PerformanceEntry& entry) {
   static constexpr const char* entryTypeNames[] = {
-      "UNDEFINED",
-      "MARK",
-      "MEASURE",
-      "EVENT",
+      "PerformanceEntryType::UNDEFINED",
+      "PerformanceEntryType::MARK",
+      "PerformanceEntryType::MEASURE",
+      "PerformanceEntryType::EVENT",
   };
-  return os << "{ name: " << entry.name
-            << ", type: " << entryTypeNames[static_cast<int>(entry.entryType)]
-            << ", startTime: " << entry.startTime
-            << ", duration: " << entry.duration << " }";
+  return os << "{ .name = \"" << entry.name << "\"" << ", .entryType = "
+            << entryTypeNames[static_cast<int>(entry.entryType)]
+            << ", .startTime = " << entry.startTime
+            << ", .duration = " << entry.duration << " }";
 }
 } // namespace facebook::react
 
-using namespace facebook::react;
-
-TEST(PerformanceEntryReporter, PerformanceEntryReporterTestStartReporting) {
-  auto reporter = PerformanceEntryReporter::getInstance();
-
-  reporter->stopReporting();
-  reporter->clearEntries();
-
-  reporter->startReporting(PerformanceEntryType::MARK);
-  reporter->startReporting(PerformanceEntryType::MEASURE);
-
-  ASSERT_TRUE(reporter->isReporting(PerformanceEntryType::MARK));
-  ASSERT_TRUE(reporter->isReporting(PerformanceEntryType::MEASURE));
-
-  ASSERT_FALSE(reporter->isReporting(PerformanceEntryType::EVENT));
-}
-
-TEST(PerformanceEntryReporter, PerformanceEntryReporterTestStopReporting) {
-  auto reporter = PerformanceEntryReporter::getInstance();
-
-  reporter->stopReporting();
-  reporter->clearEntries();
-
-  reporter->startReporting(PerformanceEntryType::MARK);
-
-  reporter->mark("mark0", 0.0);
-  reporter->mark("mark1", 0.0);
-  reporter->mark("mark2", 0.0);
-  reporter->measure("measure0", 0.0, 0.0);
-
-  auto res = reporter->popPendingEntries();
-  const auto& entries = res.entries;
-
-  ASSERT_EQ(0, res.droppedEntriesCount);
-  ASSERT_EQ(3, entries.size());
-
-  res = reporter->popPendingEntries();
-
-  ASSERT_EQ(0, res.droppedEntriesCount);
-  ASSERT_EQ(0, res.entries.size());
-
-  reporter->stopReporting(PerformanceEntryType::MARK);
-  reporter->startReporting(PerformanceEntryType::MEASURE);
-
-  reporter->mark("mark3");
-  reporter->measure("measure1", 0.0, 0.0);
-
-  res = reporter->popPendingEntries();
-
-  ASSERT_EQ(0, res.droppedEntriesCount);
-  ASSERT_EQ(1, res.entries.size());
-  ASSERT_STREQ("measure1", res.entries[0].name.c_str());
+namespace {
+std::vector<PerformanceEntry> toSorted(
+    std::vector<PerformanceEntry>&& entries) {
+  std::stable_sort(entries.begin(), entries.end(), PerformanceEntrySorter{});
+  return entries;
 }
+} // namespace
 
 TEST(PerformanceEntryReporter, PerformanceEntryReporterTestReportMarks) {
   auto reporter = PerformanceEntryReporter::getInstance();
 
-  reporter->stopReporting();
   reporter->clearEntries();
 
-  reporter->startReporting(PerformanceEntryType::MARK);
-
-  reporter->mark("mark0", 0.0);
-  reporter->mark("mark1", 1.0);
-  reporter->mark("mark2", 2.0);
+  reporter->reportMark("mark0", 0);
+  reporter->reportMark("mark1", 1);
+  reporter->reportMark("mark2", 2);
   // Report mark0 again
-  reporter->mark("mark0", 3.0);
+  reporter->reportMark("mark0", 3);
 
-  auto res = reporter->popPendingEntries();
-  const auto& entries = res.entries;
+  const auto entries = toSorted(reporter->getEntries());
 
-  ASSERT_EQ(0, res.droppedEntriesCount);
   ASSERT_EQ(4, entries.size());
 
   const std::vector<PerformanceEntry> expected = {
       {.name = "mark0",
        .entryType = PerformanceEntryType::MARK,
-       .startTime = 0.0},
+       .startTime = 0,
+       .duration = 0},
       {.name = "mark1",
        .entryType = PerformanceEntryType::MARK,
-       .startTime = 1.0},
+       .startTime = 1,
+       .duration = 0},
       {.name = "mark2",
        .entryType = PerformanceEntryType::MARK,
-       .startTime = 2.0},
+       .startTime = 2,
+       .duration = 0},
       {.name = "mark0",
        .entryType = PerformanceEntryType::MARK,
-       .startTime = 3.0},
-  };
+       .startTime = 3,
+       .duration = 0}};
 
   ASSERT_EQ(expected, entries);
 }
 
 TEST(PerformanceEntryReporter, PerformanceEntryReporterTestReportMeasures) {
   auto reporter = PerformanceEntryReporter::getInstance();
-
-  reporter->stopReporting();
   reporter->clearEntries();
 
-  reporter->startReporting(PerformanceEntryType::MARK);
-  reporter->startReporting(PerformanceEntryType::MEASURE);
+  reporter->reportMark("mark0", 0);
+  reporter->reportMark("mark1", 1);
+  reporter->reportMark("mark2", 2);
 
-  reporter->mark("mark0", 0.0);
-  reporter->mark("mark1", 1.0);
-  reporter->mark("mark2", 2.0);
-
-  reporter->measure("measure0", 0.0, 2.0);
-  reporter->measure("measure1", 0.0, 2.0, 4.0);
-  reporter->measure("measure2", 0.0, 0.0, std::nullopt, "mark1", "mark2");
-  reporter->measure("measure3", 0.0, 0.0, 5.0, "mark1");
-  reporter->measure("measure4", 1.5, 0.0, std::nullopt, std::nullopt, "mark2");
+  reporter->reportMeasure("measure0", 0, 2);
+  reporter->reportMeasure("measure1", 0, 2, 4);
+  reporter->reportMeasure("measure2", 0, 0, std::nullopt, "mark1", "mark2");
+  reporter->reportMeasure("measure3", 0, 0, 5, "mark1");
+  reporter->reportMeasure(
+      "measure4", 1.5, 0, std::nullopt, std::nullopt, "mark2");
 
   reporter->setTimeStampProvider([]() { return 3.5; });
-  reporter->measure("measure5", 0.0, 0.0, std::nullopt, "mark2");
+  reporter->reportMeasure("measure5", 0, 0, std::nullopt, "mark2");
 
-  reporter->mark("mark3", 2.0);
-  reporter->measure("measure6", 2.0, 2.0);
-  reporter->mark("mark4", 2.0);
-  reporter->mark("mark4", 3.0);
+  reporter->reportMark("mark3", 2.5);
+  reporter->reportMeasure("measure6", 2.0, 2.0);
+  reporter->reportMark("mark4", 2.1);
+  reporter->reportMark("mark4", 3.0);
   // Uses the last reported time for mark4
-  reporter->measure("measure7", 0.0, 0.0, std::nullopt, "mark1", "mark4");
-
-  auto res = reporter->popPendingEntries();
-  const auto& entries = res.entries;
+  reporter->reportMeasure("measure7", 0, 0, std::nullopt, "mark1", "mark4");
 
-  ASSERT_EQ(0, res.droppedEntriesCount);
+  const auto entries = toSorted(reporter->getEntries());
 
   const std::vector<PerformanceEntry> expected = {
       {.name = "mark0",
        .entryType = PerformanceEntryType::MARK,
-       .startTime = 0.0},
+       .startTime = 0,
+       .duration = 0},
       {.name = "measure0",
        .entryType = PerformanceEntryType::MEASURE,
-       .startTime = 0.0,
-       .duration = 2.0},
+       .startTime = 0,
+       .duration = 2},
       {.name = "measure1",
        .entryType = PerformanceEntryType::MEASURE,
-       .startTime = 0.0,
-       .duration = 4.0},
+       .startTime = 0,
+       .duration = 4},
       {.name = "mark1",
        .entryType = PerformanceEntryType::MARK,
-       .startTime = 1.0},
+       .startTime = 1,
+       .duration = 0},
       {.name = "measure2",
        .entryType = PerformanceEntryType::MEASURE,
-       .startTime = 1.0,
-       .duration = 1.0},
+       .startTime = 1,
+       .duration = 1},
       {.name = "measure7",
        .entryType = PerformanceEntryType::MEASURE,
-       .startTime = 1.0,
-       .duration = 2.0},
+       .startTime = 1,
+       .duration = 2},
       {.name = "measure3",
        .entryType = PerformanceEntryType::MEASURE,
-       .startTime = 1.0,
-       .duration = 5.0},
+       .startTime = 1,
+       .duration = 5},
       {.name = "measure4",
        .entryType = PerformanceEntryType::MEASURE,
        .startTime = 1.5,
        .duration = 0.5},
       {.name = "mark2",
        .entryType = PerformanceEntryType::MARK,
-       .startTime = 2.0},
-      {.name = "mark3",
-       .entryType = PerformanceEntryType::MARK,
-       .startTime = 2.0},
-      {.name = "mark4",
-       .entryType = PerformanceEntryType::MARK,
-       .startTime = 2.0},
+       .startTime = 2,
+       .duration = 0},
       {.name = "measure6",
        .entryType = PerformanceEntryType::MEASURE,
-       .startTime = 2.0,
-       .duration = 0.0},
+       .startTime = 2,
+       .duration = 0},
       {.name = "measure5",
        .entryType = PerformanceEntryType::MEASURE,
-       .startTime = 2.0,
+       .startTime = 2,
        .duration = 1.5},
       {.name = "mark4",
        .entryType = PerformanceEntryType::MARK,
-       .startTime = 3.0}};
+       .startTime = 2.1,
+       .duration = 0},
+      {.name = "mark3",
+       .entryType = PerformanceEntryType::MARK,
+       .startTime = 2.5,
+       .duration = 0},
+      {.name = "mark4",
+       .entryType = PerformanceEntryType::MARK,
+       .startTime = 3,
+       .duration = 0}};
 
   ASSERT_EQ(expected, entries);
 }
 
-static std::vector<std::string> getNames(
-    const std::vector<PerformanceEntry>& entries) {
-  std::vector<std::string> res;
-  std::transform(
-      entries.begin(),
-      entries.end(),
-      std::back_inserter(res),
-      [](const PerformanceEntry& e) { return e.name; });
-  return res;
-}
-
-static std::vector<PerformanceEntryType> getTypes(
-    const std::vector<PerformanceEntry>& entries) {
-  std::vector<PerformanceEntryType> res;
-  std::transform(
-      entries.begin(),
-      entries.end(),
-      std::back_inserter(res),
-      [](const PerformanceEntry& e) { return e.entryType; });
-  return res;
-}
-
 TEST(PerformanceEntryReporter, PerformanceEntryReporterTestGetEntries) {
   auto reporter = PerformanceEntryReporter::getInstance();
-
-  reporter->stopReporting();
   reporter->clearEntries();
 
-  auto res = reporter->popPendingEntries();
-  const auto& entries = res.entries;
-
-  ASSERT_EQ(0, res.droppedEntriesCount);
-  ASSERT_EQ(0, entries.size());
-
-  reporter->startReporting(PerformanceEntryType::MARK);
-  reporter->startReporting(PerformanceEntryType::MEASURE);
-
-  reporter->mark("common_name", 0.0);
-  reporter->mark("mark1", 1.0);
-  reporter->mark("mark2", 2.0);
-
-  reporter->measure("common_name", 0.0, 2.0);
-  reporter->measure("measure1", 0.0, 2.0, 4.0);
-  reporter->measure("measure2", 0.0, 0.0, std::nullopt, "mark1", "mark2");
-  reporter->measure("measure3", 0.0, 0.0, 5.0, "mark1");
-  reporter->measure("measure4", 1.5, 0.0, std::nullopt, std::nullopt, "mark2");
-
-  res = reporter->popPendingEntries();
-  ASSERT_EQ(0, res.droppedEntriesCount);
-  ASSERT_EQ(8, res.entries.size());
-
-  reporter->getEntries(PerformanceEntryType::MARK);
-  const auto marks = reporter->getEntries(PerformanceEntryType::MARK);
-
-  const auto measures = reporter->getEntries(PerformanceEntryType::MEASURE);
-  const auto common_name = reporter->getEntries(std::nullopt, "common_name");
-
-  reporter->getEntries();
-  const auto all = reporter->getEntries();
-
-  ASSERT_EQ(
-      std::vector(
-          {PerformanceEntryType::MEASURE,
-           PerformanceEntryType::MEASURE,
-           PerformanceEntryType::MEASURE,
-           PerformanceEntryType::MEASURE,
-           PerformanceEntryType::MEASURE}),
-      getTypes(measures));
-  ASSERT_EQ(
-      std::vector({PerformanceEntryType::MARK, PerformanceEntryType::MEASURE}),
-      getTypes(common_name));
-  ASSERT_EQ(
-      std::vector(
-          {PerformanceEntryType::MARK,
-           PerformanceEntryType::MARK,
-           PerformanceEntryType::MARK,
-           PerformanceEntryType::MEASURE,
-           PerformanceEntryType::MEASURE,
-           PerformanceEntryType::MEASURE,
-           PerformanceEntryType::MEASURE,
-           PerformanceEntryType::MEASURE}),
-      getTypes(all));
-  ASSERT_EQ(
-      std::vector(
-          {PerformanceEntryType::MARK,
-           PerformanceEntryType::MARK,
-           PerformanceEntryType::MARK}),
-      getTypes(marks));
-
-  ASSERT_EQ(
-      std::vector<std::string>({"common_name", "mark1", "mark2"}),
-      getNames(marks));
-
-  ASSERT_EQ(
-      std::vector<std::string>({"common_name", "common_name"}),
-      getNames(common_name));
+  {
+    const auto entries = reporter->getEntries();
+    ASSERT_EQ(0, entries.size());
+  }
+
+  reporter->reportMark("common_name", 0);
+  reporter->reportMark("mark1", 1);
+  reporter->reportMark("mark2", 2);
+
+  reporter->reportMeasure("common_name", 0, 2);
+  reporter->reportMeasure("measure1", 0, 2, 4);
+  reporter->reportMeasure("measure2", 0, 0, std::nullopt, "mark1", "mark2");
+  reporter->reportMeasure("measure3", 0, 0, 5, "mark1");
+  reporter->reportMeasure(
+      "measure4", 1.5, 0, std::nullopt, std::nullopt, "mark2");
+
+  {
+    const auto allEntries = toSorted(reporter->getEntries());
+    const std::vector<PerformanceEntry> expected = {
+        {.name = "common_name",
+         .entryType = PerformanceEntryType::MARK,
+         .startTime = 0,
+         .duration = 0},
+        {.name = "common_name",
+         .entryType = PerformanceEntryType::MEASURE,
+         .startTime = 0,
+         .duration = 2},
+        {.name = "measure1",
+         .entryType = PerformanceEntryType::MEASURE,
+         .startTime = 0,
+         .duration = 4},
+        {.name = "mark1",
+         .entryType = PerformanceEntryType::MARK,
+         .startTime = 1,
+         .duration = 0},
+        {.name = "measure2",
+         .entryType = PerformanceEntryType::MEASURE,
+         .startTime = 1,
+         .duration = 1},
+        {.name = "measure3",
+         .entryType = PerformanceEntryType::MEASURE,
+         .startTime = 1,
+         .duration = 5},
+        {.name = "measure4",
+         .entryType = PerformanceEntryType::MEASURE,
+         .startTime = 1.5,
+         .duration = 0.5},
+        {.name = "mark2",
+         .entryType = PerformanceEntryType::MARK,
+         .startTime = 2,
+         .duration = 0}};
+    ASSERT_EQ(expected, allEntries);
+  }
+
+  {
+    const auto marks =
+        toSorted(reporter->getEntries(PerformanceEntryType::MARK));
+    const std::vector<PerformanceEntry> expected = {
+        {.name = "common_name",
+         .entryType = PerformanceEntryType::MARK,
+         .startTime = 0,
+         .duration = 0},
+        {.name = "mark1",
+         .entryType = PerformanceEntryType::MARK,
+         .startTime = 1,
+         .duration = 0},
+        {.name = "mark2",
+         .entryType = PerformanceEntryType::MARK,
+         .startTime = 2,
+         .duration = 0}};
+    ASSERT_EQ(expected, marks);
+  }
+
+  {
+    const auto measures =
+        toSorted(reporter->getEntries(PerformanceEntryType::MEASURE));
+    const std::vector<PerformanceEntry> expected = {
+        {.name = "common_name",
+         .entryType = PerformanceEntryType::MEASURE,
+         .startTime = 0,
+         .duration = 2},
+        {.name = "measure1",
+         .entryType = PerformanceEntryType::MEASURE,
+         .startTime = 0,
+         .duration = 4},
+        {.name = "measure2",
+         .entryType = PerformanceEntryType::MEASURE,
+         .startTime = 1,
+         .duration = 1},
+        {.name = "measure3",
+         .entryType = PerformanceEntryType::MEASURE,
+         .startTime = 1,
+         .duration = 5},
+        {.name = "measure4",
+         .entryType = PerformanceEntryType::MEASURE,
+         .startTime = 1.5,
+         .duration = 0.5}};
+    ASSERT_EQ(expected, measures);
+  }
+
+  {
+    const std::vector<PerformanceEntry> expected = {
+        {.name = "common_name",
+         .entryType = PerformanceEntryType::MARK,
+         .startTime = 0}};
+    const auto commonName =
+        reporter->getEntries(PerformanceEntryType::MARK, "common_name");
+    ASSERT_EQ(expected, commonName);
+  }
+
+  {
+    const std::vector<PerformanceEntry> expected = {
+        {.name = "common_name",
+         .entryType = PerformanceEntryType::MEASURE,
+         .startTime = 0,
+         .duration = 2}};
+    const auto commonName =
+        reporter->getEntries(PerformanceEntryType::MEASURE, "common_name");
+    ASSERT_EQ(expected, commonName);
+  }
 }
 
-TEST(PerformanceEntryReporter, PerformanceEntryReporterTestClearEntries) {
+TEST(PerformanceEntryReporter, PerformanceEntryReporterTestClearMarks) {
   auto reporter = PerformanceEntryReporter::getInstance();
-
-  reporter->stopReporting();
   reporter->clearEntries();
 
-  reporter->startReporting(PerformanceEntryType::MARK);
-  reporter->startReporting(PerformanceEntryType::MEASURE);
-
-  reporter->mark("common_name", 0.0);
-  reporter->mark("mark1", 1.0);
-  reporter->mark("mark2", 2.0);
-
-  reporter->measure("common_name", 0.0, 2.0);
-  reporter->measure("measure1", 0.0, 2.0, 4.0);
-  reporter->measure("measure2", 0.0, 0.0, std::nullopt, "mark1", "mark2");
-  reporter->measure("measure3", 0.0, 0.0, 5.0, "mark1");
-  reporter->measure("measure4", 1.5, 0.0, std::nullopt, std::nullopt, "mark2");
-
-  reporter->clearEntries(std::nullopt, "common_name");
-  auto e1 = reporter->getEntries();
-
-  ASSERT_EQ(6, e1.size());
-  ASSERT_EQ(
-      std::vector<std::string>(
-          {"mark1", "mark2", "measure1", "measure2", "measure3", "measure4"}),
-      getNames(e1));
-
-  reporter->clearEntries(PerformanceEntryType::MARK, "mark1");
-  auto e2 = reporter->getEntries();
-
-  ASSERT_EQ(5, e2.size());
-  ASSERT_EQ(
-      std::vector<std::string>(
-          {"mark2", "measure1", "measure2", "measure3", "measure4"}),
-      getNames(e2));
-
-  reporter->clearEntries(PerformanceEntryType::MEASURE);
-  auto e3 = reporter->getEntries();
-
-  ASSERT_EQ(1, e3.size());
-  ASSERT_EQ(std::vector<std::string>({"mark2"}), getNames(e3));
+  reporter->reportMark("common_name", 0);
+  reporter->reportMark("mark1", 1);
+  reporter->reportMark("mark1", 2.1);
+  reporter->reportMark("mark2", 2);
+
+  reporter->reportMeasure("common_name", 0, 2);
+  reporter->reportMeasure("measure1", 0, 2, 4);
+  reporter->reportMeasure("measure2", 0, 0, std::nullopt, "mark1", "mark2");
+  reporter->reportMeasure("measure3", 0, 0, 5, "mark1");
+  reporter->reportMeasure(
+      "measure4", 1.5, 0, std::nullopt, std::nullopt, "mark2");
+
+  reporter->clearEntries(PerformanceEntryType::MARK, "common_name");
+
+  {
+    auto entries = toSorted(reporter->getEntries(PerformanceEntryType::MARK));
+    std::vector<PerformanceEntry> expected = {
+        {.name = "mark1",
+         .entryType = PerformanceEntryType::MARK,
+         .startTime = 1,
+         .duration = 0},
+        {.name = "mark2",
+         .entryType = PerformanceEntryType::MARK,
+         .startTime = 2,
+         .duration = 0},
+        {.name = "mark1",
+         .entryType = PerformanceEntryType::MARK,
+         .startTime = 2.1,
+         .duration = 0},
+    };
+    ASSERT_EQ(expected, entries);
+  }
+
+  reporter->clearEntries(PerformanceEntryType::MARK);
+
+  {
+    auto entries = reporter->getEntries(PerformanceEntryType::MARK);
+    ASSERT_EQ(entries.size(), 0);
+  }
 
   reporter->clearEntries();
-  auto e4 = reporter->getEntries();
 
-  ASSERT_EQ(0, e4.size());
+  {
+    auto entries = reporter->getEntries();
+    ASSERT_EQ(entries.size(), 0);
+  }
 }