mirror of
https://github.com/Green-Sky/crdt_tests.git
synced 2025-06-27 06:36:45 +02:00
move prots to extra folder
This commit is contained in:
28
prototyping/CMakeLists.txt
Normal file
28
prototyping/CMakeLists.txt
Normal file
@ -0,0 +1,28 @@
|
||||
cmake_minimum_required(VERSION 3.9 FATAL_ERROR)
|
||||
|
||||
project(crdt_tests CXX C)
|
||||
|
||||
########################################
|
||||
|
||||
add_executable(test1
|
||||
./test1.cpp
|
||||
)
|
||||
|
||||
target_compile_features(test1 PUBLIC cxx_std_17)
|
||||
|
||||
target_link_libraries(test1 PUBLIC
|
||||
nlohmann_json::nlohmann_json
|
||||
)
|
||||
|
||||
########################################
|
||||
|
||||
add_executable(test2
|
||||
./test2.cpp
|
||||
)
|
||||
|
||||
target_compile_features(test2 PUBLIC cxx_std_17)
|
||||
|
||||
target_link_libraries(test2 PUBLIC
|
||||
nlohmann_json::nlohmann_json
|
||||
)
|
||||
|
||||
293
prototyping/test1.cpp
Normal file
293
prototyping/test1.cpp
Normal file
@ -0,0 +1,293 @@
|
||||
#include <nlohmann/json.hpp>
|
||||
|
||||
#include <array>
|
||||
#include <list>
|
||||
#include <optional>
|
||||
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <cassert>
|
||||
|
||||
namespace GreenCRDT {
|
||||
namespace detail {
|
||||
uint8_t nib_from_hex(char c) {
|
||||
assert((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f'));
|
||||
|
||||
if (c >= '0' && c <= '9') {
|
||||
return static_cast<uint8_t>(c) - '0';
|
||||
} else if (c >= 'a' && c <= 'f') {
|
||||
return (static_cast<uint8_t>(c) - 'a') + 10u;
|
||||
} else {
|
||||
return 0u;
|
||||
}
|
||||
}
|
||||
} // detail
|
||||
|
||||
struct ID {
|
||||
// something like a toxid
|
||||
// for testing its martins paper trace
|
||||
std::array<uint8_t, 32> data;
|
||||
|
||||
bool operator<(const ID& rhs) const {
|
||||
return data < rhs.data;
|
||||
}
|
||||
|
||||
bool operator==(const ID& rhs) const {
|
||||
return data == rhs.data;
|
||||
}
|
||||
|
||||
bool operator!=(const ID& rhs) const {
|
||||
return data != rhs.data;
|
||||
}
|
||||
|
||||
static ID fromHex(const std::string_view str) {
|
||||
assert(str.size() == 32*2);
|
||||
ID tmp;
|
||||
|
||||
for (size_t i = 0; i < tmp.data.size(); i++) {
|
||||
tmp.data[i] = detail::nib_from_hex(str[i*2]) << 4 | detail::nib_from_hex(str[i*2+1]);
|
||||
}
|
||||
|
||||
return tmp;
|
||||
}
|
||||
};
|
||||
|
||||
struct ListID {
|
||||
ID id;
|
||||
uint64_t seq{0};
|
||||
|
||||
bool operator<(const ListID& rhs) const {
|
||||
if (seq < rhs.seq) {
|
||||
return true;
|
||||
} else if (seq > rhs.seq) {
|
||||
return false;
|
||||
} else { // ==
|
||||
return id < rhs.id;
|
||||
}
|
||||
}
|
||||
|
||||
bool operator==(const ListID& rhs) const {
|
||||
return seq == rhs.seq && id == rhs.id;
|
||||
}
|
||||
|
||||
bool operator!=(const ListID& rhs) const {
|
||||
return seq != rhs.seq || id != rhs.id;
|
||||
}
|
||||
|
||||
static ListID fromStr(const std::string_view str) {
|
||||
assert(str.size() >= 32*2);
|
||||
|
||||
size_t at_pos = str.find_first_of('@');
|
||||
auto seq_sv = str.substr(0, at_pos);
|
||||
auto id_sv = str.substr(at_pos+1);
|
||||
|
||||
assert(seq_sv.size() != 0);
|
||||
assert(id_sv.size() == 32*2);
|
||||
|
||||
uint64_t tmp_seq {0};
|
||||
for (size_t i = 0; i < seq_sv.size(); i++) {
|
||||
assert(seq_sv[i] >= '0' && seq_sv[i] <= '9');
|
||||
tmp_seq *= 10;
|
||||
tmp_seq += seq_sv[i] - '0';
|
||||
}
|
||||
|
||||
return {GreenCRDT::ID::fromHex(id_sv), tmp_seq};
|
||||
}
|
||||
};
|
||||
|
||||
template<typename ValueType>
|
||||
struct List {
|
||||
struct Entry {
|
||||
ListID id;
|
||||
std::optional<ListID> parent;
|
||||
|
||||
// might be deleted (yes, *sigh*, crtds need tombstones)
|
||||
std::optional<ValueType> value;
|
||||
};
|
||||
|
||||
// linked list for now
|
||||
std::list<Entry> list;
|
||||
|
||||
// largest observed sequence number minus one
|
||||
uint64_t largest_seq{0};
|
||||
|
||||
// the "first" insert(s)
|
||||
void addParentless(const ValueType& value, const ListID& list_id) {
|
||||
if (list.empty()) { // special
|
||||
list.emplace(list.begin(), Entry{
|
||||
list_id,
|
||||
std::nullopt, // no parent
|
||||
value
|
||||
});
|
||||
} else {
|
||||
// loop until we find the position to insert
|
||||
for (auto it = list.begin(); it != list.end(); it++) {
|
||||
if (
|
||||
it->parent && // has a parent, so we need to insert before that (usually the first one)
|
||||
list_id < it->id // ensure ordering
|
||||
) {
|
||||
list.emplace(it, Entry{
|
||||
list_id,
|
||||
std::nullopt, // no parent
|
||||
value
|
||||
});
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
largest_seq = list_id.seq > largest_seq ? list_id.seq : largest_seq;
|
||||
}
|
||||
|
||||
// returns false if parent not found. (missing OPs)
|
||||
bool add(const ListID& parent, const ValueType& value, const ListID& list_id) {
|
||||
// list empty, obv cant find parent
|
||||
if (list.empty()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// loop until we find the parent
|
||||
auto it = list.begin();
|
||||
for (; it != list.end(); it++) {
|
||||
if (it->id == parent) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
// not found, prob data missing
|
||||
if (it == list.end()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
bool inserted = false;
|
||||
do {
|
||||
it++;
|
||||
if (
|
||||
it == list.end() || // no more elements
|
||||
it->parent != parent || // not a sibling
|
||||
list_id < it->id // we where created earlier
|
||||
) {
|
||||
list.emplace(it, Entry{
|
||||
list_id,
|
||||
parent,
|
||||
value
|
||||
});
|
||||
inserted = true;
|
||||
break;
|
||||
}
|
||||
} while (it != list.end());
|
||||
assert(inserted);
|
||||
|
||||
largest_seq = list_id.seq > largest_seq ? list_id.seq : largest_seq;
|
||||
return true;
|
||||
}
|
||||
|
||||
// returns false if not found
|
||||
bool del(const ListID& id) {
|
||||
auto it = list.begin();
|
||||
for (; it != list.end(); it++) {
|
||||
if (it->id == id) {
|
||||
it->value = std::nullopt;
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// not found
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
struct TextDocument {
|
||||
struct Cursor {
|
||||
ID who;
|
||||
ListID pos;
|
||||
};
|
||||
|
||||
// TODO: determine if char is the best
|
||||
List<char> state;
|
||||
};
|
||||
} // GreenCRDT
|
||||
|
||||
int main(void) {
|
||||
GreenCRDT::TextDocument doc;
|
||||
|
||||
std::ifstream file {"../res/paper.json"};
|
||||
std::cout << "start reading...\n";
|
||||
for (std::string line; std::getline(file, line); ) {
|
||||
nlohmann::json j_entry = nlohmann::json::parse(line);
|
||||
const GreenCRDT::ID actor = GreenCRDT::ID::fromHex(static_cast<const std::string&>(j_entry["actor"]));
|
||||
uint64_t op_seq = j_entry["startOp"];
|
||||
for (const auto& j_op : j_entry["ops"]) {
|
||||
if (j_op["action"] == "set") {
|
||||
const GreenCRDT::ListID obj = GreenCRDT::ListID::fromStr(static_cast<const std::string&>(j_op["obj"]));
|
||||
if (obj.seq != 1) {
|
||||
// skip all non text edits
|
||||
continue;
|
||||
}
|
||||
|
||||
if (j_op["insert"]) {
|
||||
const auto& j_parent = j_op["key"];
|
||||
if (j_parent == "_head") {
|
||||
//std::cout << j_op << "\n";
|
||||
|
||||
auto size_pre = doc.state.list.size();
|
||||
|
||||
doc.state.addParentless(
|
||||
static_cast<const std::string&>(j_op["value"]).front(),
|
||||
{
|
||||
actor,
|
||||
op_seq
|
||||
}
|
||||
);
|
||||
|
||||
assert(size_pre+1 == doc.state.list.size());
|
||||
} else { // we have a parrent
|
||||
assert(j_parent != nullptr);
|
||||
auto size_pre = doc.state.list.size();
|
||||
|
||||
// split parent into seq and id
|
||||
GreenCRDT::ListID parent = GreenCRDT::ListID::fromStr(static_cast<const std::string&>(j_parent));
|
||||
|
||||
assert(static_cast<const std::string&>(j_op["value"]).size() == 1);
|
||||
|
||||
doc.state.add(
|
||||
parent,
|
||||
static_cast<const std::string&>(j_op["value"]).front(),
|
||||
{ actor, op_seq }
|
||||
);
|
||||
|
||||
assert(size_pre+1 == doc.state.list.size());
|
||||
}
|
||||
} else {
|
||||
// i think this is curser movement
|
||||
}
|
||||
} else if (j_op["action"] == "del") {
|
||||
doc.state.del(GreenCRDT::ListID::fromStr(static_cast<const std::string&>(j_op["key"])));
|
||||
} else if (j_op["action"] == "makeText") {
|
||||
// doc.clear();
|
||||
} else if (j_op["action"] == "makeMap") {
|
||||
// no idea
|
||||
} else {
|
||||
std::cout << "op: " << j_op << "\n";
|
||||
}
|
||||
|
||||
op_seq++;
|
||||
}
|
||||
}
|
||||
|
||||
std::cout << "\ndoc size (with tombstones): " << doc.state.list.size() << "\n";
|
||||
std::cout << "\ndoc largest seq: " << doc.state.largest_seq << "\n";
|
||||
std::cout << "doc text:\n";
|
||||
|
||||
// simple print
|
||||
for (const auto& it : doc.state.list) {
|
||||
if (it.value) {
|
||||
std::cout << it.value.value();
|
||||
}
|
||||
}
|
||||
|
||||
std::cout << "\n";
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
540
prototyping/test2.cpp
Normal file
540
prototyping/test2.cpp
Normal file
@ -0,0 +1,540 @@
|
||||
#include <array>
|
||||
#include <list>
|
||||
#include <optional>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
|
||||
#include <numeric>
|
||||
#include <random>
|
||||
#include <iostream>
|
||||
#include <cassert>
|
||||
|
||||
namespace GreenCRDT {
|
||||
namespace detail {
|
||||
uint8_t nib_from_hex(char c) {
|
||||
assert((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f'));
|
||||
|
||||
if (c >= '0' && c <= '9') {
|
||||
return static_cast<uint8_t>(c) - '0';
|
||||
} else if (c >= 'a' && c <= 'f') {
|
||||
return (static_cast<uint8_t>(c) - 'a') + 10u;
|
||||
} else {
|
||||
return 0u;
|
||||
}
|
||||
}
|
||||
} // detail
|
||||
|
||||
struct ID {
|
||||
// something like a toxid
|
||||
// for testing its martins paper trace
|
||||
std::array<uint8_t, 32> data;
|
||||
|
||||
bool operator<(const ID& rhs) const {
|
||||
return data < rhs.data;
|
||||
}
|
||||
|
||||
bool operator==(const ID& rhs) const {
|
||||
return data == rhs.data;
|
||||
}
|
||||
|
||||
bool operator!=(const ID& rhs) const {
|
||||
return data != rhs.data;
|
||||
}
|
||||
|
||||
static ID fromHex(const std::string_view str) {
|
||||
assert(str.size() == 32*2);
|
||||
ID tmp;
|
||||
|
||||
for (size_t i = 0; i < tmp.data.size(); i++) {
|
||||
tmp.data[i] = detail::nib_from_hex(str[i*2]) << 4 | detail::nib_from_hex(str[i*2+1]);
|
||||
}
|
||||
|
||||
return tmp;
|
||||
}
|
||||
};
|
||||
|
||||
using Agent = ID;
|
||||
|
||||
struct ListID {
|
||||
Agent id;
|
||||
uint64_t seq{0}; // strictly increasing for that agent
|
||||
|
||||
bool operator<(const ListID& rhs) const {
|
||||
if (seq < rhs.seq) {
|
||||
return true;
|
||||
} else if (seq > rhs.seq) {
|
||||
return false;
|
||||
} else { // ==
|
||||
return id < rhs.id;
|
||||
}
|
||||
}
|
||||
|
||||
bool operator==(const ListID& rhs) const {
|
||||
return seq == rhs.seq && id == rhs.id;
|
||||
}
|
||||
|
||||
bool operator!=(const ListID& rhs) const {
|
||||
return seq != rhs.seq || id != rhs.id;
|
||||
}
|
||||
|
||||
static ListID fromStr(const std::string_view str) {
|
||||
assert(str.size() >= 32*2);
|
||||
|
||||
size_t at_pos = str.find_first_of('@');
|
||||
const auto seq_sv = str.substr(0, at_pos);
|
||||
const auto agent_sv = str.substr(at_pos+1);
|
||||
|
||||
assert(seq_sv.size() != 0);
|
||||
assert(agent_sv.size() == 32*2);
|
||||
|
||||
uint64_t tmp_seq {0};
|
||||
for (size_t i = 0; i < seq_sv.size(); i++) {
|
||||
assert(seq_sv[i] >= '0' && seq_sv[i] <= '9');
|
||||
tmp_seq *= 10;
|
||||
tmp_seq += seq_sv[i] - '0';
|
||||
}
|
||||
|
||||
return {GreenCRDT::Agent::fromHex(agent_sv), tmp_seq};
|
||||
}
|
||||
};
|
||||
|
||||
template<typename ValueType>
|
||||
struct List {
|
||||
// TODO: replace with SoA
|
||||
struct Entry {
|
||||
ListID id;
|
||||
|
||||
// Yjs
|
||||
std::optional<ListID> parent_left;
|
||||
std::optional<ListID> parent_right;
|
||||
|
||||
// might be deleted (yes, *sigh*, crtds need tombstones)
|
||||
std::optional<ValueType> value;
|
||||
};
|
||||
|
||||
// linked list for now
|
||||
std::vector<Entry> list;
|
||||
|
||||
// number of not deleted entries
|
||||
size_t doc_size {0};
|
||||
|
||||
std::map<Agent, uint64_t> last_seen_seq;
|
||||
|
||||
auto findIt(const ListID& list_id) {
|
||||
auto it = list.begin();
|
||||
for (; it != list.end(); it++) {
|
||||
if (it->id == list_id) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return it;
|
||||
}
|
||||
|
||||
std::optional<size_t> findIdx(const ListID& list_id) {
|
||||
#if 0
|
||||
size_t i = 0;
|
||||
for (auto it = list.cbegin(); it != list.cend(); it++, i++) {
|
||||
if (it->id == list_id) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
for (size_t i = 0; i < list.size(); i++) {
|
||||
if (list[i].id == list_id) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
// returns false if parent not found. (missing OPs)
|
||||
// returns false if missing operations
|
||||
// base on YjsMod https://github.com/josephg/reference-crdts/blob/9f4f9c3a97b497e2df8ae4473d1e521d3c3bf2d2/crdts.ts#L293-L348
|
||||
// which is a modified Yjs algo
|
||||
bool add(const ListID& list_id, const ValueType& value, const std::optional<ListID>& parent_left, const std::optional<ListID>& parent_right) {
|
||||
// check agent op order
|
||||
if (!last_seen_seq.count(list_id.id)) {
|
||||
// we dont know this agent yet, first seq needs to be 0
|
||||
if (list_id.seq != 0) {
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
// making sure we dont skip operations by that agent
|
||||
if (list_id.seq != last_seen_seq.at(list_id.id) + 1) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (list.empty()) {
|
||||
if (parent_left.has_value() || parent_right.has_value()) {
|
||||
// empty, missing parents
|
||||
return false;
|
||||
}
|
||||
list.emplace(list.begin(), Entry{
|
||||
list_id,
|
||||
parent_left,
|
||||
parent_right,
|
||||
value
|
||||
});
|
||||
|
||||
// insert parentless into empty doc
|
||||
} else {
|
||||
// find left
|
||||
std::optional<size_t> left_idx = std::nullopt;
|
||||
size_t insert_idx = 0;
|
||||
if (parent_left.has_value()) {
|
||||
left_idx = findIdx(parent_left.value());
|
||||
if (!left_idx.has_value()) {
|
||||
// missing parent left
|
||||
return false;
|
||||
}
|
||||
|
||||
// we insert before the it, so we need to go past the left parent
|
||||
insert_idx = left_idx.value() + 1;
|
||||
} // else insert_idx = 0
|
||||
|
||||
// find right
|
||||
size_t right_idx = list.size();
|
||||
if (parent_right.has_value()) {
|
||||
auto tmp_right = findIdx(parent_right.value());
|
||||
if (!tmp_right.has_value()) {
|
||||
return false;
|
||||
}
|
||||
right_idx = tmp_right.value();
|
||||
}
|
||||
|
||||
bool scanning {false};
|
||||
|
||||
for(size_t i = insert_idx;; i++) {
|
||||
if (!scanning) {
|
||||
insert_idx = i;
|
||||
}
|
||||
// if right parent / end of doc, insert
|
||||
if (insert_idx == right_idx) {
|
||||
break;
|
||||
}
|
||||
// we ran past right o.o ?
|
||||
if (insert_idx == list.size()) {
|
||||
break;
|
||||
}
|
||||
|
||||
const Entry& at_i = list[i];
|
||||
// parents left and right
|
||||
std::optional<size_t> i_left_idx {std::nullopt};
|
||||
if (at_i.parent_left.has_value()) {
|
||||
i_left_idx = findIdx(at_i.parent_left.value());
|
||||
if (!i_left_idx.has_value()) {
|
||||
assert(false && "item in list with unknown parent left!!");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// possibility map
|
||||
//
|
||||
// | ir < r | ir == r | ir > r
|
||||
// -------------------------------------
|
||||
// il < l | insert | insert | insert
|
||||
// il == l | ? | agentfallback | ?
|
||||
// il > l | skip | skip | skip
|
||||
|
||||
if (i_left_idx < left_idx) {
|
||||
break;
|
||||
} else if (i_left_idx == left_idx) {
|
||||
// get i parent_right
|
||||
size_t i_right_idx = list.size();
|
||||
if (at_i.parent_right.has_value()) {
|
||||
auto tmp_right = findIdx(at_i.parent_right.value());
|
||||
if (!tmp_right.has_value()) {
|
||||
assert(false && "item in list with unknown parent right!!");
|
||||
return false;
|
||||
}
|
||||
i_right_idx = tmp_right.value();
|
||||
}
|
||||
|
||||
if (i_right_idx < right_idx) {
|
||||
scanning = true;
|
||||
} else if (i_right_idx == right_idx) {
|
||||
// agent id tie breaker
|
||||
if (list_id.id < at_i.id.id) {
|
||||
break;
|
||||
} else {
|
||||
scanning = false;
|
||||
}
|
||||
} else { // i_right_idx > right_idx
|
||||
scanning = false;
|
||||
}
|
||||
} else { // il > l
|
||||
// do nothing
|
||||
}
|
||||
}
|
||||
|
||||
list.emplace(list.begin() + insert_idx, Entry{
|
||||
list_id,
|
||||
parent_left,
|
||||
parent_right,
|
||||
value
|
||||
});
|
||||
}
|
||||
|
||||
doc_size++;
|
||||
last_seen_seq[list_id.id] = list_id.seq;
|
||||
return true;
|
||||
}
|
||||
|
||||
// returns false if not found
|
||||
bool del(const ListID& id) {
|
||||
auto it = list.begin();
|
||||
for (; it != list.end(); it++) {
|
||||
if (it->id == id) {
|
||||
it->value = std::nullopt;
|
||||
|
||||
assert(doc_size > 0);
|
||||
doc_size--;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// not found
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
struct TextDocument {
|
||||
struct Cursor {
|
||||
Agent who;
|
||||
ListID pos;
|
||||
};
|
||||
|
||||
// TODO: determine if char is the best
|
||||
List<char> state;
|
||||
|
||||
friend std::ostream& operator<<(std::ostream& out, const TextDocument& doc) {
|
||||
// simple print
|
||||
for (const auto& it : doc.state.list) {
|
||||
if (it.value) {
|
||||
out << it.value.value();
|
||||
}
|
||||
}
|
||||
|
||||
return out;
|
||||
}
|
||||
|
||||
std::string getText(void) {
|
||||
std::string text;
|
||||
|
||||
for (const auto& it : state.list) {
|
||||
if (it.value) {
|
||||
text += it.value.value();
|
||||
}
|
||||
}
|
||||
|
||||
return text;
|
||||
}
|
||||
};
|
||||
} // GreenCRDT
|
||||
|
||||
void testSingle1(void) {
|
||||
GreenCRDT::TextDocument doc;
|
||||
const auto agent_a = GreenCRDT::Agent::fromHex("0a00000000000000000000000000000000000000000000000000000000000000");
|
||||
|
||||
doc.state.add({agent_a, 0}, 'a', std::nullopt, std::nullopt);
|
||||
doc.state.add({agent_a, 1}, 'b', GreenCRDT::ListID{agent_a, 0u}, std::nullopt);
|
||||
|
||||
assert(doc.getText() == "ab");
|
||||
}
|
||||
|
||||
void testConcurrent1(void) {
|
||||
const auto agent_a = GreenCRDT::Agent::fromHex("0a00000000000000000000000000000000000000000000000000000000000000");
|
||||
const auto agent_b = GreenCRDT::Agent::fromHex("0b00000000000000000000000000000000000000000000000000000000000000");
|
||||
// agent_a < agent_b
|
||||
|
||||
// concurrent insert of first element
|
||||
{ // variant 1, a then b
|
||||
GreenCRDT::TextDocument doc;
|
||||
doc.state.add({agent_a, 0}, 'a', std::nullopt, std::nullopt);
|
||||
doc.state.add({agent_b, 0}, 'b', std::nullopt, std::nullopt);
|
||||
|
||||
assert(doc.getText() == "ab");
|
||||
}
|
||||
{ // variant 2, b then a
|
||||
GreenCRDT::TextDocument doc;
|
||||
doc.state.add({agent_b, 0}, 'b', std::nullopt, std::nullopt);
|
||||
doc.state.add({agent_a, 0}, 'a', std::nullopt, std::nullopt);
|
||||
|
||||
assert(doc.getText() == "ab");
|
||||
}
|
||||
}
|
||||
|
||||
struct AddOp {
|
||||
GreenCRDT::ListID id;
|
||||
char value;
|
||||
std::optional<GreenCRDT::ListID> parent_left;
|
||||
std::optional<GreenCRDT::ListID> parent_right;
|
||||
};
|
||||
|
||||
void randomAddPermutations(const std::vector<AddOp>& ops, const std::string& expected) {
|
||||
// TODO: more then 1k?
|
||||
for (size_t i = 0; i < 1000; i++) {
|
||||
std::minstd_rand rng(1337 + i);
|
||||
std::vector<size_t> ops_todo(ops.size());
|
||||
std::iota(ops_todo.begin(), ops_todo.end(), 0u);
|
||||
|
||||
size_t attempts {0};
|
||||
|
||||
GreenCRDT::TextDocument doc;
|
||||
do {
|
||||
size_t idx = rng() % ops_todo.size();
|
||||
|
||||
if (doc.state.add(ops[ops_todo[idx]].id, ops[ops_todo[idx]].value, ops[ops_todo[idx]].parent_left, ops[ops_todo[idx]].parent_right)) {
|
||||
// only remove if it was possible -> returned true;
|
||||
ops_todo.erase(ops_todo.begin()+idx);
|
||||
}
|
||||
|
||||
attempts++;
|
||||
assert(attempts < 10'000); // in case we run into an endless loop
|
||||
} while (!ops_todo.empty());
|
||||
|
||||
assert(doc.getText() == expected);
|
||||
}
|
||||
}
|
||||
|
||||
void testInterleave1(void) {
|
||||
const auto agent_a = GreenCRDT::Agent::fromHex("0a00000000000000000000000000000000000000000000000000000000000000");
|
||||
const auto agent_b = GreenCRDT::Agent::fromHex("0b00000000000000000000000000000000000000000000000000000000000000");
|
||||
// agent_a < agent_b
|
||||
|
||||
const std::vector<AddOp> ops {
|
||||
{{agent_a, 0u}, 'a', std::nullopt, std::nullopt},
|
||||
{{agent_a, 1u}, 'a', GreenCRDT::ListID{agent_a, 0u}, std::nullopt},
|
||||
{{agent_a, 2u}, 'a', GreenCRDT::ListID{agent_a, 1u}, std::nullopt},
|
||||
{{agent_b, 0u}, 'b', std::nullopt, std::nullopt},
|
||||
{{agent_b, 1u}, 'b', GreenCRDT::ListID{agent_b, 0u}, std::nullopt},
|
||||
{{agent_b, 2u}, 'b', GreenCRDT::ListID{agent_b, 1u}, std::nullopt},
|
||||
};
|
||||
|
||||
randomAddPermutations(ops, "aaabbb");
|
||||
}
|
||||
|
||||
void testInterleave2(void) {
|
||||
const auto agent_a = GreenCRDT::Agent::fromHex("0a00000000000000000000000000000000000000000000000000000000000000");
|
||||
const auto agent_b = GreenCRDT::Agent::fromHex("0b00000000000000000000000000000000000000000000000000000000000000");
|
||||
// agent_a < agent_b
|
||||
|
||||
const std::vector<AddOp> ops {
|
||||
{{agent_a, 0u}, 'a', std::nullopt, std::nullopt},
|
||||
{{agent_a, 1u}, 'a', std::nullopt, GreenCRDT::ListID{agent_a, 0u}},
|
||||
{{agent_a, 2u}, 'a', std::nullopt, GreenCRDT::ListID{agent_a, 1u}},
|
||||
{{agent_b, 0u}, 'b', std::nullopt, std::nullopt},
|
||||
{{agent_b, 1u}, 'b', std::nullopt, GreenCRDT::ListID{agent_b, 0u}},
|
||||
{{agent_b, 2u}, 'b', std::nullopt, GreenCRDT::ListID{agent_b, 1u}},
|
||||
};
|
||||
|
||||
randomAddPermutations(ops, "aaabbb");
|
||||
}
|
||||
|
||||
void testConcurrent2(void) {
|
||||
const auto agent_a = GreenCRDT::Agent::fromHex("0a00000000000000000000000000000000000000000000000000000000000000");
|
||||
const auto agent_b = GreenCRDT::Agent::fromHex("0b00000000000000000000000000000000000000000000000000000000000000");
|
||||
const auto agent_c = GreenCRDT::Agent::fromHex("0c00000000000000000000000000000000000000000000000000000000000000");
|
||||
const auto agent_d = GreenCRDT::Agent::fromHex("0d00000000000000000000000000000000000000000000000000000000000000");
|
||||
|
||||
const std::vector<AddOp> ops {
|
||||
{{agent_a, 0u}, 'a', std::nullopt, std::nullopt},
|
||||
{{agent_c, 0u}, 'c', std::nullopt, std::nullopt},
|
||||
|
||||
{{agent_b, 0u}, 'b', std::nullopt, std::nullopt},
|
||||
{{agent_d, 0u}, 'd', GreenCRDT::ListID{agent_a, 0u}, GreenCRDT::ListID{agent_c, 0u}},
|
||||
};
|
||||
|
||||
randomAddPermutations(ops, "adbc");
|
||||
}
|
||||
|
||||
void testMain1(void) {
|
||||
GreenCRDT::TextDocument doc;
|
||||
|
||||
const GreenCRDT::Agent agent0 = GreenCRDT::Agent::fromHex("9654bd415cfac9ee6aa9f55bf1024f840afdbb1f37237673c928491a91ff7783");
|
||||
uint64_t agent0_seq {0};
|
||||
const GreenCRDT::Agent agent1 = GreenCRDT::Agent::fromHex("0100000000000000000000000000000000000000000000000000000000000000");
|
||||
uint64_t agent1_seq {0};
|
||||
|
||||
const std::vector<AddOp> a0_ops {
|
||||
{{agent0, agent0_seq++}, 'a', std::nullopt, std::nullopt},
|
||||
{{agent0, agent0_seq++}, 'b', GreenCRDT::ListID{agent0, 0u}, std::nullopt},
|
||||
{{agent0, agent0_seq++}, 'c', GreenCRDT::ListID{agent0, 1u}, std::nullopt},
|
||||
{{agent0, agent0_seq++}, 'd', GreenCRDT::ListID{agent0, 1u}, GreenCRDT::ListID{agent0, 2u}},
|
||||
};
|
||||
|
||||
const std::vector<AddOp> a1_ops {
|
||||
// knows of a0 up to {a0, 1}
|
||||
{{agent1, agent1_seq++}, 'z', GreenCRDT::ListID{agent0, 0u}, GreenCRDT::ListID{agent0, 1u}},
|
||||
{{agent1, agent1_seq++}, 'y', GreenCRDT::ListID{agent0, 1u}, std::nullopt},
|
||||
};
|
||||
|
||||
{ // the ez, in order stuff
|
||||
// a0 insert first char, 'a', since its the first, we dont have any parents
|
||||
doc.state.add(a0_ops[0].id, a0_ops[0].value, a0_ops[0].parent_left, a0_ops[0].parent_right);
|
||||
assert(doc.getText() == "a");
|
||||
|
||||
// a0 insert secound char, 'b' after 'a', no parents to right
|
||||
doc.state.add(a0_ops[1].id, a0_ops[1].value, a0_ops[1].parent_left, a0_ops[1].parent_right);
|
||||
assert(doc.getText() == "ab");
|
||||
|
||||
// a0 insert 'c' after 'b', no parents to right
|
||||
doc.state.add(a0_ops[2].id, a0_ops[2].value, a0_ops[2].parent_left, a0_ops[2].parent_right);
|
||||
assert(doc.getText() == "abc");
|
||||
|
||||
// a0 insert 'd' after 'b', 'c' parent right
|
||||
doc.state.add(a0_ops[3].id, a0_ops[3].value, a0_ops[3].parent_left, a0_ops[3].parent_right);
|
||||
assert(doc.getText() == "abdc");
|
||||
|
||||
// a1 insert 'z' after 'a', 'b' parent right
|
||||
doc.state.add(a1_ops[0].id, a1_ops[0].value, a1_ops[0].parent_left, a1_ops[0].parent_right);
|
||||
assert(doc.getText() == "azbdc");
|
||||
}
|
||||
|
||||
std::cout << "done with ez\n";
|
||||
|
||||
{ // a1 was not uptodate only had 0,1 of a0
|
||||
// a1 insert 'y' after 'b', no parent right
|
||||
doc.state.add(a1_ops[1].id, a1_ops[1].value, a1_ops[1].parent_left, a1_ops[1].parent_right);
|
||||
assert(doc.getText() == "azbydc");
|
||||
}
|
||||
|
||||
std::cout << "\ndoc size (with tombstones): " << doc.state.list.size() << "\n";
|
||||
std::cout << "\ndoc size: " << doc.state.doc_size << "\n";
|
||||
std::cout << "doc text:\n";
|
||||
|
||||
// simple print
|
||||
std::cout << doc << "\n";
|
||||
}
|
||||
|
||||
int main(void) {
|
||||
std::cout << "testSingle1:\n";
|
||||
testSingle1();
|
||||
std::cout << std::string(40, '-') << "\n";
|
||||
|
||||
std::cout << "testConcurrent1:\n";
|
||||
testConcurrent1();
|
||||
std::cout << std::string(40, '-') << "\n";
|
||||
|
||||
std::cout << "testInterleave1:\n";
|
||||
testInterleave1();
|
||||
std::cout << std::string(40, '-') << "\n";
|
||||
|
||||
std::cout << "testInterleave2:\n";
|
||||
testInterleave2();
|
||||
std::cout << std::string(40, '-') << "\n";
|
||||
|
||||
std::cout << "testConcurrent2:\n";
|
||||
testConcurrent2();
|
||||
std::cout << std::string(40, '-') << "\n";
|
||||
|
||||
std::cout << "testMain1:\n";
|
||||
testMain1();
|
||||
std::cout << std::string(40, '-') << "\n";
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user