// Define main function as an entry to these tests. // These test functions cannot use the main() defined for unittests because they // call runGlobalInitializers(). The embedded C API calls mongoDbMain() which // calls runGlobalInitializers(). int main(int argc, char** argv, char** envp) { moe::OptionsParser parser; moe::Environment environment; moe::OptionSection options; std::map<std::string, std::string> env; options.addOptionChaining( "tempPath", "tempPath", moe::String, "directory to place mongo::TempDir subdirectories"); std::vector<std::string> argVector(argv, argv + argc); mongo::Status ret = parser.run(options, argVector, env, &environment); if (!ret.isOK()) { std::cerr << options.helpString(); return EXIT_FAILURE; } if (environment.count("tempPath")) { ::mongo::unittest::TempDir::setTempPath(environment["tempPath"].as<std::string>()); } ::mongo::clearSignalMask(); ::mongo::setupSynchronousSignalHandlers(); ::mongo::serverGlobalParams.noUnixSocket = true; ::mongo::unittest::setupTestLogger(); StatusPtr status(mongo_embedded_v1_status_create()); mongoc_init(); global_lib_handle = mongo_embedded_v1_lib_init(nullptr, status.get()); if (global_lib_handle == nullptr) { std::cerr << "Error: " << mongo_embedded_v1_status_get_explanation(status.get()); return EXIT_FAILURE; } auto result = ::mongo::unittest::Suite::run(std::vector<std::string>(), "", 1); if (mongo_embedded_v1_lib_fini(global_lib_handle, status.get()) != MONGO_EMBEDDED_V1_SUCCESS) { std::cerr << "Error: " << mongo_embedded_v1_status_get_explanation(status.get()); return EXIT_FAILURE; } mongoc_cleanup(); globalTempDir.reset(); mongo::quickExit(result); }
// Define main function as an entry to these tests. // These test functions cannot use the main() defined for unittests because they // call runGlobalInitializers(). The embedded C API calls mongoDbMain() which // calls runGlobalInitializers(). int main(int argc, char** argv, char** envp) { moe::OptionsParser parser; moe::Environment environment; moe::OptionSection options; std::map<std::string, std::string> env; auto ret = mongo::embedded::addMongocEmbeddedTestOptions(&options); if (!ret.isOK()) { std::cerr << ret << std::endl; return EXIT_FAILURE; } std::vector<std::string> argVector(argv, argv + argc); ret = parser.run(options, argVector, env, &environment); if (!ret.isOK()) { std::cerr << options.helpString(); return EXIT_FAILURE; } if (environment.count("tempPath")) { ::mongo::unittest::TempDir::setTempPath(environment["tempPath"].as<std::string>()); } ::mongo::clearSignalMask(); ::mongo::setupSynchronousSignalHandlers(); ::mongo::serverGlobalParams.noUnixSocket = true; // See comment by the same code block in mongo_embedded_test.cpp const char* null_argv[1] = {nullptr}; ret = mongo::runGlobalInitializers(0, null_argv, nullptr); if (!ret.isOK()) { std::cerr << "Global initilization failed"; return EXIT_FAILURE; } ret = mongo::runGlobalDeinitializers(); if (!ret.isOK()) { std::cerr << "Global deinitilization failed"; return EXIT_FAILURE; } StatusPtr status(mongo_embedded_v1_status_create()); mongoc_init(); mongo_embedded_v1_init_params params; params.log_flags = MONGO_EMBEDDED_V1_LOG_STDOUT; params.log_callback = nullptr; params.log_user_data = nullptr; global_lib_handle = mongo_embedded_v1_lib_init(¶ms, status.get()); if (global_lib_handle == nullptr) { std::cerr << "Error: " << mongo_embedded_v1_status_get_explanation(status.get()); return EXIT_FAILURE; } auto result = ::mongo::unittest::Suite::run(std::vector<std::string>(), "", 1); if (mongo_embedded_v1_lib_fini(global_lib_handle, status.get()) != MONGO_EMBEDDED_V1_SUCCESS) { std::cerr << "Error: " << mongo_embedded_v1_status_get_explanation(status.get()); return EXIT_FAILURE; } mongoc_cleanup(); globalTempDir.reset(); mongo::quickExit(result); }
// Define main function as an entry to these tests. // These test functions cannot use the main() defined for unittests because they // call runGlobalInitializers(). The embedded C API calls mongoDbMain() which // calls runGlobalInitializers(). int main(const int argc, const char* const* const argv) { moe::Environment environment; moe::OptionSection options; auto ret = mongo::embedded::addMongoEmbeddedTestOptions(&options); if (!ret.isOK()) { std::cerr << ret << std::endl; return EXIT_FAILURE; } std::map<std::string, std::string> env; ret = moe::OptionsParser().run( options, std::vector<std::string>(argv, argv + argc), env, &environment); if (!ret.isOK()) { std::cerr << options.helpString(); return EXIT_FAILURE; } if (environment.count("tempPath")) { ::mongo::unittest::TempDir::setTempPath(environment["tempPath"].as<std::string>()); } ::mongo::clearSignalMask(); ::mongo::setupSynchronousSignalHandlers(); ::mongo::serverGlobalParams.noUnixSocket = true; // Allocate an error descriptor for use in non-configured tests const auto status = makeStatusPtr(); mongo::setTestCommandsEnabled(true); // Perform one cycle of global initialization/deinitialization before running test. This will // make sure everything that is needed is setup for the unittest infrastructure. // The reason this works is that the unittest system relies on other systems being initialized // through global init and deinitialize just deinitializes systems that explicitly supports // deinit leaving the systems unittest needs initialized. const char* null_argv[1] = {nullptr}; ret = mongo::runGlobalInitializers(0, null_argv, nullptr); if (!ret.isOK()) { std::cerr << "Global initilization failed"; return EXIT_FAILURE; } ret = mongo::runGlobalDeinitializers(); if (!ret.isOK()) { std::cerr << "Global deinitilization failed"; return EXIT_FAILURE; } // Check so we can initialize the library without providing init params mongo_embedded_v1_lib* lib = mongo_embedded_v1_lib_init(nullptr, status.get()); if (lib == nullptr) { std::cerr << "mongo_embedded_v1_init() failed with " << mongo_embedded_v1_status_get_error(status.get()) << ": " << mongo_embedded_v1_status_get_explanation(status.get()) << std::endl; return EXIT_FAILURE; } if (mongo_embedded_v1_lib_fini(lib, status.get()) != MONGO_EMBEDDED_V1_SUCCESS) { std::cerr << "mongo_embedded_v1_fini() failed with " << mongo_embedded_v1_status_get_error(status.get()) << ": " << mongo_embedded_v1_status_get_explanation(status.get()) << std::endl; return EXIT_FAILURE; } // Initialize the library with a log callback and test so we receive at least one callback // during the lifetime of the test mongo_embedded_v1_init_params params{}; bool receivedCallback = false; params.log_flags = MONGO_EMBEDDED_V1_LOG_STDOUT | MONGO_EMBEDDED_V1_LOG_CALLBACK; params.log_callback = [](void* user_data, const char* message, const char* component, const char* context, int severety) { ASSERT(message); ASSERT(component); *reinterpret_cast<bool*>(user_data) = true; }; params.log_user_data = &receivedCallback; lib = mongo_embedded_v1_lib_init(¶ms, nullptr); if (lib == nullptr) { std::cerr << "mongo_embedded_v1_init() failed with " << mongo_embedded_v1_status_get_error(status.get()) << ": " << mongo_embedded_v1_status_get_explanation(status.get()) << std::endl; } // Attempt to create an embedded instance to make sure something gets logged. This will probably // fail but that's fine. mongo_embedded_v1_instance* instance = mongo_embedded_v1_instance_create(lib, nullptr, nullptr); if (instance) { mongo_embedded_v1_instance_destroy(instance, nullptr); } if (mongo_embedded_v1_lib_fini(lib, nullptr) != MONGO_EMBEDDED_V1_SUCCESS) { std::cerr << "mongo_embedded_v1_fini() failed with " << mongo_embedded_v1_status_get_error(status.get()) << ": " << mongo_embedded_v1_status_get_explanation(status.get()) << std::endl; } if (!receivedCallback) { std::cerr << "Did not get a log callback." << std::endl; return EXIT_FAILURE; } const auto result = ::mongo::unittest::Suite::run(std::vector<std::string>(), "", 1); globalTempDir.reset(); mongo::quickExit(result); }