Framework::ReturnCode Framework::list() const {
std::stringstream sStr;
ListTests list_tests;
list_tests(sStr, get_registry()->makeTest());
std::cout << sStr.str() << std::endl;
return SUCCESS;
}
/* static */
void GeneratorRegistry::unregister_factory(const std::string &name) {
GeneratorRegistry ®istry = get_registry();
std::lock_guard<std::mutex> lock(registry.mutex);
internal_assert(registry.factories.find(name) != registry.factories.end())
<< "Generator not found: " << name;
registry.factories.erase(name);
}
/* static */
std::vector<void *> ObjectInstanceRegistry::instances_in_range(void *start, size_t size,
Kind kind) {
std::vector<void *> results;
#if __cplusplus > 199711L || _MSC_VER >= 1800
ObjectInstanceRegistry ®istry = get_registry();
std::lock_guard<std::mutex> lock(registry.mutex);
std::map<uintptr_t, InstanceInfo>::const_iterator it =
registry.instances.lower_bound((uintptr_t)start);
uintptr_t limit_ptr = ((uintptr_t)start) + size;
while (it != registry.instances.end() && it->first < limit_ptr) {
if (it->second.kind == kind) {
results.push_back(it->second.subject_ptr);
}
if (it->first > (uintptr_t)start && it->second.size != 0) {
// Skip over containers that we enclose
it = registry.instances.lower_bound(it->first + it->second.size);
} else {
it++;
}
}
#endif
return results;
}
Framework::ReturnCode Framework::run() {
Ensures(m_program_options.parse_options());
if (m_program_options.asked_for_help()) {
return help();
}
if (m_program_options.asked_for_list()) {
return list();
}
CPPUNIT_NS::TextUi::TestRunner runner;
if (m_program_options.asked_to_run_only_some_tests()) {
Ensures(combine_tests_subset(runner));
} else if (m_program_options.asked_for_regtest()) {
Ensures(combine_regtest_subset(runner));
} else {
runner.addTest(get_registry()->makeTest());
}
CPPUNIT_NS::TestResult controller;
CPPUNIT_NS::TestResultCollector result;
controller.addListener(&result);
CPPUNIT_NS::BriefTestProgressListener progress;
controller.addListener(&progress);
runner.run(controller);
CPPUNIT_NS::CompilerOutputter outputter(&result, std::cerr);
outputter.write();
return result.wasSuccessful() ? SUCCESS : FAILURE;
}
/* static */
std::unique_ptr<GeneratorBase> GeneratorRegistry::create(const std::string &name,
const GeneratorParamValues ¶ms) {
GeneratorRegistry ®istry = get_registry();
std::lock_guard<std::mutex> lock(registry.mutex);
auto it = registry.factories.find(name);
user_assert(it != registry.factories.end()) << "Generator not found: " << name;
return it->second->create(params);
}
/* static */
std::vector<std::string> GeneratorRegistry::enumerate() {
GeneratorRegistry ®istry = get_registry();
std::lock_guard<std::mutex> lock(registry.mutex);
std::vector<std::string> result;
for (const auto& i : registry.factories) {
result.push_back(i.first);
}
return result;
}
/* static */
void GeneratorRegistry::register_factory(const std::string &name,
std::unique_ptr<GeneratorFactory> factory) {
user_assert(is_valid_name(name)) << "Invalid Generator name: " << name;
GeneratorRegistry ®istry = get_registry();
std::lock_guard<std::mutex> lock(registry.mutex);
internal_assert(registry.factories.find(name) == registry.factories.end())
<< "Duplicate Generator name: " << name;
registry.factories[name] = std::move(factory);
}
/* static */
void ObjectInstanceRegistry::unregister_instance(void *this_ptr) {
#if __cplusplus > 199711L || _MSC_VER >= 1800
ObjectInstanceRegistry ®istry = get_registry();
std::lock_guard<std::mutex> lock(registry.mutex);
uintptr_t key = (uintptr_t)this_ptr;
std::map<uintptr_t, InstanceInfo>::iterator it = registry.instances.find(key);
internal_assert(it != registry.instances.end());
if (it->second.registered_for_introspection) {
Introspection::deregister_heap_object(this_ptr, it->second.size);
}
registry.instances.erase(it);
#endif
}
/* static */
void ObjectInstanceRegistry::register_instance(void *this_ptr, size_t size, Kind kind,
void *subject_ptr, const void *introspection_helper) {
#if __cplusplus > 199711L || _MSC_VER >= 1800
ObjectInstanceRegistry ®istry = get_registry();
std::lock_guard<std::mutex> lock(registry.mutex);
uintptr_t key = (uintptr_t)this_ptr;
internal_assert(registry.instances.find(key) == registry.instances.end());
if (introspection_helper) {
registry.instances[key] = InstanceInfo(size, kind, subject_ptr, true);
Introspection::register_heap_object(this_ptr, size, introspection_helper);
} else {
registry.instances[key] = InstanceInfo(size, kind, subject_ptr, false);
}
#endif
}
bool Framework::combine_regtest_subset(CPPUNIT_NS::TextUi::TestRunner &runner) const {
FindRegTest find_regtest;
try {
auto tests_to_run = find_regtest(m_program_options.get_regtest(), get_registry()->makeTest());
for (auto &test : tests_to_run) {
runner.addTest(test);
}
} catch (const std::exception &e) {
std::cerr << "Cannot match your regexp: " << e.what() << std::endl;
return false;
}
return true;
}
bool Framework::combine_tests_subset(CPPUNIT_NS::TextUi::TestRunner &runner) const {
FindTest find_test;
for (auto &name : m_program_options.get_tests_to_run()) {
CPPUNIT_NS::Test *test = find_test(name, get_registry()->makeTest());
if (test == nullptr) {
std::cerr << "Cannot find test '" << name << "'!" << std::endl;
return false;
}
runner.addTest(test);
}
return true;
}
s8 wl_display_req(struct client *c,struct msg *m)
{
s8 r;
switch(m->req_op){
case WL_DISPLAY_GET_REGISTRY:
r=get_registry(c,m);
break;
case WL_DISPLAY_SYNC:
r=sync(c,m);
break;
default:
PERR("client(%d):fatal:display:request unknown opcode %u\n",c->so,
m->req_op);
r=LWL_ERR;
}
return r;
}