add text document to v3, planing v4

This commit is contained in:
2022-12-23 03:16:38 +01:00
parent 931436dc11
commit d85a2dc191
8 changed files with 1659 additions and 11 deletions

View File

@ -18,9 +18,9 @@ target_link_libraries(v3_test1 PUBLIC crdt_version3)
########################################
#add_executable(v3_test2
#./test2.cpp
#)
add_executable(v3_test2
./test2.cpp
)
#target_link_libraries(v3_test2 PUBLIC crdt_version3)
target_link_libraries(v3_test2 PUBLIC crdt_version3)

View File

@ -80,7 +80,7 @@ struct List {
//size_t _stat_find_with_hint{0};
//size_t _stat_find_with_hint_hit{0};
std::optional<size_t> findActor(const ActorType& actor) const {
[[nodiscard]] std::optional<size_t> findActor(const ActorType& actor) const {
for (size_t i = 0; i < _actors.size(); i++) {
if (_actors[i] == actor) {
return i;
@ -89,7 +89,7 @@ struct List {
return std::nullopt;
}
std::optional<size_t> findIdx(const ListIDInternal& list_id) const {
[[nodiscard]] std::optional<size_t> findIdx(const ListIDInternal& list_id) const {
extra_assert(verify());
for (size_t i = 0; i < _list_ids.size(); i++) {
@ -102,7 +102,7 @@ struct List {
}
// search close to hint first
std::optional<size_t> findIdx(const ListIDInternal& list_id, size_t hint) const {
[[nodiscard]] std::optional<size_t> findIdx(const ListIDInternal& list_id, size_t hint) const {
extra_assert(verify());
//_stat_find_with_hint++;
@ -140,7 +140,7 @@ struct List {
return findIdx(list_id);
}
std::optional<size_t> findIdx(const ListID& list_id) const {
[[nodiscard]] std::optional<size_t> findIdx(const ListID& list_id) const {
extra_assert(verify());
const auto actor_idx_opt = findActor(list_id.id);
@ -153,7 +153,7 @@ struct List {
return findIdx(tmp_id);
}
std::optional<size_t> findIdx(const ListID& list_id, size_t hint) const {
[[nodiscard]] std::optional<size_t> findIdx(const ListID& list_id, size_t hint) const {
extra_assert(verify());
const auto actor_idx_opt = findActor(list_id.id);
@ -369,12 +369,32 @@ struct List {
return false;
}
[[nodiscard]] bool empty(void) const {
return _list_ids.empty();
}
[[nodiscard]] size_t size(void) const {
return _list_ids.size();
}
[[nodiscard]] ListIDInternal getIDInternal(size_t idx) const {
return _list_ids.at(idx);
}
[[nodiscard]] const ListID getID(size_t idx) const {
return {_actors.at(_list_ids.at(idx).actor_idx), _list_ids.at(idx).seq};
}
[[nodiscard]] const std::optional<ValueType>& getValue(size_t idx) const {
return _list_data.at(idx).value;
}
// returns the size of alive entries
size_t getDocSize(void) const {
[[nodiscard]] size_t getDocSize(void) const {
return _doc_size;
}
std::vector<ValueType> getArray(void) const {
[[nodiscard]] std::vector<ValueType> getArray(void) const {
std::vector<ValueType> array;
for (const auto& e : _list_data) {
if (e.value.has_value()) {

View File

@ -0,0 +1,305 @@
#pragma once
#include "./list.hpp"
#include <variant>
//#include <iostream> // debug
namespace GreenCRDT::V3 {
template<typename ActorType>
struct TextDocument {
// TODO: determine if char is the best
using ListType = List<char, ActorType>;
struct OpAdd {
typename ListType::ListID id;
std::optional<typename ListType::ListID> parent_left;
std::optional<typename ListType::ListID> parent_right;
char value;
};
struct OpDel {
typename ListType::ListID id;
};
using Op = std::variant<OpAdd, OpDel>;
//// TODO: implement
//struct Cursor {
//AgentType who;
//typename ListType::ListID pos;
//};
ActorType local_actor;
ListType state;
[[nodiscard]] std::string getText(void) const {
std::string text;
for (const auto& it : state._list_data) {
if (it.value.has_value()) {
text += it.value.value();
}
}
return text;
}
bool apply(const Op& op) {
if(std::holds_alternative<OpAdd>(op)) {
const auto& add_op = std::get<OpAdd>(op);
//std::cout << "a:" << add_op.id.id << " s:" << add_op.id.seq << " v:" << add_op.value << "\n";
return state.add(add_op.id, add_op.value, add_op.parent_left, add_op.parent_right);
} else if (std::holds_alternative<OpDel>(op)) {
const auto& del_op = std::get<OpDel>(op);
return state.del(del_op.id);
} else {
assert(false);
}
}
bool apply(const std::vector<Op>& ops) {
for (const auto& op : ops) {
if (!apply(op)) {
// this is not ideal, since we might have applyed some, and dont report which/howmany
return false;
}
}
return true;
}
static std::vector<Op> text2adds(
const ActorType& actor, uint64_t seq, // seq is the first seq
std::optional<typename ListType::ListID> parent_left,
std::optional<typename ListType::ListID> parent_right,
std::string_view text
) {
std::vector<Op> ops;
for (size_t i = 0; i < text.size(); i++) {
typename ListType::ListID new_id {actor, seq++};
ops.emplace_back(OpAdd{
new_id,
parent_left,
parent_right,
text[i]
});
parent_left = new_id;
}
return ops;
}
// adds in tast with specified parents
// returns generated ops
std::vector<Op> addText(
std::optional<typename ListType::ListID> parent_left,
std::optional<typename ListType::ListID> parent_right,
std::string_view text
) {
// TODO: move actor setting to list
if (!state.findActor(local_actor).has_value()) {
state._actors.push_back(local_actor);
}
// TODO: look up typesystem and fix (move? decltype?)
std::vector<Op> ops = text2adds(
// TODO: abstract actors
local_actor, state._last_seen_seq.count(state.findActor(local_actor).value()) ? state._last_seen_seq[state.findActor(local_actor).value()]+1u : 0u,
parent_left,
parent_right,
text
);
// TODO: make this better
// and apply
for (const auto& op : ops) {
if(std::holds_alternative<OpAdd>(op)) {
const auto& add_op = std::get<OpAdd>(op);
//std::cout << "a:" << add_op.id.id << " s:" << add_op.id.seq << " v:" << add_op.value << "\n";
bool r = state.add(add_op.id, add_op.value, add_op.parent_left, add_op.parent_right);
assert(r);
} else if (std::holds_alternative<OpDel>(op)) {
const auto& del_op = std::get<OpDel>(op);
state.del(del_op.id);
} else {
assert(false);
}
}
return ops; // TODO: move?
}
// deletes everything in range [first, last)
// returns generated ops
std::vector<Op> delRange(
std::optional<typename ListType::ListID> left,
std::optional<typename ListType::ListID> right
) {
size_t first_idx = 0;
if (left.has_value()) {
auto res = state.findIdx(left.value());
if (!res.has_value()) {
assert(false && "cant find left");
return {};
}
first_idx = res.value();
}
size_t last_idx = state.size();
if (right.has_value()) {
auto res = state.findIdx(right.value());
if (!res.has_value()) {
assert(false && "cant find right");
return {};
}
last_idx = res.value();
}
std::vector<Op> ops;
for (size_t i = first_idx; i < last_idx; i++) {
if (!state.getValue(i).has_value()) {
// allready deleted
continue;
}
ops.emplace_back(OpDel{
//state.list.at(i).id
state.getID(i)
});
// TODO: do delets get a seq?????
state.del(state.getID(i));
}
return ops;
}
// generates ops from the difference
// note: rn it only creates 1 diff patch
std::vector<Op> merge(std::string_view text) {
if (text.empty()) {
if (state.empty() || state.getDocSize() == 0) {
// no op
return {};
} else {
// delete all
return delRange(std::nullopt, std::nullopt);
}
}
// text not empty
if (state.empty()) {
return addText(
std::nullopt,
std::nullopt,
text
);
}
// neither empty
// find start and end of changes
// start
size_t list_start = 0;
size_t list_start_counted = 0;
size_t text_start = 0;
bool differ = false;
for (; list_start < state.size() && text_start < text.size();) {
// jump over tombstones
if (!state.getValue(list_start).has_value()) {
list_start++;
continue;
}
if (state.getValue(list_start).value() != text[text_start]) {
differ = true;
break;
}
list_start++;
text_start++;
list_start_counted++;
}
// doc and text dont differ
if (!differ && list_start == state.size() && text_start == text.size()) {
return {};
}
//std::cout << "list.size: " << state.list.size() << "(" << getText().size() << ")" << " text.size: " << text.size() << "\n";
//std::cout << "list_start: " << list_start << " text_start: " << text_start << "\n";
// +1 so i can have unsigned
size_t list_end = state.size();
size_t text_end = text.size();
//for (; list_end > 0 && text_end > 0 && list_end >= list_start && text_end >= text_start;) {
//while (list_end >= list_start && text_end >= text_start) {
size_t list_end_counted = 0;
differ = false; // var reuse
//while (list_start_counted - list_end_counted > state.doc_size && text_end >= text_start) {
while (state.getDocSize() - list_start_counted > list_end_counted && text_end >= text_start) {
// jump over tombstones
if (!state.getValue(list_end-1).has_value()) {
list_end--;
continue;
}
if (state.getValue(list_end-1).value() != text[text_end-1]) {
differ = true;
break;
}
list_end--;
text_end--;
list_end_counted++;
}
if (!differ && text_start == text_end+1) {
// we ran into eachother without seeing the different char
// TODO: do we need to increment list_end? text_end?
list_end++;
}
//std::cout << "list_end: " << list_end << " text_end: " << text_end << "\n";
//std::cout << "substring before: " << text.substr(text_start, text.size() - state.doc_size) << "\n";
std::vector<Op> ops;
// 1. clear range (del all list_start - list_end)
if (list_start <= list_end && list_start < state.size()) {
//list_end += list_start == list_end;
ops = delRange(
state.getID(list_start),
list_end < state.size() ? std::make_optional(state.getID(list_end)) : std::nullopt
);
//std::cout << "deleted: " << ops.size() << "\n";
}
//std::cout << "text between: " << getText() << "\n";
//std::cout << "substring between: " << text.substr(text_start, text.size() - state.doc_size) << "\n";
// 2. add range (add all text_start - text_end)
if (state.getDocSize() < text.size()) {
auto tmp_add_ops = addText(
list_start == 0 ? std::nullopt : std::make_optional(state.getID(list_start-1)),
list_start == state.size() ? std::nullopt :std::make_optional(state.getID(list_start)),
text.substr(text_start, text.size() - state.getDocSize())
);
//std::cout << "added: " << tmp_add_ops.size() << "\n";
ops.insert(ops.end(), tmp_add_ops.begin(), tmp_add_ops.end());
}
return ops;
}
};
} // GreenCRDT::V3

701
version3/test2.cpp Normal file
View File

@ -0,0 +1,701 @@
#include <green_crdt/v3/text_document.hpp>
#include <numeric>
#include <optional>
#include <random>
#include <iostream>
#include <cassert>
#include <variant>
// single letter agent, for testing only
using Agent = std::string;
using Doc = GreenCRDT::V3::TextDocument<Agent>;
using Op = Doc::Op;
using ListType = Doc::ListType;
// maybe switch it up?
//using Rng = std::minstd_rand;
//using Rng = std::mt19937;
using Rng = std::ranlux24_base;
// 10*7 -> 70 permutations , ggwp
// | 1add | 1del | 1rep | 2add | 2del | 2rep | random add | random del | random rep | random
// empty doc | | 0 | 0 | | 0 | 0 | x | 0 | 0 |
// before 1 char | | | | | | | | | |
// after 1 char | | | | | | | | | |
// before 2 char | | | | | | | | | |
// in 2 char | | | | | | | | | |
// after 2 char | | | | | | | | | |
// random | | | | | | | | | |
static const std::vector<char> random_chars {
'a', 'b', 'c', 'd', 'e',
'f', 'g', 'h', 'i', 'j',
'k', 'l', 'm', 'n', 'o',
'p', 'q', 'r', 's', 't',
'u', 'v', 'w', 'x', 'y',
'z',
'A', 'B', 'C', 'D', 'E',
'F', 'G', 'H', 'I', 'J',
'K', 'L', 'M', 'N', 'O',
'P', 'Q', 'R', 'S', 'T',
'U', 'V', 'W', 'X', 'Y',
'Z',
};
std::ostream& operator<<(std::ostream& out, const std::optional<ListType::ListID>& id) {
if (id.has_value()) {
out << id.value().id << "-" << id.value().seq;
} else {
out << "null";
}
return out;
}
std::ostream& operator<<(std::ostream& out, const Doc::OpAdd& op) {
out
<< "{ id:" << op.id.id
<< "-" << op.id.seq
<< ", v:" << op.value
<< ", l:" << op.parent_left
<< ", r:" << op.parent_right
<< " }"
;
return out;
}
// genX() changes doc, uses local agent
Op genAdd(Rng& rng, Doc& doc) {
Doc::OpAdd op {
{doc.local_actor, 0u},
std::nullopt,
std::nullopt,
random_chars[rng()%random_chars.size()]
};
// TODO: move to list
// make sure actor index exists
if (!doc.state.findActor(doc.local_actor).has_value()) {
doc.state._actors.push_back(doc.local_actor);
}
// first id is 0
if (doc.state._last_seen_seq.count(doc.state.findActor(doc.local_actor).value())) {
op.id.seq = doc.state._last_seen_seq[doc.state.findActor(doc.local_actor).value()] + 1;
}
if (!doc.state.empty()) {
// gen parents
size_t li = rng()%(1+doc.state.size());
if (li != doc.state.size()) { // nullopt
op.parent_left = doc.state.getID(li);
}
//size_t r_range = 1+doc.state.list.size();
//if (li != doc.state.list.size()) {
//r_range -= li+1;
//}
//size_t ri = rng()%r_range;
//if (li != doc.state.list.size()) {
//ri += li+1;
//}
//if (ri != doc.state.list.size()) { // nullopt
//op.parent_right = doc.state.list[li].id;
//}
if (op.parent_left.has_value()) {
if (doc.state.size() != li + 1) { // left is not last
op.parent_right = doc.state.getID(li+1);
}
} else {
// left is before first, so right is first
op.parent_right = doc.state.getID(0);
}
} // else first char, both nullopt
//std::cout << "op: " << op << "\n";
{
bool r = doc.state.add(op.id, op.value, op.parent_left, op.parent_right);
if (!r) {
std::cout << "op: " << op << "\n";
}
assert(r);
}
return op;
}
Op genDel(Rng& rng, Doc& doc) {
if (doc.state.getDocSize() == 0) {
assert(false && "empty doc");
return {}; // empty
}
doc.state.verify();
Doc::OpDel op{};
// search for undelted entry
size_t idx = rng()%doc.state.size();
bool found = false;
for (size_t attempts = 0; attempts <= doc.state.size(); attempts++) {
//if (doc.state.list[idx].value.has_value()) {
if (doc.state.getValue(idx).has_value()) {
op.id = doc.state.getID(idx);
found = true;
break;
}
idx = (idx+1) % doc.state.size();
}
assert(found);
{
auto size_pre = doc.state.getDocSize();
bool r = doc.state.del(op.id);
assert(r);
assert(size_pre-1 == doc.state.getDocSize());
assert(doc.state.verify());
}
return op;
}
//genRep()
//genAddContRange()
//genDelContRange()
//genRepContRange()
//genRand()
//genRandRanges()
std::vector<Op> genRandAll(Rng& rng, Doc& doc) {
switch (rng() % 1) {
case 0:
return {genAdd(rng, doc)};
}
return {};
}
void testEmptyDocAdds(size_t seed) {
Rng rng(seed);
Doc doc; // empty
doc.local_actor = 'A';
std::string changed_text;
{
// for modifying
Doc doctmp = doc;
const size_t loop_count = (rng() % 55)+1;
for (size_t i = 0; i < loop_count; i++) {
genAdd(rng, doctmp);
}
changed_text = doctmp.getText();
}
assert(doc.getText() != changed_text);
std::cout << "changed_text: " << changed_text << "\n";
Doc otherdoc = doc;
assert(doc.getText().size() == doc.state.getDocSize());
const auto merge_ops = doc.merge(changed_text);
assert(doc.getText().size() == doc.state.getDocSize());
assert(doc.getText() == changed_text);
assert(otherdoc.apply(merge_ops));
assert(doc.getText() == otherdoc.getText());
}
void test1CharDocAdds(size_t seed) {
Rng rng(seed);
Doc doc;
doc.local_actor = 'A';
doc.addText(std::nullopt, std::nullopt, "0");
assert(doc.getText() == "0");
std::string changed_text;
{
// for modifying
Doc doctmp = doc;
const size_t loop_count = (rng() % 4)+1;
for (size_t i = 0; i < loop_count; i++) {
genAdd(rng, doctmp);
}
changed_text = doctmp.getText();
}
assert(doc.getText() != changed_text);
std::cout << "text: " << doc.getText() << "\n";
std::cout << "changed_text: " << changed_text << "\n";
Doc otherdoc = doc;
assert(doc.getText().size() == doc.state.getDocSize());
const auto merge_ops = doc.merge(changed_text);
assert(doc.getText().size() == doc.state.getDocSize());
std::cout << "text after merge: " << doc.getText() << "\n";
assert(doc.getText() == changed_text);
assert(otherdoc.apply(merge_ops));
assert(doc.getText() == otherdoc.getText());
}
void test1CharDocDels(size_t seed) {
Rng rng(seed);
Doc doc;
doc.local_actor = 'A';
assert(doc.getText().size() == doc.state.getDocSize());
doc.addText(std::nullopt, std::nullopt, "0123");
assert(doc.getText().size() == doc.state.getDocSize());
assert(doc.getText() == "0123");
std::string changed_text;
{
// for modifying
Doc doctmp = doc;
const size_t loop_count = (rng() % 4)+1;
std::cout << "going to delete: " << loop_count << "\n";
for (size_t i = 0; i < loop_count; i++) {
genDel(rng, doctmp);
}
changed_text = doctmp.getText();
assert(doctmp.getText().size() == doctmp.state.getDocSize());
if (loop_count == doc.state.getDocSize()) {
assert(doctmp.state.getDocSize() == 0);
assert(changed_text.size() == 0);
}
}
assert(doc.getText() != changed_text);
std::cout << "text: " << doc.getText() << "\n";
std::cout << "changed_text: " << changed_text << "\n";
Doc otherdoc = doc;
assert(doc.getText().size() == doc.state.getDocSize());
const auto merge_ops = doc.merge(changed_text);
assert(doc.getText().size() == doc.state.getDocSize());
std::cout << "text after merge: " << doc.getText() << "\n";
assert(doc.getText() == changed_text);
assert(otherdoc.apply(merge_ops));
assert(doc.getText() == otherdoc.getText());
}
void test2CharDocAdds(size_t seed) {
Rng rng(seed);
Doc doc;
doc.local_actor = 'A';
assert(doc.getText().size() == doc.state.getDocSize());
doc.addText(std::nullopt, std::nullopt, "012345");
assert(doc.getText().size() == doc.state.getDocSize());
assert(doc.getText() == "012345");
std::string changed_text;
{
// for modifying
Doc doctmp = doc;
const size_t loop_count = (rng() % 6)+1;
for (size_t i = 0; i < loop_count; i++) {
genAdd(rng, doctmp);
}
changed_text = doctmp.getText();
}
assert(doc.getText() != changed_text);
std::cout << "text: " << doc.getText() << "\n";
std::cout << "changed_text: " << changed_text << "\n";
Doc otherdoc = doc;
assert(doc.getText().size() == doc.state.getDocSize());
const auto merge_ops = doc.merge(changed_text);
assert(doc.getText().size() == doc.state.getDocSize());
std::cout << "text after merge: " << doc.getText() << "\n";
assert(doc.getText() == changed_text);
assert(otherdoc.apply(merge_ops));
assert(doc.getText() == otherdoc.getText());
}
void testChange1(size_t seed) {
Rng rng(seed);
Doc doc;
doc.local_actor = 'A';
assert(doc.getText().size() == doc.state.getDocSize());
doc.addText(std::nullopt, std::nullopt, "012345");
assert(doc.getText().size() == doc.state.getDocSize());
assert(doc.getText() == "012345");
std::string changed_text;
{
// for modifying
Doc doctmp = doc;
{ // dels
const size_t loop_count = (rng() % 6)+1;
for (size_t i = 0; i < loop_count; i++) {
genDel(rng, doctmp);
}
}
{ // adds
const size_t loop_count = (rng() % 6)+1;
for (size_t i = 0; i < loop_count; i++) {
genAdd(rng, doctmp);
}
}
changed_text = doctmp.getText();
}
assert(doc.getText() != changed_text);
std::cout << "text: " << doc.getText() << "\n";
std::cout << "changed_text: " << changed_text << "\n";
Doc otherdoc = doc;
assert(doc.getText().size() == doc.state.getDocSize());
const auto merge_ops = doc.merge(changed_text);
assert(doc.getText().size() == doc.state.getDocSize());
std::cout << "text after merge: " << doc.getText() << "\n";
assert(doc.getText() == changed_text);
assert(otherdoc.apply(merge_ops));
assert(doc.getText() == otherdoc.getText());
}
void testBugSame(void) {
Doc doc;
doc.local_actor = 'A';
std::string_view new_text1{"a"};
doc.merge(new_text1);
assert(doc.getText() == new_text1);
std::string_view new_text2{"aa"};
doc.merge(new_text2);
assert(doc.getText() == new_text2);
}
void testBugDoubleDel(void) {
Doc doc;
doc.local_actor = 'A';
{
std::string_view new_text{"a"};
const auto ops = doc.merge(new_text);
assert(doc.getText() == new_text);
assert(ops.size() == 1);
}
{
std::string_view new_text{""};
const auto ops = doc.merge(new_text);
assert(doc.getText() == new_text);
assert(ops.size() == 1);
assert(std::holds_alternative<Doc::OpDel>(ops.front()));
assert(std::get<Doc::OpDel>(ops.front()).id.seq == 0);
}
{
std::string_view new_text{""};
const auto ops = doc.merge(new_text);
assert(doc.getText() == new_text);
assert(ops.size() == 0);
}
}
void testBugSameDel(void) {
Doc doc;
doc.local_actor = 'A';
{
std::string_view new_text{"a"};
const auto ops = doc.merge(new_text);
assert(doc.getText() == new_text);
assert(ops.size() == 1);
}
{
std::string_view new_text{"aa"};
const auto ops = doc.merge(new_text);
assert(doc.getText() == new_text);
assert(ops.size() == 1);
}
{
std::string_view new_text{"a"};
const auto ops = doc.merge(new_text);
assert(doc.getText() == new_text);
assert(ops.size() == 1);
}
}
void testBugSameDel2(void) {
Doc doc;
doc.local_actor = 'A';
{
std::string_view new_text{"a"};
const auto ops = doc.merge(new_text);
assert(doc.getText() == new_text);
assert(ops.size() == 1);
}
{
std::string_view new_text{"aa"};
const auto ops = doc.merge(new_text);
assert(doc.getText() == new_text);
assert(ops.size() == 1);
}
{
std::string_view new_text{"aaa"};
const auto ops = doc.merge(new_text);
assert(doc.getText() == new_text);
assert(ops.size() == 1);
}
{
std::string_view new_text{"aa"};
const auto ops = doc.merge(new_text);
assert(doc.getText() == new_text);
assert(ops.size() == 1);
}
{
std::string_view new_text{"a"};
const auto ops = doc.merge(new_text);
assert(doc.getText() == new_text);
assert(ops.size() == 1);
}
}
void testMulti1(void) {
Doc docA;
docA.local_actor = 'A';
Doc docB;
docB.local_actor = 'B';
// state A
{
std::string_view new_text{"iiiiiii"};
const auto ops = docA.merge(new_text);
assert(docA.getText() == new_text);
assert(docB.apply(ops));
assert(docB.getText() == new_text);
assert(docB.state.getDocSize() == docA.state.getDocSize());
assert(docB.state.size() == docA.state.size());
}
// now B inserts b
{
std::string_view new_text{"iiibiiii"};
const auto ops = docB.merge(new_text);
assert(docB.getText() == new_text);
assert(ops.size() == 1); // 1 new inserted char, nothing to delete
assert(docA.apply(ops));
assert(docA.getText() == new_text);
}
}
void testPaste1(void) {
Doc docA;
docA.local_actor = 'A';
{
std::string_view new_text{"iiiiiii"};
const auto ops = docA.merge(new_text);
assert(ops.size() == 7);
assert(docA.getText() == new_text);
}
{
std::string_view new_text{"iiiiiii\n"};
const auto ops = docA.merge(new_text);
assert(ops.size() == 1);
assert(docA.getText() == new_text);
}
{
std::string_view new_text{"iiiiiii\niiiiiii"};
const auto ops = docA.merge(new_text);
assert(ops.size() == 7);
assert(docA.getText() == new_text);
}
}
void testPaste2(void) {
Doc docA;
docA.local_actor = 'A';
{
std::string_view new_text{"aiiiiib"};
const auto ops = docA.merge(new_text);
assert(ops.size() == 7);
assert(docA.getText() == new_text);
}
{
std::string_view new_text{"aiiiiib\n"};
const auto ops = docA.merge(new_text);
assert(ops.size() == 1);
assert(docA.getText() == new_text);
}
{
std::string_view new_text{"aiiiiib\naiiiiib"};
const auto ops = docA.merge(new_text);
assert(ops.size() == 7);
assert(docA.getText() == new_text);
}
}
int main(void) {
const size_t loops = 1'000;
{
std::cout << "testEmptyDocAdds:\n";
for (size_t i = 0; i < loops; i++) {
std::cout << "i " << i << "\n";
testEmptyDocAdds(1337+i);
std::cout << std::string(40, '-') << "\n";
}
}
std::cout << std::string(40, '=') << "\n";
{
std::cout << "test1CharDocAdds:\n";
for (size_t i = 0; i < loops; i++) {
std::cout << "i " << i << "\n";
test1CharDocAdds(1337+i);
std::cout << std::string(40, '-') << "\n";
}
}
std::cout << std::string(40, '=') << "\n";
{
std::cout << "test1CharDocDels:\n";
for (size_t i = 0; i < loops; i++) {
std::cout << "i " << i << "\n";
test1CharDocDels(1337+i);
std::cout << std::string(40, '-') << "\n";
}
}
std::cout << std::string(40, '=') << "\n";
{
std::cout << "test2CharDocAdds:\n";
for (size_t i = 0; i < loops; i++) {
std::cout << "i " << i << "\n";
test2CharDocAdds(1337+i);
std::cout << std::string(40, '-') << "\n";
}
}
std::cout << std::string(40, '=') << "\n";
{
std::cout << "testChange1:\n";
for (size_t i = 0; i < loops; i++) {
std::cout << "i " << i << "\n";
testChange1(1337+i);
std::cout << std::string(40, '-') << "\n";
}
}
std::cout << std::string(40, '=') << "\n";
{
std::cout << "testBugSame:\n";
testBugSame();
}
std::cout << std::string(40, '=') << "\n";
{
std::cout << "testBugDoubleDel:\n";
testBugDoubleDel();
}
std::cout << std::string(40, '=') << "\n";
{
std::cout << "testBugSameDel:\n";
testBugSameDel();
}
std::cout << std::string(40, '=') << "\n";
{
std::cout << "testBugSameDel2:\n";
testBugSameDel2();
}
std::cout << std::string(40, '=') << "\n";
{
std::cout << "testMulti1:\n";
testMulti1();
}
std::cout << std::string(40, '=') << "\n";
{
std::cout << "testPaste1:\n";
testPaste1();
}
std::cout << std::string(40, '=') << "\n";
{
std::cout << "testPaste2:\n";
testPaste2();
}
return 0;
}