test: extend coverage of testJobSystem

tests/testJobSystem.cpp

@@ -313,3 +313,89 @@ VF_TEST(highPriorityJobsAreServedBeforeLowOnesOnOneWorker) {
     JobHandle normal = jobs.submit(record(2), JobPriority::Normal);
     JobHandle high = jobs.submit(record(1), JobPriority::High);
 
+    release.open();
+    blocker.wait();
+    low.wait();
+    normal.wait();
+    high.wait();
+    jobs.waitAll();
+
+    CHECK_EQ(order.size(), static_cast<std::size_t>(3));
+    CHECK_EQ(order[0], 1);
+    CHECK_EQ(order[1], 2);
+    CHECK_EQ(order[2], 3);
+}
+
+VF_TEST(statsCountExecutedJobsAndPeakOccupancy) {
+    JobSystem jobs(4);
+    JobBatch batch;
+    for (int i = 0; i < 120; ++i) batch.add(jobs.submit([] {}));
+    batch.wait();
+    jobs.waitAll();
+
+    JobStats counted = jobs.stats();
+    CHECK_EQ(counted.submitted, static_cast<std::uint64_t>(120));
+    CHECK_EQ(counted.executed, static_cast<std::uint64_t>(120));
+    CHECK_EQ(counted.queuePops, static_cast<std::uint64_t>(120));
+    CHECK_EQ(counted.failed, static_cast<std::uint64_t>(0));
+    CHECK(counted.peakBusyWorkers >= 1u);
+    CHECK(counted.peakBusyWorkers <= 4u);
+    CHECK(counted.peakQueueDepth >= 1u);
+
+    jobs.resetStats();
+    CHECK_EQ(jobs.stats().executed, static_cast<std::uint64_t>(0));
+}
+
+VF_TEST(waitAllReturnsOnlyWithAnEmptyQueue) {
+    JobSystem jobs(4);
+    std::atomic<int> done{0};
+    for (int i = 0; i < 400; ++i) jobs.submit([&done] { done.fetch_add(1); });
+    jobs.waitAll();
+    CHECK_EQ(done.load(), 400);
+    CHECK_EQ(jobs.stats().executed, static_cast<std::uint64_t>(400));
+}
+
+VF_TEST(destructorDrainsQueuedJobsWithoutHanging) {
+    std::atomic<int> done{0};
+    {
+        JobSystem jobs(4);
+        for (int i = 0; i < 500; ++i) jobs.submit([&done] { done.fetch_add(1); });
+    }
+    CHECK_EQ(done.load(), 500);
+}
+
+VF_TEST(jobsSubmittedFromInsideAJobStillGetDrained) {
+    for (unsigned threads : {0u, 3u}) {
+        JobSystem jobs(threads);
+        std::atomic<int> leaves{0};
+        for (int i = 0; i < 8; ++i) {
+            jobs.submit([&jobs, &leaves] {
+                for (int k = 0; k < 4; ++k) jobs.submit([&leaves] { leaves.fetch_add(1); });
+            });
+        }
+        jobs.waitAll();
+        CHECK_EQ(leaves.load(), 32);
+        CHECK_EQ(jobs.stats().executed, static_cast<std::uint64_t>(40));
+    }
+}
+
+VF_TEST(topologicalOrderIsAFunctionOfTheGraphAlone) {
+    JobGraph graph;
+    for (int i = 0; i < 6; ++i) graph.addNode("n" + std::to_string(i), [] {});
+    graph.addDependency(2, 5);
+    graph.addDependency(3, 2);
+    graph.addDependency(4, 1);
+
+    std::vector<std::size_t> first = graph.topologicalOrder();
+    std::vector<std::size_t> second = graph.topologicalOrder();
+    CHECK_EQ(first.size(), static_cast<std::size_t>(6));
+    CHECK(first == second);
+    for (std::size_t i = 0; i < first.size(); ++i) {
+        for (std::size_t dep : graph.nodeAt(first[i]).dependencies) {
+            std::size_t depPosition = 0;
+            for (std::size_t k = 0; k < first.size(); ++k)
+                if (first[k] == dep) depPosition = k;
+            CHECK(depPosition < i);
+        }
+    }
+}