Method runUnitTests

fdbserver/workloads/UnitTests.actor.cpp:118–184

	}

	ACTOR static Future<Void> runUnitTests(UnitTestWorkload* self) {
		state std::vector<UnitTest*> tests;

		for (auto test = g_unittests.tests; test != nullptr; test = test->next) {
			if (StringRef(test->name).startsWith(self->testPattern)) {
				++self->testsAvailable;
				tests.push_back(test);
			}
		}

		std::sort(tests.begin(), tests.end(), [](auto lhs, auto rhs) {
			return std::string_view(lhs->name) < std::string_view(rhs->name);
		});

		fprintf(stdout, "Found %zu tests\n", tests.size());

		if (tests.size() == 0) {
			TraceEvent(SevError, "NoMatchingUnitTests").detail("TestPattern", self->testPattern);
			++self->testsFailed;
			return Void();
		}

		deterministicRandom()->randomShuffle(tests);
		if (self->testRunLimit > 0 && tests.size() > self->testRunLimit)
			tests.resize(self->testRunLimit);

		state std::vector<UnitTest*>::iterator t;
		for (t = tests.begin(); t != tests.end(); ++t) {
			state UnitTest* test = *t;
			printf("Testing %s\n", test->name);

			TraceEvent(SevInfo, "RunningUnitTest")
			    .detail("Name", test->name)
			    .detail("File", test->file)
			    .detail("Line", test->line);

			state Error result = success();
			state double start_now = now();
			state double start_timer = timer();

			platform::createDirectory(self->testParams.getDataDir());
			try {
				wait(test->func(self->testParams));
			} catch (Error& e) {
				++self->testsFailed;
				result = e;
			}
			if (self->cleanupAfterTests) {
				platform::eraseDirectoryRecursive(self->testParams.getDataDir());
			}
			++self->testsExecuted;
			double wallTime = timer() - start_timer;
			double simTime = now() - start_now;

			self->totalWallTime += wallTime;
			self->totalSimTime += simTime;
			TraceEvent(result.code() != error_code_success ? SevError : SevInfo, "UnitTest")
			    .errorUnsuppressed(result)