setStartTime(getUnixTime());

setToolType(ToolType::TEST);

if (osquery::isPlatform(PlatformType::TYPE_OSX)) {

kTestWorkingDirectory = "/private/tmp/osquery-tests";

} else {

kTestWorkingDirectory =

(fs::temp_directory_path() / "osquery-tests").string();

}

if (osquery::isPlatform(PlatformType::TYPE_WINDOWS)) {

kTestDataPath = "../" + kTestDataPath;

}

// Allow unit test execution from anywhere in the osquery source/build tree.

if (fs::exists("test_data/test_inline_pack.conf")) {

// If the execution occurs within the build/shared directory and shared

// is pointing to a tmp build directory. See #3414.

kTestDataPath = "test_data/";

} else if (fs::exists("../test_data/test_inline_pack.conf")) {

// ctest executes from the osquery subdirectory. If this is a build/shared

// link then the test_data directory links to the source repo.

kTestDataPath = "../test_data/";

} else {

while (kTestDataPath.find("tools") != 0) {

if (!fs::exists(kTestDataPath + "test_inline_pack.conf")) {

kTestDataPath = kTestDataPath.substr(3, kTestDataPath.size());

} else {

break;

}

}

}

// The tests will fail randomly without test data.

if (!fs::exists(kTestDataPath)) {

throw std::runtime_error("Cannot find test data path");

}

// Seed the random number generator, some tests generate temporary files

// ports, sockets, etc using random numbers.

std::srand(static_cast<unsigned int>(

chrono_clock::now().time_since_epoch().count()));

// Set safe default values for path-based flags.

// Specific unittests may edit flags temporarily.

kTestWorkingDirectory += std::to_string(platformGetUid()) + "/";

kFakeDirectory = kTestWorkingDirectory + kFakeDirectoryName;

fs::remove_all(kTestWorkingDirectory);

fs::create_directories(kTestWorkingDirectory);

FLAGS_database_path = kTestWorkingDirectory + "unittests.db";

FLAGS_extensions_socket = kTestWorkingDirectory + "unittests.em";

FLAGS_extensions_autoload = kTestWorkingDirectory + "unittests-ext.load";

FLAGS_disable_logging = true;

platformSetup();

registryAndPluginInit();

initDatabasePluginForTesting();

if (init_users) {

std::promise<void> users_cache_promise;

GlobalUsersGroupsCache::global_users_cache_future_ =

users_cache_promise.get_future();

Dispatcher::addService(std::make_shared<UsersService>(

std::move(users_cache_promise),

GlobalUsersGroupsCache::global_users_cache_));

}

if (init_groups) {

std::promise<void> groups_cache_promise;

GlobalUsersGroupsCache::global_groups_cache_future_ =

groups_cache_promise.get_future();

Dispatcher::addService(std::make_shared<GroupsService>(

std::move(groups_cache_promise),

GlobalUsersGroupsCache::global_groups_cache_));

}

if (deinit_users) {

GlobalUsersGroupsCache::global_users_cache_->clear();

GlobalUsersGroupsCache::global_users_cache_future_ = {};

}

if (deinit_groups) {

GlobalUsersGroupsCache::global_groups_cache_->clear();

GlobalUsersGroupsCache::global_groups_cache_future_ = {};

}

ScheduledQuery sq(

"path_pack",

"bin",

"SELECT filename FROM fs WHERE path = '/bin' ORDER BY filename");

sq.interval = 5;

return sq;

auto vtc = std::make_shared<VirtualTableContent>();

QueryContext context(vtc);

RowGenerator::pull_type generator(std::bind(&EventSubscriberPlugin::genTable,

sub,

std::placeholders::_1,

std::move(context)));

TableRows results;

if (!generator) {

return results;

}

while (generator) {

results.push_back(generator.get());

generator();

}

return results;