TEST_CASE("RCOCOA-1929 repro", "") {
    using namespace std::literals::string_literals;
    std::string base_url = get_base_url();
    REQUIRE(!base_url.empty());
    const auto partition = random_string(100);
    Schema schema = {{"Project",
                      {
                          {"_id", PropertyType::ObjectId, true},
                          {"title", PropertyType::String},
                          {"comments", PropertyType::Array | PropertyType::Object, "Comments"},
                      }},
                     {"Comments",
                      {
                          {"_id", PropertyType::Int, true},
                          {"text", PropertyType::String | PropertyType::Nullable},
                      }}};
    auto server_app_config = minimal_app_config(base_url, "rcocoa-1929", schema);
    TestAppSession test_session(create_app(server_app_config));
    std::string parition("default");
    auto project_id = ObjectId::gen();
    std::default_random_engine engine(std::random_device{}());
    const size_t expected_comments = 10;

    auto shuffle_list = [&](const SharedRealm& realm, List& list) {
        std::uniform_int_distribution<size_t> dist;
        using dist_param = decltype(dist)::param_type;
        size_t n = list.size() - 1;
        for (size_t idx = n - 1; idx > 0; --idx) {
            auto second_idx = dist(engine, dist_param(0, idx));
            if (idx == second_idx) {
                continue;
            }
            realm->begin_transaction();
            std::cerr << "=== Swapping idx " << idx << " with idx " << second_idx << " ===\n";
            list.move(idx, second_idx);
            realm->commit_transaction();
        }
    };

    auto get_comments_list = [&](const SharedRealm& realm) {
        CppContext c(realm);
        auto project_obj = Object::get_for_primary_key(c, realm, "Project", std::any(project_id));
        return List(project_obj, project_obj.get_object_schema().property_for_name("comments"));
    };

    auto comments_to_pks = [](List& list) {
        std::vector<int64_t> ret;
        for (size_t i = 0; i < list.size();   i) {
            ret.push_back(list.get_object(i).get_primary_key().get_int());
        }
        return ret;
    };

    create_user_and_log_in(test_session.app());
    auto user_1 = test_session.app()->current_user();
    SyncTestFile user_1_realm(user_1, partition, schema);
    auto orig_realm = Realm::get_shared_realm(user_1_realm);
    {

        std::cerr << "=== Creating initial object ===\n";
        CppContext c(orig_realm);
        orig_realm->begin_transaction();
        auto project_obj = Object::create(c, orig_realm, "Project",
                                          std::any(AnyDict{{"_id"s, project_id}, {"title"s, "test title"s}}));
        auto comments_list = get_comments_list(orig_realm);
        orig_realm->commit_transaction();

        std::cerr << "=== Creating comments ===\n";
        for (size_t i = 0; i < expected_comments;   i) {
            orig_realm->begin_transaction();
            auto obj =
                Object::create(c, orig_realm, "Comments",
                               std::any(AnyDict{{"_id"s, int64_t(i)}, {"text"s, util::format("comment %1", i)}}));
            comments_list.add(obj.obj());
            orig_realm->commit_transaction();
        }
        wait_for_upload(*orig_realm);

        std::cerr << "=== Comments order " << ::Catch::Detail::stringify(comments_to_pks(comments_list)) << " ===\n";
        std::cerr << "=== Logging out original session ===\n";
        orig_realm->sync_session()->log_out();
    }

    create_user_and_log_in(test_session.app());
    auto user_2 = test_session.app()->current_user();
    SyncTestFile user_2_realm(user_2, partition, schema);
    {
        std::cerr << "=== Opening second realm ===\n";
        auto realm = Realm::get_shared_realm(user_2_realm);
        wait_for_download(*realm);

        std::cerr << "=== Shuffling second list while connected ===\n";
        auto comments_list = get_comments_list(realm);
        REQUIRE(comments_list.size() == expected_comments);
        shuffle_list(realm, comments_list);
        wait_for_upload(*realm);

        std::cerr << "=== Second realm is shuffled ===\n";
        std::cerr << "=== Second realm comments order after shuffle "
                  << ::Catch::Detail::stringify(comments_to_pks(comments_list)) << " ===\n";
    }

    {
        std::cerr << "=== Shuffling original list while disconnected ===\n";
        auto comments_list = get_comments_list(orig_realm);
        shuffle_list(orig_realm, comments_list);
        std::cerr << "=== Original realm comments order after shuffling "
                  << ::Catch::Detail::stringify(comments_to_pks(comments_list)) << " ===\n";
    }

    {
        std::cerr << "=== Re-opening first realm/uploading/downloading ===\n";
        orig_realm->sync_session()->revive_if_needed();
        wait_for_upload(*orig_realm);
        wait_for_download(*orig_realm);

        orig_realm->refresh();
        auto orig_comments_list = get_comments_list(orig_realm);
        std::cerr << "=== Original realm comments order after upload/download "
                  << ::Catch::Detail::stringify(comments_to_pks(orig_comments_list)) << "===\n";

        std::cerr << "=== Re-opening second realm/uploading/downloading ===\n";
        auto second_realm = Realm::get_shared_realm(user_2_realm);
        wait_for_upload(*second_realm);
        wait_for_download(*second_realm);

        auto second_comments_list = get_comments_list(second_realm);
        std::cerr << "=== Second realm comments order after upload/download "
                  << ::Catch::Detail::stringify(comments_to_pks(second_comments_list)) << "===\n";
        std::cerr << "=== Checking order ===\n";
        REQUIRE(orig_comments_list.size() == second_comments_list.size());
        REQUIRE(comments_to_pks(orig_comments_list) == comments_to_pks(second_comments_list));
    }
}