This PR builds on #9495 to unit test the CCheckQueue for correctness.
The cases covered in these tests are:
0@@ -0,0 +1,395 @@
1+// Copyright (c) 2012-2015 The Bitcoin Core developers
16+#include <mutex>
17+
18+#include <unordered_set>
19+#include <memory>
20+#include "random.h"
21+BOOST_FIXTURE_TEST_SUITE(checkqueue_tests, TestingSetup)
117+/** This test case checks that the CCheckQueue works properly
118+ * with each specified size_t Checks pushed.
119+ */
120+void Correct_Queue_range(std::vector<size_t> range)
121+{
122+ auto small_queue = std::shared_ptr<Correct_Queue>(new Correct_Queue {128});
130+ {
131+ CCheckQueueControl<FakeCheckCheckCompletion> control(small_queue.get());
132+ while (total) {
133+ size_t r = GetRand(10);
134+ std::vector<FakeCheckCheckCompletion> vChecks;
135+ for (size_t k = 0; k < r && total; k++) {
236+ vChecks.emplace_back(k == 99 && end_fails);
237+ control.Add(vChecks);
238+ }
239+ result[end_fails ? 0 : 1] = control.Wait();
240+ }
241+ BOOST_CHECK(!result[0]);
120+void Correct_Queue_range(std::vector<size_t> range)
121+{
122+ auto small_queue = std::shared_ptr<Correct_Queue>(new Correct_Queue {128});
123+ boost::thread_group tg;
124+ for (auto x = 0; x < nScriptCheckThreads; ++x) {
125+ tg.create_thread([=]{small_queue->Thread();});
270+ }
271+ }
272+ bool r = true;
273+ for (size_t i = 0; i < COUNT; ++i)
274+ r = r && UniqueCheck::results.count(i) == 1;
275+ BOOST_REQUIRE(r);
278+}
279+
280+
281+// Test that blocks which might allocate lots of memory free their memory agressively.
282+//
283+// This test attempts to catch a pathalogical case where by lazily freeing
282+//
283+// This test attempts to catch a pathalogical case where by lazily freeing
284+// checks might mean leaving a check un-swapped out, and decreasing by 1 each
285+// time could leave the data hanging across a sequence of blocks.
286+//
287+// This test (failing) is dependent on not being able to handle
338+ // Try waiting a second (which should be plenty of time to reach the hang
339+ // point in t0)
340+ //
341+ // Note that this cannot cause a spurious failure, only could mean that
342+ // the test doesn't actually end up checking that control waited.
343+ MilliSleep(1000);
399- // Agressively check that we can never aquire the lock, once
400- // the thread has stopped check that we never got it.
401- while (!done && !fails2) {
402- fails2 = queue->ControlMutex.try_lock();
403+ std::mutex m;
404+ bool has_lock {false};
326+ vChecks.emplace_back(total == 0 || total == i || total == i/2);
327+ }
328+ control.Add(vChecks);
329+ }
330+ }
331+ BOOST_REQUIRE(MemoryCheck::fake_allocated_memory == 0);
88+ fake_allocated_memory += 1;
89+ }
90+ };
91+ ~MemoryCheck(){
92+ if (b) {
93+ fake_allocated_memory += 1;
fake_allocated_memory -= 1
241+// Test that a block validation which fails does not interfere with
242+// future blocks, ie, the bad state is cleared.
243+BOOST_AUTO_TEST_CASE(test_CheckQueue_Recovers_From_Failure)
244+{
245+ auto fail_queue = std::unique_ptr<Failing_Queue>(new Failing_Queue {QUEUE_BATCH_SIZE});
246+ std::array<FailingCheck, 100> checks;
357+ {
358+ std::unique_lock<std::mutex> l(FrozenCleanupCheck::m);
359+ // Wait until the queue has finished all jobs and frozen
360+ FrozenCleanupCheck::cv.wait(l, [](){return FrozenCleanupCheck::nFrozen == 1;});
361+ // Try to get control of the queue a bunch of times
362+ for (auto x = 0; x < 100; ++x) {
!fails && x < 100 here and simply fails = queue->ControlMutex.try_lock(); would break iteration on first fail rather than iterate over all 100 (e.g. if first try_lock() fails).
419+ cv.wait(l, [&]{return done_ack;});
420+ });
421+ // Wait for thread to get the lock
422+ cv.wait(l, [&](){return has_lock;});
423+ bool fails = false;
424+ for (auto x = 0; x < 100; ++x) {
!fails && x < 100 as above.
Fixed the issues that @kallewoof raised, and squashed.
Unsquashed preserved here https://github.com/JeremyRubin/bitcoin/tree/checkqueue-tests-unsquashed.
utACK 96c7f2c
I’m a bit concerned about non-deterministic behavior in tests as this tends to be a pain when you do run into a problem. Or is this fixed seed / PRNG so that the numbers are always the same each time? (for GetRand())