Skip to content

Commit c1632a4

Browse files
tgoynetgoyne
committed
Fix many tests which used the default scheduler on background threads
The libuv scheduler used in tests on non-Apple platforms does not support this.
1 parent fb46803 commit c1632a4

File tree

8 files changed

+137
-162
lines changed

8 files changed

+137
-162
lines changed

‎test/object-store/c_api/c_api.cpp‎

Lines changed: 4 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -4360,13 +4360,11 @@ TEST_CASE("C API - properties", "[c_api]") {
43604360
auto results = cptr_checked(realm_object_find_all(realm, class_foo.key));
43614361

43624362
SECTION("wrong thread") {
4363-
std::thread t{[&]() {
4363+
JoiningThread{[&] {
43644364
realm_value_t val;
43654365
CHECK(!realm_get_value(foo_obj.get(), foo_int_key, &val));
43664366
CHECK_ERR(RLM_ERR_WRONG_THREAD);
43674367
}};
4368-
4369-
t.join();
43704368
}
43714369

43724370
SECTION("thread-safe references") {
@@ -4378,8 +4376,9 @@ TEST_CASE("C API - properties", "[c_api]") {
43784376
auto results_tsr = cptr_checked(realm_create_thread_safe_reference(results.get()));
43794377

43804378
SECTION("resolve") {
4381-
std::thread t{[&]() {
4379+
JoiningThread{[&] {
43824380
auto config = make_config(test_file.path.c_str());
4381+
config->scheduler = util::Scheduler::make_dummy();
43834382
auto realm2 = cptr_checked(realm_open(config.get()));
43844383
auto foo_obj2 =
43854384
cptr_checked(realm_object_from_thread_safe_reference(realm2.get(), foo_obj_tsr.get()));
@@ -4400,8 +4399,6 @@ TEST_CASE("C API - properties", "[c_api]") {
44004399
CHECK(realm_results_count(results2.get(), &count));
44014400
CHECK(count == 1);
44024401
}};
4403-
4404-
t.join();
44054402
}
44064403

44074404
SECTION("resolve in frozen") {
@@ -6005,7 +6002,7 @@ TEST_CASE("C API - binding callback thread observer", "[sync][c_api]") {
60056002
REQUIRE(observer_ptr->has_handle_error());
60066003
REQUIRE(observer_ptr->test_get_userdata_ptr() == &bcto_user_data);
60076004

6008-
auto test_thread = std::thread([&]() {
6005+
JoiningThread([&] {
60096006
auto bcto_ptr = std::static_pointer_cast<realm::BindingCallbackThreadObserver>(
60106007
config->default_socket_provider_thread_observer);
60116008
REQUIRE(bcto_ptr);
@@ -6016,9 +6013,6 @@ TEST_CASE("C API - binding callback thread observer", "[sync][c_api]") {
60166013
REQUIRE(bcto_ptr->handle_error(MultipleSyncAgents()));
60176014
});
60186015

6019-
// Wait for the thread to exit
6020-
test_thread.join();
6021-
60226016
REQUIRE(bcto_user_data.thread_create_called);
60236017
REQUIRE(bcto_user_data.thread_on_error_message.find(
60246018
"Multiple sync agents attempted to join the same session") != std::string::npos);

‎test/object-store/realm.cpp‎

Lines changed: 21 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -248,7 +248,6 @@ TEST_CASE("SharedRealm: get_shared_realm()") {
248248
}
249249
}
250250

251-
252251
// Windows doesn't use fifos
253252
#ifndef _WIN32
254253
SECTION("should be able to set a FIFO fallback path") {
@@ -461,6 +460,7 @@ TEST_CASE("SharedRealm: get_shared_realm()") {
461460
REQUIRE(realm4->schema().size() == 1);
462461
REQUIRE(realm4->schema().find("object") != realm4->schema().end());
463462
}
463+
464464
#ifndef _WIN32
465465
SECTION("should throw when creating the notification pipe fails") {
466466
// The ExternalCommitHelper implementation on Windows doesn't rely on FIFOs
@@ -480,21 +480,23 @@ TEST_CASE("SharedRealm: get_shared_realm()") {
480480
}
481481
#endif
482482

483+
#if !REALM_USE_UV && !TEST_SCHEDULER_UV // uv scheduler does not support background threads
483484
SECTION("should get different instances on different threads") {
484485
config.cache = true;
485486
auto realm1 = Realm::get_shared_realm(config);
486-
std::thread([&] {
487+
JoiningThread([&] {
487488
auto realm2 = Realm::get_shared_realm(config);
488489
REQUIRE(realm1 != realm2);
489-
}).join();
490+
});
490491
}
492+
#endif
491493

492494
SECTION("should detect use of Realm on incorrect thread") {
493495
auto realm = Realm::get_shared_realm(config);
494-
std::thread([&] {
496+
JoiningThread([&] {
495497
REQUIRE_THROWS_MATCHES(realm->verify_thread(), LogicError,
496498
Catch::Matchers::Message("Realm accessed from incorrect thread."));
497-
}).join();
499+
});
498500
}
499501

500502
// Our test scheduler uses a simple integer identifier to allow cross thread scheduling
@@ -543,19 +545,19 @@ TEST_CASE("SharedRealm: get_shared_realm()") {
543545
config.cache = true;
544546
config.scheduler = std::make_shared<SimpleScheduler>(1);
545547
auto realm = Realm::get_shared_realm(config);
546-
std::thread([&] {
548+
JoiningThread([&] {
547549
REQUIRE_NOTHROW(realm->verify_thread());
548-
}).join();
550+
});
549551
}
550552

551553
SECTION("should get same instance for same explicit execution context on different thread") {
552554
config.cache = true;
553555
config.scheduler = std::make_shared<SimpleScheduler>(1);
554556
auto realm1 = Realm::get_shared_realm(config);
555-
std::thread([&] {
557+
JoiningThread([&] {
556558
auto realm2 = Realm::get_shared_realm(config);
557559
REQUIRE(realm1 == realm2);
558-
}).join();
560+
});
559561
}
560562

561563
SECTION("should not modify the schema when fetching from the cache") {
@@ -4059,15 +4061,15 @@ TEST_CASE("SharedRealm: compact on launch") {
40594061
config.scheduler = util::Scheduler::make_frozen(VersionID());
40604062
r = Realm::get_shared_realm(config);
40614063
REQUIRE(num_opens == 2);
4062-
std::thread([&] {
4064+
JoiningThread([&] {
40634065
auto r2 = Realm::get_shared_realm(config);
40644066
REQUIRE(num_opens == 2);
4065-
}).join();
4067+
});
40664068
r->close();
4067-
std::thread([&] {
4069+
JoiningThread([&] {
40684070
auto r3 = Realm::get_shared_realm(config);
40694071
REQUIRE(num_opens == 3);
4070-
}).join();
4072+
});
40714073
}
40724074
}
40734075

@@ -4355,16 +4357,16 @@ TEST_CASE("RealmCoordinator: get_unbound_realm()") {
43554357
};
43564358

43574359
ThreadSafeReference ref;
4358-
std::thread([&] {
4360+
JoiningThread([&] {
43594361
ref = _impl::RealmCoordinator::get_coordinator(config)->get_unbound_realm();
4360-
}).join();
4362+
});
43614363

43624364
SECTION("checks thread after being resolved") {
43634365
auto realm = Realm::get_shared_realm(std::move(ref));
43644366
REQUIRE_NOTHROW(realm->verify_thread());
4365-
std::thread([&] {
4367+
JoiningThread([&] {
43664368
REQUIRE_EXCEPTION(realm->verify_thread(), WrongThread, "Realm accessed from incorrect thread.");
4367-
}).join();
4369+
});
43684370
}
43694371

43704372
SECTION("delivers notifications to the thread it is resolved on") {
@@ -4396,9 +4398,9 @@ TEST_CASE("RealmCoordinator: get_unbound_realm()") {
43964398
REQUIRE(r1 != r2);
43974399

43984400
// New unbound with cache disabled
4399-
std::thread([&] {
4401+
JoiningThread([&] {
44004402
ref = _impl::RealmCoordinator::get_coordinator(config)->get_unbound_realm();
4401-
}).join();
4403+
});
44024404
auto r3 = Realm::get_shared_realm(std::move(ref));
44034405
REQUIRE(r1 != r3);
44044406
REQUIRE(r2 != r3);

‎test/object-store/results.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1040,9 +1040,9 @@ TEST_CASE("notifications: skip", "[notifications]") {
10401040
SECTION("skipping must be done from the Realm's thread") {
10411041
advance_and_notify(*r);
10421042
r->begin_transaction();
1043-
std::thread([&] {
1043+
JoiningThread([&] {
10441044
REQUIRE_EXCEPTION(token1.suppress_next(), WrongThread, "Realm accessed from incorrect thread.");
1045-
}).join();
1045+
});
10461046
r->cancel_transaction();
10471047
}
10481048

‎test/object-store/sync/client_reset.cpp‎

Lines changed: 21 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -385,7 +385,7 @@ TEST_CASE("sync: client reset", "[sync][pbs][client reset][baas]") {
385385
local_config.sync_config->notify_after_client_reset = [&](SharedRealm before, ThreadSafeReference after_ref,
386386
bool) {
387387
std::lock_guard<std::mutex> lock(mtx);
388-
SharedRealm after = Realm::get_shared_realm(std::move(after_ref), util::Scheduler::make_default());
388+
SharedRealm after = Realm::get_shared_realm(std::move(after_ref), util::Scheduler::make_dummy());
389389
++after_callback_invocations;
390390
REQUIRE(before);
391391
REQUIRE(before->is_frozen());
@@ -1698,7 +1698,7 @@ TEST_CASE("sync: client reset", "[sync][pbs][client reset][baas]") {
16981698
};
16991699
local_config.sync_config->notify_after_client_reset = [&](SharedRealm, ThreadSafeReference realm_ref,
17001700
bool did_recover) {
1701-
SharedRealm realm = Realm::get_shared_realm(std::move(realm_ref), util::Scheduler::make_default());
1701+
SharedRealm realm = Realm::get_shared_realm(std::move(realm_ref), util::Scheduler::make_dummy());
17021702
auto flag = has_reset_cycle_flag(realm);
17031703
REQUIRE(bool(flag));
17041704
REQUIRE(flag->mode == ClientResyncMode::Recover);
@@ -1780,17 +1780,16 @@ TEST_CASE("sync: client reset", "[sync][pbs][client reset][baas]") {
17801780
"In RecoverOrDiscard mode: a previous failed recovery is detected and triggers a DiscardLocal reset") {
17811781
local_config.sync_config->client_resync_mode = ClientResyncMode::RecoverOrDiscard;
17821782
make_fake_previous_reset(ClientResyncMode::Recover);
1783-
local_config.sync_config->notify_after_client_reset = [&](SharedRealm before,
1784-
ThreadSafeReference after_ref,
1785-
bool did_recover) {
1786-
SharedRealm after = Realm::get_shared_realm(std::move(after_ref), util::Scheduler::make_default());
1783+
local_config.sync_config->notify_after_client_reset =
1784+
[&](SharedRealm before, ThreadSafeReference after_ref, bool did_recover) {
1785+
SharedRealm after = Realm::get_shared_realm(std::move(after_ref), util::Scheduler::make_dummy());
17871786

1788-
REQUIRE(!did_recover);
1789-
REQUIRE(has_added_object(before));
1790-
REQUIRE(!has_added_object(after)); // discarded insert due to fallback to DiscardLocal mode
1791-
std::lock_guard<std::mutex> lock(mtx);
1792-
++after_callback_invocations;
1793-
};
1787+
REQUIRE(!did_recover);
1788+
REQUIRE(has_added_object(before));
1789+
REQUIRE(!has_added_object(after)); // discarded insert due to fallback to DiscardLocal mode
1790+
std::lock_guard<std::mutex> lock(mtx);
1791+
++after_callback_invocations;
1792+
};
17941793
make_reset(local_config, remote_config)
17951794
->make_local_changes([&](SharedRealm realm) {
17961795
auto table = get_table(*realm, "object");
@@ -1809,17 +1808,16 @@ TEST_CASE("sync: client reset", "[sync][pbs][client reset][baas]") {
18091808
SECTION("In DiscardLocal mode: a previous failed recovery does not cause an error") {
18101809
local_config.sync_config->client_resync_mode = ClientResyncMode::DiscardLocal;
18111810
make_fake_previous_reset(ClientResyncMode::Recover);
1812-
local_config.sync_config->notify_after_client_reset = [&](SharedRealm before,
1813-
ThreadSafeReference after_ref,
1814-
bool did_recover) {
1815-
SharedRealm after = Realm::get_shared_realm(std::move(after_ref), util::Scheduler::make_default());
1811+
local_config.sync_config->notify_after_client_reset =
1812+
[&](SharedRealm before, ThreadSafeReference after_ref, bool did_recover) {
1813+
SharedRealm after = Realm::get_shared_realm(std::move(after_ref), util::Scheduler::make_dummy());
18161814

1817-
REQUIRE(!did_recover);
1818-
REQUIRE(has_added_object(before));
1819-
REQUIRE(!has_added_object(after)); // not recovered
1820-
std::lock_guard<std::mutex> lock(mtx);
1821-
++after_callback_invocations;
1822-
};
1815+
REQUIRE(!did_recover);
1816+
REQUIRE(has_added_object(before));
1817+
REQUIRE(!has_added_object(after)); // not recovered
1818+
std::lock_guard<std::mutex> lock(mtx);
1819+
++after_callback_invocations;
1820+
};
18231821
make_reset(local_config, remote_config)
18241822
->make_local_changes([&](SharedRealm realm) {
18251823
auto table = get_table(*realm, "object");
@@ -1966,7 +1964,7 @@ TEST_CASE("sync: Client reset during async open", "[sync][pbs][client reset][baa
19661964
if (ex) {
19671965
std::rethrow_exception(ex);
19681966
}
1969-
auto realm = Realm::get_shared_realm(std::move(ref));
1967+
auto realm = Realm::get_shared_realm(std::move(ref), util::Scheduler::make_dummy());
19701968
realm_pf.promise.emplace_value(std::move(realm));
19711969
}
19721970
catch (...) {

0 commit comments

Comments
 (0)