From ab53fa26a10e27fced2fc95370ef6b734ffe59d3 Mon Sep 17 00:00:00 2001
From: charonxin <1656746727@qq.com>
Date: Mon, 14 Aug 2023 23:04:45 +0800
Subject: [PATCH 1/2] [2_3] add modification_test

---
 tests/Kernel/Types/modification_test.cpp | 143 +++++++++++++++++++++++
 1 file changed, 143 insertions(+)
 create mode 100644 tests/Kernel/Types/modification_test.cpp

diff --git a/tests/Kernel/Types/modification_test.cpp b/tests/Kernel/Types/modification_test.cpp
new file mode 100644
index 000000000..c67be2770
--- /dev/null
+++ b/tests/Kernel/Types/modification_test.cpp
@@ -0,0 +1,143 @@
+#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
+
+#include "doctest/doctest.h"
+#include "modification.hpp"
+
+TEST_CASE ("test construct func") {
+    modification m1 (MOD_ASSIGN, path (), tree ());
+    modification m2 (MOD_ASSIGN, path (), tree ());
+    CHECK_EQ (m1 == m2, true);
+    CHECK_EQ (m1 != m2, false);
+    CHECK_EQ (m1->k == MOD_ASSIGN, true);
+    CHECK_EQ (m1->p == path (), true);
+    CHECK_EQ (m1->t == tree (), true);
+    CHECK_EQ (m2->k == MOD_ASSIGN, true);
+    CHECK_EQ (m2->p == path (), true);
+    CHECK_EQ (m2->t == tree (), true);
+}
+
+TEST_CASE ("test mod_assign") {
+    modification m1 = mod_assign (path (), tree ());
+    modification m2 = mod_assign (path (), tree ());
+    CHECK_EQ (m1 == m2, true);
+    CHECK_EQ (m1 != m2, false);
+    CHECK_EQ (m1->k == MOD_ASSIGN, true);
+    CHECK_EQ (m1->p == path (), true);
+    CHECK_EQ (m1->t == tree (), true);
+    CHECK_EQ (m2->k == MOD_ASSIGN, true);
+    CHECK_EQ (m2->p == path (), true);
+    CHECK_EQ (m2->t == tree (), true);
+}
+
+TEST_CASE ("test mod_insert") {
+    modification m1 = mod_insert (path (), 0, tree ());
+    modification m2 = mod_insert (path (), 0, tree ());
+    CHECK_EQ (m1 == m2, true);
+    CHECK_EQ (m1 != m2, false);
+    CHECK_EQ (m1->k == MOD_INSERT, true);
+    CHECK_EQ (m1->t == tree (), true);
+    CHECK_EQ (m2->k == MOD_INSERT, true);
+    CHECK_EQ (m2->t == tree (), true);
+}
+
+TEST_CASE ("test mod_remove") {
+    modification m1 = mod_remove (path (),1,2);
+    modification m2 = mod_remove (path (),1,2);
+    CHECK_EQ (m1 == m2, true);
+    CHECK_EQ (m1 != m2, false);
+    CHECK_EQ (m1->k == MOD_REMOVE, true);
+    CHECK_EQ (m1->p[0] == 1, true);
+    CHECK_EQ (m1->p[1] == 2, true);
+    CHECK_EQ (m1->t == tree (), true);
+    CHECK_EQ (m2->k == MOD_REMOVE, true);
+    CHECK_EQ (m2->t == tree (), true);
+}
+
+TEST_CASE ("test mod_split") {
+    modification m1 = mod_split (path (), 1, 2);
+    modification m2 = mod_split (path (), 1, 2);
+    CHECK_EQ (m1 == m2, true);
+    CHECK_EQ (m1 != m2, false);
+    CHECK_EQ (m1->k == MOD_SPLIT, true);
+    CHECK_EQ (m1->p[0] == 1, true);
+    CHECK_EQ (m1->p[1] == 2, true);
+    CHECK_EQ (m1->t == tree (), true);
+    CHECK_EQ (m2->k == MOD_SPLIT, true);
+    CHECK_EQ (m2->t == tree (), true);
+}
+
+TEST_CASE ("test mod_join") {
+    modification m1 = mod_join (path (), 1);
+    modification m2 = mod_join (path (), 1);
+    CHECK_EQ (m1 == m2, true);
+    CHECK_EQ (m1 != m2, false);
+    CHECK_EQ (m1->k == MOD_JOIN, true);
+    CHECK_EQ (m1->p[0] == 1, true);
+    CHECK_EQ (m1->t == tree (), true);
+    CHECK_EQ (m2->k == MOD_JOIN, true);
+    CHECK_EQ (m2->t == tree (), true);
+    modification m3 = mod_join (path (1), 2);
+    CHECK_EQ (m3->k == MOD_JOIN, true);
+    CHECK_EQ (m3->p[0] == 1, true);
+    CHECK_EQ (m3->p[1] == 2, true);
+}
+
+TEST_CASE ("test mod_assign_node") {
+    modification m1 = mod_assign_node (path (), 1);
+    modification m2 = mod_assign_node (path (), 1);
+    CHECK_EQ (m1 == m2, true);
+    CHECK_EQ (m1 != m2, false);
+    CHECK_EQ (m1->k == MOD_ASSIGN_NODE, true);
+    CHECK_EQ (m1->p == path (), true);
+    CHECK_EQ (m1->t == tree (1), true);
+    CHECK_EQ (m2->k == MOD_ASSIGN_NODE, true);
+    CHECK_EQ (m2->p == path (), true);
+    CHECK_EQ (m2->t == tree (1), true);
+}
+
+TEST_CASE ("test mod_insert_node") {
+    modification m1 = mod_insert_node (path (), 1, tree ());
+    modification m2 = mod_insert_node (path (), 1, tree ());
+    CHECK_EQ (m1 == m2, true);
+    CHECK_EQ (m1 != m2, false);
+    CHECK_EQ (m1->k == MOD_INSERT_NODE, true);
+    CHECK_EQ (m1->p[0] == 1, true);
+    CHECK_EQ (m1->t == tree (), true);
+    CHECK_EQ (m2->k == MOD_INSERT_NODE, true);
+    CHECK_EQ (m2->p[0] == 1, true);
+    CHECK_EQ (m2->t == tree (), true);
+    modification m3 = mod_insert_node (path (), 2, tree ("string"));
+    CHECK_EQ (m3->k == MOD_INSERT_NODE, true);
+    CHECK_EQ (m3->p[0] == 2, true);
+    CHECK_EQ (m3->t == tree ("string"), true);
+}
+
+TEST_CASE ("test mod_remove_node") {
+    modification m1 = mod_remove_node (path (), 1);
+    modification m2 = mod_remove_node (path (), 1);
+    CHECK_EQ (m1 == m2, true);
+    CHECK_EQ (m1 != m2, false);
+    CHECK_EQ (m1->k == MOD_REMOVE_NODE, true);
+    CHECK_EQ (m1->p[0] == 1, true);
+    CHECK_EQ (m1->t == tree (), true);
+    CHECK_EQ (m2->k == MOD_REMOVE_NODE, true);
+    CHECK_EQ (m2->p[0] == 1, true);
+    CHECK_EQ (m2->t == tree (), true);
+}
+
+TEST_CASE ("test mod_set_cursor") {
+    modification m1 = mod_set_cursor (path (), 1, tree ());
+    modification m2 = mod_set_cursor (path (), 1, tree ());
+    CHECK_EQ (m1 == m2, true);
+    CHECK_EQ (m1 != m2, false);
+    CHECK_EQ (m1->k == MOD_SET_CURSOR, true);
+    CHECK_EQ (m1->p[0] == 1, true);
+    CHECK_EQ (m1->t == tree (), true);
+    CHECK_EQ (m2->k == MOD_SET_CURSOR, true);
+    CHECK_EQ (m2->p[0] == 1, true);
+    CHECK_EQ (m2->t == tree (), true);
+    modification m3 = mod_set_cursor (path (), 2, tree ("string"));
+    CHECK_EQ (m3->k == MOD_SET_CURSOR, true);
+    CHECK_EQ (m3->p[0] == 2, true);
+    CHECK_EQ (m3->t == tree ("string"), true);
+}
\ No newline at end of file

From 18c675294ed824a9619864aa93c2e7cd9c5b2d79 Mon Sep 17 00:00:00 2001
From: charonxin <1656746727@qq.com>
Date: Tue, 15 Aug 2023 10:17:22 +0800
Subject: [PATCH 2/2] add more tests

---
 tests/Kernel/Types/modification_test.cpp | 360 ++++++++++++++++-------
 1 file changed, 251 insertions(+), 109 deletions(-)

diff --git a/tests/Kernel/Types/modification_test.cpp b/tests/Kernel/Types/modification_test.cpp
index c67be2770..3a6aa918d 100644
--- a/tests/Kernel/Types/modification_test.cpp
+++ b/tests/Kernel/Types/modification_test.cpp
@@ -4,140 +4,282 @@
 #include "modification.hpp"
 
 TEST_CASE ("test construct func") {
-    modification m1 (MOD_ASSIGN, path (), tree ());
-    modification m2 (MOD_ASSIGN, path (), tree ());
-    CHECK_EQ (m1 == m2, true);
-    CHECK_EQ (m1 != m2, false);
-    CHECK_EQ (m1->k == MOD_ASSIGN, true);
-    CHECK_EQ (m1->p == path (), true);
-    CHECK_EQ (m1->t == tree (), true);
-    CHECK_EQ (m2->k == MOD_ASSIGN, true);
-    CHECK_EQ (m2->p == path (), true);
-    CHECK_EQ (m2->t == tree (), true);
+  modification m1 (MOD_ASSIGN, path (), tree ());
+  modification m2 (MOD_ASSIGN, path (), tree ());
+  CHECK_EQ (m1 == m2, true);
+  CHECK_EQ (m1 != m2, false);
+  CHECK_EQ (m1->k == MOD_ASSIGN, true);
+  CHECK_EQ (m1->p == path (), true);
+  CHECK_EQ (m1->t == tree (), true);
+  CHECK_EQ (m2->k == MOD_ASSIGN, true);
+  CHECK_EQ (m2->p == path (), true);
+  CHECK_EQ (m2->t == tree (), true);
 }
 
 TEST_CASE ("test mod_assign") {
-    modification m1 = mod_assign (path (), tree ());
-    modification m2 = mod_assign (path (), tree ());
-    CHECK_EQ (m1 == m2, true);
-    CHECK_EQ (m1 != m2, false);
-    CHECK_EQ (m1->k == MOD_ASSIGN, true);
-    CHECK_EQ (m1->p == path (), true);
-    CHECK_EQ (m1->t == tree (), true);
-    CHECK_EQ (m2->k == MOD_ASSIGN, true);
-    CHECK_EQ (m2->p == path (), true);
-    CHECK_EQ (m2->t == tree (), true);
+  modification m1= mod_assign (path (), tree ());
+  modification m2= mod_assign (path (), tree ());
+  CHECK_EQ (m1 == m2, true);
+  CHECK_EQ (m1 != m2, false);
+  CHECK_EQ (m1->k == MOD_ASSIGN, true);
+  CHECK_EQ (m1->p == path (), true);
+  CHECK_EQ (m1->t == tree (), true);
+  CHECK_EQ (m2->k == MOD_ASSIGN, true);
+  CHECK_EQ (m2->p == path (), true);
+  CHECK_EQ (m2->t == tree (), true);
 }
 
 TEST_CASE ("test mod_insert") {
-    modification m1 = mod_insert (path (), 0, tree ());
-    modification m2 = mod_insert (path (), 0, tree ());
-    CHECK_EQ (m1 == m2, true);
-    CHECK_EQ (m1 != m2, false);
-    CHECK_EQ (m1->k == MOD_INSERT, true);
-    CHECK_EQ (m1->t == tree (), true);
-    CHECK_EQ (m2->k == MOD_INSERT, true);
-    CHECK_EQ (m2->t == tree (), true);
+  modification m1= mod_insert (path (), 0, tree ());
+  modification m2= mod_insert (path (), 0, tree ());
+  CHECK_EQ (m1 == m2, true);
+  CHECK_EQ (m1 != m2, false);
+  CHECK_EQ (m1->k == MOD_INSERT, true);
+  CHECK_EQ (m1->t == tree (), true);
+  CHECK_EQ (m2->k == MOD_INSERT, true);
+  CHECK_EQ (m2->t == tree (), true);
 }
 
 TEST_CASE ("test mod_remove") {
-    modification m1 = mod_remove (path (),1,2);
-    modification m2 = mod_remove (path (),1,2);
-    CHECK_EQ (m1 == m2, true);
-    CHECK_EQ (m1 != m2, false);
-    CHECK_EQ (m1->k == MOD_REMOVE, true);
-    CHECK_EQ (m1->p[0] == 1, true);
-    CHECK_EQ (m1->p[1] == 2, true);
-    CHECK_EQ (m1->t == tree (), true);
-    CHECK_EQ (m2->k == MOD_REMOVE, true);
-    CHECK_EQ (m2->t == tree (), true);
+  modification m1= mod_remove (path (), 1, 2);
+  modification m2= mod_remove (path (), 1, 2);
+  CHECK_EQ (m1 == m2, true);
+  CHECK_EQ (m1 != m2, false);
+  CHECK_EQ (m1->k == MOD_REMOVE, true);
+  CHECK_EQ (m1->p[0] == 1, true);
+  CHECK_EQ (m1->p[1] == 2, true);
+  CHECK_EQ (m1->t == tree (), true);
+  CHECK_EQ (m2->k == MOD_REMOVE, true);
+  CHECK_EQ (m2->t == tree (), true);
 }
 
 TEST_CASE ("test mod_split") {
-    modification m1 = mod_split (path (), 1, 2);
-    modification m2 = mod_split (path (), 1, 2);
-    CHECK_EQ (m1 == m2, true);
-    CHECK_EQ (m1 != m2, false);
-    CHECK_EQ (m1->k == MOD_SPLIT, true);
-    CHECK_EQ (m1->p[0] == 1, true);
-    CHECK_EQ (m1->p[1] == 2, true);
-    CHECK_EQ (m1->t == tree (), true);
-    CHECK_EQ (m2->k == MOD_SPLIT, true);
-    CHECK_EQ (m2->t == tree (), true);
+  modification m1= mod_split (path (), 1, 2);
+  modification m2= mod_split (path (), 1, 2);
+  CHECK_EQ (m1 == m2, true);
+  CHECK_EQ (m1 != m2, false);
+  CHECK_EQ (m1->k == MOD_SPLIT, true);
+  CHECK_EQ (m1->p[0] == 1, true);
+  CHECK_EQ (m1->p[1] == 2, true);
+  CHECK_EQ (m1->t == tree (), true);
+  CHECK_EQ (m2->k == MOD_SPLIT, true);
+  CHECK_EQ (m2->t == tree (), true);
 }
 
 TEST_CASE ("test mod_join") {
-    modification m1 = mod_join (path (), 1);
-    modification m2 = mod_join (path (), 1);
-    CHECK_EQ (m1 == m2, true);
-    CHECK_EQ (m1 != m2, false);
-    CHECK_EQ (m1->k == MOD_JOIN, true);
-    CHECK_EQ (m1->p[0] == 1, true);
-    CHECK_EQ (m1->t == tree (), true);
-    CHECK_EQ (m2->k == MOD_JOIN, true);
-    CHECK_EQ (m2->t == tree (), true);
-    modification m3 = mod_join (path (1), 2);
-    CHECK_EQ (m3->k == MOD_JOIN, true);
-    CHECK_EQ (m3->p[0] == 1, true);
-    CHECK_EQ (m3->p[1] == 2, true);
+  modification m1= mod_join (path (), 1);
+  modification m2= mod_join (path (), 1);
+  CHECK_EQ (m1 == m2, true);
+  CHECK_EQ (m1 != m2, false);
+  CHECK_EQ (m1->k == MOD_JOIN, true);
+  CHECK_EQ (m1->p[0] == 1, true);
+  CHECK_EQ (m1->t == tree (), true);
+  CHECK_EQ (m2->k == MOD_JOIN, true);
+  CHECK_EQ (m2->t == tree (), true);
+  modification m3= mod_join (path (1), 2);
+  CHECK_EQ (m3->k == MOD_JOIN, true);
+  CHECK_EQ (m3->p[0] == 1, true);
+  CHECK_EQ (m3->p[1] == 2, true);
 }
 
 TEST_CASE ("test mod_assign_node") {
-    modification m1 = mod_assign_node (path (), 1);
-    modification m2 = mod_assign_node (path (), 1);
-    CHECK_EQ (m1 == m2, true);
-    CHECK_EQ (m1 != m2, false);
-    CHECK_EQ (m1->k == MOD_ASSIGN_NODE, true);
-    CHECK_EQ (m1->p == path (), true);
-    CHECK_EQ (m1->t == tree (1), true);
-    CHECK_EQ (m2->k == MOD_ASSIGN_NODE, true);
-    CHECK_EQ (m2->p == path (), true);
-    CHECK_EQ (m2->t == tree (1), true);
+  modification m1= mod_assign_node (path (), 1);
+  modification m2= mod_assign_node (path (), 1);
+  CHECK_EQ (m1 == m2, true);
+  CHECK_EQ (m1 != m2, false);
+  CHECK_EQ (m1->k == MOD_ASSIGN_NODE, true);
+  CHECK_EQ (m1->p == path (), true);
+  CHECK_EQ (m1->t == tree (1), true);
+  CHECK_EQ (m2->k == MOD_ASSIGN_NODE, true);
+  CHECK_EQ (m2->p == path (), true);
+  CHECK_EQ (m2->t == tree (1), true);
 }
 
 TEST_CASE ("test mod_insert_node") {
-    modification m1 = mod_insert_node (path (), 1, tree ());
-    modification m2 = mod_insert_node (path (), 1, tree ());
-    CHECK_EQ (m1 == m2, true);
-    CHECK_EQ (m1 != m2, false);
-    CHECK_EQ (m1->k == MOD_INSERT_NODE, true);
-    CHECK_EQ (m1->p[0] == 1, true);
-    CHECK_EQ (m1->t == tree (), true);
-    CHECK_EQ (m2->k == MOD_INSERT_NODE, true);
-    CHECK_EQ (m2->p[0] == 1, true);
-    CHECK_EQ (m2->t == tree (), true);
-    modification m3 = mod_insert_node (path (), 2, tree ("string"));
-    CHECK_EQ (m3->k == MOD_INSERT_NODE, true);
-    CHECK_EQ (m3->p[0] == 2, true);
-    CHECK_EQ (m3->t == tree ("string"), true);
+  modification m1= mod_insert_node (path (), 1, tree ());
+  modification m2= mod_insert_node (path (), 1, tree ());
+  CHECK_EQ (m1 == m2, true);
+  CHECK_EQ (m1 != m2, false);
+  CHECK_EQ (m1->k == MOD_INSERT_NODE, true);
+  CHECK_EQ (m1->p[0] == 1, true);
+  CHECK_EQ (m1->t == tree (), true);
+  CHECK_EQ (m2->k == MOD_INSERT_NODE, true);
+  CHECK_EQ (m2->p[0] == 1, true);
+  CHECK_EQ (m2->t == tree (), true);
+  modification m3= mod_insert_node (path (), 2, tree ("string"));
+  CHECK_EQ (m3->k == MOD_INSERT_NODE, true);
+  CHECK_EQ (m3->p[0] == 2, true);
+  CHECK_EQ (m3->t == tree ("string"), true);
 }
 
 TEST_CASE ("test mod_remove_node") {
-    modification m1 = mod_remove_node (path (), 1);
-    modification m2 = mod_remove_node (path (), 1);
-    CHECK_EQ (m1 == m2, true);
-    CHECK_EQ (m1 != m2, false);
-    CHECK_EQ (m1->k == MOD_REMOVE_NODE, true);
-    CHECK_EQ (m1->p[0] == 1, true);
-    CHECK_EQ (m1->t == tree (), true);
-    CHECK_EQ (m2->k == MOD_REMOVE_NODE, true);
-    CHECK_EQ (m2->p[0] == 1, true);
-    CHECK_EQ (m2->t == tree (), true);
+  modification m1= mod_remove_node (path (), 1);
+  modification m2= mod_remove_node (path (), 1);
+  CHECK_EQ (m1 == m2, true);
+  CHECK_EQ (m1 != m2, false);
+  CHECK_EQ (m1->k == MOD_REMOVE_NODE, true);
+  CHECK_EQ (m1->p[0] == 1, true);
+  CHECK_EQ (m1->t == tree (), true);
+  CHECK_EQ (m2->k == MOD_REMOVE_NODE, true);
+  CHECK_EQ (m2->p[0] == 1, true);
+  CHECK_EQ (m2->t == tree (), true);
 }
 
 TEST_CASE ("test mod_set_cursor") {
-    modification m1 = mod_set_cursor (path (), 1, tree ());
-    modification m2 = mod_set_cursor (path (), 1, tree ());
-    CHECK_EQ (m1 == m2, true);
-    CHECK_EQ (m1 != m2, false);
-    CHECK_EQ (m1->k == MOD_SET_CURSOR, true);
-    CHECK_EQ (m1->p[0] == 1, true);
-    CHECK_EQ (m1->t == tree (), true);
-    CHECK_EQ (m2->k == MOD_SET_CURSOR, true);
-    CHECK_EQ (m2->p[0] == 1, true);
-    CHECK_EQ (m2->t == tree (), true);
-    modification m3 = mod_set_cursor (path (), 2, tree ("string"));
-    CHECK_EQ (m3->k == MOD_SET_CURSOR, true);
-    CHECK_EQ (m3->p[0] == 2, true);
-    CHECK_EQ (m3->t == tree ("string"), true);
+  modification m1= mod_set_cursor (path (), 1, tree ());
+  modification m2= mod_set_cursor (path (), 1, tree ());
+  CHECK_EQ (m1 == m2, true);
+  CHECK_EQ (m1 != m2, false);
+  CHECK_EQ (m1->k == MOD_SET_CURSOR, true);
+  CHECK_EQ (m1->p[0] == 1, true);
+  CHECK_EQ (m1->t == tree (), true);
+  CHECK_EQ (m2->k == MOD_SET_CURSOR, true);
+  CHECK_EQ (m2->p[0] == 1, true);
+  CHECK_EQ (m2->t == tree (), true);
+  modification m3= mod_set_cursor (path (), 2, tree ("string"));
+  CHECK_EQ (m3->k == MOD_SET_CURSOR, true);
+  CHECK_EQ (m3->p[0] == 2, true);
+  CHECK_EQ (m3->t == tree ("string"), true);
+}
+
+TEST_CASE ("test operator*/") {
+  modification m1= mod_assign (path (), tree ());
+  modification m2= 1 * m1;
+  modification m3= path (1) * m1;
+  modification m4= m1 * 1;
+  modification m5= mod_assign (path (1, 2, 3), tree ()) / path (1);
+  CHECK_EQ (m2->k == MOD_ASSIGN, true);
+  CHECK_EQ (m2->p[0] == 1, true);
+  CHECK_EQ (m2->t == tree (), true);
+  CHECK_EQ (m3->k == MOD_ASSIGN, true);
+  CHECK_EQ (m3->p[0] == 1, true);
+  CHECK_EQ (m3->t == tree (), true);
+  CHECK_EQ (m4->k == MOD_ASSIGN, true);
+  CHECK_EQ (m4->p[0] == 1, true);
+  CHECK_EQ (m4->t == tree (), true);
+  CHECK_EQ (m5->k == MOD_ASSIGN, true);
+  CHECK_EQ (m5->p[0] == 2, true);
+  CHECK_EQ (m5->t == tree (), true);
+}
+
+TEST_CASE ("test operator==") {
+  modification m1= mod_assign (path (), tree ());
+  modification m2= mod_assign (path (), tree ());
+  CHECK_EQ (m1 == m2, true);
+  CHECK_EQ (m1 != m2, false);
+  modification m3= mod_assign (path (), tree ("string"));
+  CHECK_EQ (m1 == m3, false);
+  CHECK_EQ (m1 != m3, true);
+}
+
+TEST_CASE ("test copy") {
+  modification m1= mod_assign (path (), tree ());
+  modification m2= copy (m1);
+  CHECK_EQ (m1 == m2, true);
+  CHECK_EQ (m1 != m2, false);
+  CHECK_EQ (m1->k == MOD_ASSIGN, true);
+  CHECK_EQ (m1->p == path (), true);
+  CHECK_EQ (m1->t == tree (), true);
+  CHECK_EQ (m2->k == MOD_ASSIGN, true);
+  CHECK_EQ (m2->p == path (), true);
+  CHECK_EQ (m2->t == tree (), true);
+}
+
+TEST_CASE ("test root") {
+  modification m1= mod_assign (path (), tree ());
+  modification m2= mod_assign (path (1), tree ());
+  modification m3= mod_assign (path (1, 2), tree ());
+  CHECK_EQ (root (m1) == path (), true);
+  CHECK_EQ (root (m2) == path (1), true);
+  CHECK_EQ (root (m3) == path (1, 2), true);
+}
+
+TEST_CASE ("test index") {
+  modification m1= mod_insert (path (1, 2), 3, tree ());
+  modification m2= mod_remove (path (), 3, 4);
+  modification m3= mod_split (path (), 3, 4);
+  modification m4= mod_join (path (), 3);
+  modification m5= mod_remove_node (path (), 3);
+  modification m6= mod_set_cursor (path (), 3, tree ());
+  CHECK_EQ (index (m1) == 3, true);
+  CHECK_EQ (index (m2) == 3, true);
+  CHECK_EQ (index (m3) == 3, true);
+  CHECK_EQ (index (m4) == 3, true);
+  CHECK_EQ (index (m5) == 3, true);
+  CHECK_EQ (index (m6) == 3, true);
+}
+
+TEST_CASE ("test argument") {
+  modification m1= mod_remove (path (), 3, 4);
+  modification m2= mod_split (path (), 3, 4);
+  modification m3= mod_insert_node (path (), 3, tree ());
+  CHECK_EQ (argument (m1) == 4, true);
+  CHECK_EQ (argument (m2) == 4, true);
+  CHECK_EQ (argument (m3) == 3, true);
+}
+
+TEST_CASE ("test make_modification") {
+  make_modification ("assign", path (), tree ());
+  make_modification ("insert", path (), tree ());
+  make_modification ("remove", path (), tree ());
+  make_modification ("split", path (), tree ());
+  make_modification ("join", path (), tree ());
+  make_modification ("assign-node", path (), tree ());
+  make_modification ("insert-node", path (), tree ());
+  make_modification ("remove-node", path (), tree ());
+  make_modification ("set-cursor", path (), tree ());
+}
+
+TEST_CASE ("test get_type") {
+  modification m1= make_modification ("assign", path (), tree ());
+  modification m2= make_modification ("insert", path (), tree ());
+  modification m3= make_modification ("remove", path (), tree ());
+  modification m4= make_modification ("split", path (), tree ());
+  modification m5= make_modification ("join", path (), tree ());
+  modification m6= make_modification ("assign-node", path (), tree ());
+  modification m7= make_modification ("insert-node", path (), tree ());
+  modification m8= make_modification ("remove-node", path (), tree ());
+  modification m9= make_modification ("set-cursor", path (), tree ());
+  CHECK_EQ (get_type (m1) == "assign", true);
+  CHECK_EQ (get_type (m2) == "insert", true);
+  CHECK_EQ (get_type (m3) == "remove", true);
+  CHECK_EQ (get_type (m4) == "split", true);
+  CHECK_EQ (get_type (m5) == "join", true);
+  CHECK_EQ (get_type (m6) == "assign-node", true);
+  CHECK_EQ (get_type (m7) == "insert-node", true);
+  CHECK_EQ (get_type (m8) == "remove-node", true);
+  CHECK_EQ (get_type (m9) == "set-cursor", true);
+}
+
+TEST_CASE ("test get_path") {
+  modification m1= mod_assign (path (), tree ());
+  modification m2= mod_assign (path (1), tree ());
+  modification m3= mod_assign (path (1, 2), tree ());
+  CHECK_EQ (get_path (m1) == path (), true);
+  CHECK_EQ (get_path (m2) == path (1), true);
+  CHECK_EQ (get_path (m3) == path (1, 2), true);
+}
+
+TEST_CASE ("test get_tree") {
+  modification m1= mod_assign (path (), tree ());
+  modification m2= mod_assign (path (), tree ("string"));
+  modification m3= mod_assign (path (), tree (1));
+  CHECK_EQ (get_tree (m1) == tree (), true);
+  CHECK_EQ (get_tree (m2) == tree ("string"), true);
+  CHECK_EQ (get_tree (m3) == tree (1), true);
+}
+
+TEST_CASE ("test is_applicable") {
+  modification m1= mod_assign (path (), tree ());
+  modification m2= mod_assign (path (1), tree ());
+  modification m3= mod_assign (path (1, 2), tree ());
+  CHECK_EQ (is_applicable (tree (), m1), true);
+  CHECK_EQ (is_applicable (tree (), m2), false);
+  CHECK_EQ (is_applicable (tree (), m3), false);
+  CHECK_EQ (is_applicable (tree (1), m1), true);
+  CHECK_EQ (is_applicable (tree (1), m2), false);
+  CHECK_EQ (is_applicable (tree (1), m3), false);
+  CHECK_EQ (is_applicable (tree (1, 2), m1), true);
+  CHECK_EQ (is_applicable (tree (1, 2), m2), true);
+  CHECK_EQ (is_applicable (tree (1, 2), m3), false);
 }
\ No newline at end of file