diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 3042c110a..73b6d307d 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -95,8 +95,9 @@ jobs:
           disable-animations: true
           script: |
             adb shell pm list packages | grep dev.yorkie.test && adb uninstall dev.yorkie.test || true;
-            ./gradlew yorkie:connectedCheck -Pandroid.testInstrumentationRunnerArguments.notAnnotation=androidx.test.filters.LargeTest --no-build-cache --no-daemon --stacktrace
-            ./gradlew yorkie:connectedCheck -Pandroid.testInstrumentationRunnerArguments.annotation=androidx.test.filters.LargeTest --no-build-cache --no-daemon --stacktrace
+            ./gradlew yorkie:connectedCheck -Pandroid.testInstrumentationRunnerArguments.notAnnotation=dev.yorkie.TreeTest --no-build-cache --no-daemon --stacktrace
+            ./gradlew yorkie:connectedCheck -Pandroid.testInstrumentationRunnerArguments.annotation=dev.yorkie.TreeBasicTest --no-build-cache --no-daemon --stacktrace
+            ./gradlew yorkie:connectedCheck -Pandroid.testInstrumentationRunnerArguments.annotation=dev.yorkie.TreeSplitMergeTest --no-build-cache --no-daemon --stacktrace
       - if: ${{ matrix.api-level == 24 }}
         run: ./gradlew yorkie:jacocoDebugTestReport
       - if: ${{ matrix.api-level == 24 }}
diff --git a/yorkie/src/androidTest/kotlin/dev/yorkie/TestAnnotations.kt b/yorkie/src/androidTest/kotlin/dev/yorkie/TestAnnotations.kt
new file mode 100644
index 000000000..779ebb2a7
--- /dev/null
+++ b/yorkie/src/androidTest/kotlin/dev/yorkie/TestAnnotations.kt
@@ -0,0 +1,13 @@
+package dev.yorkie
+
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.RUNTIME)
+internal annotation class TreeTest
+
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.RUNTIME)
+internal annotation class TreeBasicTest
+
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.RUNTIME)
+internal annotation class TreeSplitMergeTest
diff --git a/yorkie/src/androidTest/kotlin/dev/yorkie/document/json/JsonTreeSplitMergeTest.kt b/yorkie/src/androidTest/kotlin/dev/yorkie/document/json/JsonTreeSplitMergeTest.kt
new file mode 100644
index 000000000..9c68bde9e
--- /dev/null
+++ b/yorkie/src/androidTest/kotlin/dev/yorkie/document/json/JsonTreeSplitMergeTest.kt
@@ -0,0 +1,322 @@
+package dev.yorkie.document.json
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.yorkie.TreeSplitMergeTest
+import dev.yorkie.TreeTest
+import dev.yorkie.core.withTwoClientsAndDocuments
+import dev.yorkie.document.json.JsonTreeTest.Companion.rootTree
+import kotlin.test.assertEquals
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@TreeTest
+@TreeSplitMergeTest
+@RunWith(AndroidJUnit4::class)
+class JsonTreeSplitMergeTest {
+
+    @Test
+    fun test_contained_split_and_split_at_the_same_position() {
+        withTwoClientsAndDocuments(realTimeSync = false) { c1, c2, d1, d2, _ ->
+            JsonTreeTest.updateAndSync(
+                JsonTreeTest.Companion.Updater(c1, d1) { root, _ ->
+                    root.setNewTree(
+                        "t",
+                        TreeBuilder.element("r") {
+                            element("p") {
+                                text { "ab" }
+                            }
+                        },
+                    )
+                },
+                JsonTreeTest.Companion.Updater(c2, d2),
+            )
+            JsonTreeTest.assertTreesXmlEquals("<r><p>ab</p></r>", d1, d2)
+
+            JsonTreeTest.updateAndSync(
+                JsonTreeTest.Companion.Updater(c1, d1) { root, _ ->
+                    root.rootTree().edit(2, 2, splitLevel = 1)
+                },
+                JsonTreeTest.Companion.Updater(c2, d2) { root, _ ->
+                    root.rootTree().edit(2, 2, splitLevel = 1)
+                },
+            ) {
+                JsonTreeTest.assertTreesXmlEquals("<r><p>a</p><p>b</p></r>", d1, d2)
+            }
+            JsonTreeTest.assertTreesXmlEquals("<r><p>a</p><p></p><p>b</p></r>", d1, d2)
+        }
+    }
+
+    @Test
+    fun test_contained_split_and_split_at_different_positions_on_the_same_node() {
+        withTwoClientsAndDocuments(realTimeSync = false) { c1, c2, d1, d2, _ ->
+            JsonTreeTest.updateAndSync(
+                JsonTreeTest.Companion.Updater(c1, d1) { root, _ ->
+                    root.setNewTree(
+                        "t",
+                        TreeBuilder.element("r") {
+                            element("p") {
+                                text { "abc" }
+                            }
+                        },
+                    )
+                },
+                JsonTreeTest.Companion.Updater(c2, d2),
+            )
+            JsonTreeTest.assertTreesXmlEquals("<r><p>abc</p></r>", d1, d2)
+
+            JsonTreeTest.updateAndSync(
+                JsonTreeTest.Companion.Updater(c1, d1) { root, _ ->
+                    root.rootTree().edit(2, 2, splitLevel = 1)
+                },
+                JsonTreeTest.Companion.Updater(c2, d2) { root, _ ->
+                    root.rootTree().edit(3, 3, splitLevel = 1)
+                },
+            ) {
+                JsonTreeTest.assertTreesXmlEquals("<r><p>a</p><p>bc</p></r>", d1)
+                JsonTreeTest.assertTreesXmlEquals("<r><p>ab</p><p>c</p></r>", d2)
+            }
+            JsonTreeTest.assertTreesXmlEquals("<r><p>a</p><p>b</p><p>c</p></r>", d1, d2)
+        }
+    }
+
+    @Test
+    fun test_contained_split_and_insert_into_the_split_position() {
+        withTwoClientsAndDocuments(realTimeSync = false) { c1, c2, d1, d2, _ ->
+            JsonTreeTest.updateAndSync(
+                JsonTreeTest.Companion.Updater(c1, d1) { root, _ ->
+                    root.setNewTree(
+                        "t",
+                        TreeBuilder.element("r") {
+                            element("p") {
+                                text { "ab" }
+                            }
+                        },
+                    )
+                },
+                JsonTreeTest.Companion.Updater(c2, d2),
+            )
+            JsonTreeTest.assertTreesXmlEquals("<r><p>ab</p></r>", d1, d2)
+
+            JsonTreeTest.updateAndSync(
+                JsonTreeTest.Companion.Updater(c1, d1) { root, _ ->
+                    root.rootTree().edit(2, 2, splitLevel = 1)
+                },
+                JsonTreeTest.Companion.Updater(c2, d2) { root, _ ->
+                    root.rootTree().edit(2, 2, TreeBuilder.text { "c" })
+                },
+            ) {
+                JsonTreeTest.assertTreesXmlEquals("<r><p>a</p><p>b</p></r>", d1)
+                JsonTreeTest.assertTreesXmlEquals("<r><p>acb</p></r>", d2)
+            }
+            JsonTreeTest.assertTreesXmlEquals("<r><p>ac</p><p>b</p></r>", d1, d2)
+        }
+    }
+
+    @Test
+    fun test_contained_split_and_insert_into_original_node() {
+        withTwoClientsAndDocuments(realTimeSync = false) { c1, c2, d1, d2, _ ->
+            JsonTreeTest.updateAndSync(
+                JsonTreeTest.Companion.Updater(c1, d1) { root, _ ->
+                    root.setNewTree(
+                        "t",
+                        TreeBuilder.element("r") {
+                            element("p") {
+                                text { "ab" }
+                            }
+                        },
+                    )
+                },
+                JsonTreeTest.Companion.Updater(c2, d2),
+            )
+            JsonTreeTest.assertTreesXmlEquals("<r><p>ab</p></r>", d1, d2)
+
+            JsonTreeTest.updateAndSync(
+                JsonTreeTest.Companion.Updater(c1, d1) { root, _ ->
+                    root.rootTree().edit(2, 2, splitLevel = 1)
+                },
+                JsonTreeTest.Companion.Updater(c2, d2) { root, _ ->
+                    root.rootTree().edit(1, 1, TreeBuilder.text { "c" })
+                },
+            ) {
+                JsonTreeTest.assertTreesXmlEquals("<r><p>a</p><p>b</p></r>", d1)
+                JsonTreeTest.assertTreesXmlEquals("<r><p>cab</p></r>", d2)
+            }
+            JsonTreeTest.assertTreesXmlEquals("<r><p>ca</p><p>b</p></r>", d1, d2)
+        }
+    }
+
+    @Test
+    fun test_contained_split_and_insert_into_split_node() {
+        withTwoClientsAndDocuments(realTimeSync = false) { c1, c2, d1, d2, _ ->
+            JsonTreeTest.updateAndSync(
+                JsonTreeTest.Companion.Updater(c1, d1) { root, _ ->
+                    root.setNewTree(
+                        "t",
+                        TreeBuilder.element("r") {
+                            element("p") {
+                                text { "ab" }
+                            }
+                        },
+                    )
+                },
+                JsonTreeTest.Companion.Updater(c2, d2),
+            )
+            JsonTreeTest.assertTreesXmlEquals("<r><p>ab</p></r>", d1, d2)
+
+            JsonTreeTest.updateAndSync(
+                JsonTreeTest.Companion.Updater(c1, d1) { root, _ ->
+                    root.rootTree().edit(2, 2, splitLevel = 1)
+                },
+                JsonTreeTest.Companion.Updater(c2, d2) { root, _ ->
+                    root.rootTree().edit(3, 3, TreeBuilder.text { "c" })
+                },
+            ) {
+                JsonTreeTest.assertTreesXmlEquals("<r><p>a</p><p>b</p></r>", d1)
+                JsonTreeTest.assertTreesXmlEquals("<r><p>abc</p></r>", d2)
+            }
+            JsonTreeTest.assertTreesXmlEquals("<r><p>a</p><p>bc</p></r>", d2)
+        }
+    }
+
+    @Test
+    fun test_contained_split_and_delete_contents_in_split_node() {
+        withTwoClientsAndDocuments(realTimeSync = false) { c1, c2, d1, d2, _ ->
+            JsonTreeTest.updateAndSync(
+                JsonTreeTest.Companion.Updater(c1, d1) { root, _ ->
+                    root.setNewTree(
+                        "t",
+                        TreeBuilder.element("r") {
+                            element("p") {
+                                text { "ab" }
+                            }
+                        },
+                    )
+                },
+                JsonTreeTest.Companion.Updater(c2, d2),
+            )
+            JsonTreeTest.assertTreesXmlEquals("<r><p>ab</p></r>", d1, d2)
+
+            JsonTreeTest.updateAndSync(
+                JsonTreeTest.Companion.Updater(c1, d1) { root, _ ->
+                    root.rootTree().edit(2, 2, splitLevel = 1)
+                },
+                JsonTreeTest.Companion.Updater(c2, d2) { root, _ ->
+                    root.rootTree().edit(2, 3)
+                },
+            ) {
+                JsonTreeTest.assertTreesXmlEquals("<r><p>a</p><p>b</p></r>", d1)
+                JsonTreeTest.assertTreesXmlEquals("<r><p>a</p></r>", d2)
+            }
+
+            JsonTreeTest.assertTreesXmlEquals("<r><p>a</p><p></p></r>", d1, d2)
+        }
+    }
+
+    @Test
+    fun test_split_and_merge_with_empty_paragraph_left() {
+        withTwoClientsAndDocuments(realTimeSync = false) { c1, c2, d1, d2, _ ->
+            d1.updateAsync { root, _ ->
+                root.setNewTree(
+                    "t",
+                    TreeBuilder.element("doc") {
+                        element("p") {
+                            text { "a" }
+                            text { "b" }
+                        }
+                    },
+                )
+            }.await()
+            JsonTreeTest.assertTreesXmlEquals("<doc><p>ab</p></doc>", d1)
+
+            d1.updateAsync { root, _ ->
+                root.rootTree().edit(1, 1, splitLevel = 1)
+            }.await()
+            JsonTreeTest.assertTreesXmlEquals("<doc><p></p><p>ab</p></doc>", d1)
+
+            JsonTreeTest.updateAndSync(
+                JsonTreeTest.Companion.Updater(c1, d1) { root, _ ->
+                    root.rootTree().edit(1, 3)
+                },
+                JsonTreeTest.Companion.Updater(c2, d2),
+            )
+            JsonTreeTest.assertTreesXmlEquals("<doc><p>ab</p></doc>", d1, d2)
+        }
+    }
+
+    @Test
+    fun test_split_and_merge_with_empty_paragraph_left_and_multiple_split_level_left() {
+        withTwoClientsAndDocuments(realTimeSync = false) { c1, c2, d1, d2, _ ->
+            d1.updateAsync { root, _ ->
+                root.setNewTree(
+                    "t",
+                    TreeBuilder.element("doc") {
+                        element("p") {
+                            element("p") {
+                                text { "a" }
+                                text { "b" }
+                            }
+                        }
+                    },
+                )
+            }.await()
+            assertEquals("<doc><p><p>ab</p></p></doc>", d1.getRoot().rootTree().toXml())
+
+            d1.updateAsync { root, _ ->
+                root.rootTree().edit(2, 2, splitLevel = 2)
+            }.await()
+            assertEquals(
+                "<doc><p><p></p></p><p><p>ab</p></p></doc>",
+                d1.getRoot().rootTree().toXml(),
+            )
+
+            JsonTreeTest.updateAndSync(
+                JsonTreeTest.Companion.Updater(c1, d1) { root, _ ->
+                    root.rootTree().edit(2, 6)
+                },
+                JsonTreeTest.Companion.Updater(c2, d2),
+            )
+            JsonTreeTest.assertTreesXmlEquals("<doc><p><p>ab</p></p></doc>", d1, d2)
+        }
+    }
+
+    @Test
+    fun test_split_same_offset_multiple_times() {
+        withTwoClientsAndDocuments(realTimeSync = false) { c1, c2, d1, d2, _ ->
+            d1.updateAsync { root, _ ->
+                root.setNewTree(
+                    "t",
+                    TreeBuilder.element("doc") {
+                        element("p") {
+                            text { "a" }
+                            text { "b" }
+                        }
+                    },
+                )
+            }.await()
+            assertEquals("<doc><p>ab</p></doc>", d1.getRoot().rootTree().toXml())
+
+            d1.updateAsync { root, _ ->
+                root.rootTree().edit(2, 2, splitLevel = 1)
+            }.await()
+            assertEquals("<doc><p>a</p><p>b</p></doc>", d1.getRoot().rootTree().toXml())
+
+            d1.updateAsync { root, _ ->
+                root.rootTree().edit(2, 2, TreeBuilder.text { "c" })
+            }.await()
+            assertEquals("<doc><p>ac</p><p>b</p></doc>", d1.getRoot().rootTree().toXml())
+
+            d1.updateAsync { root, _ ->
+                root.rootTree().edit(2, 2, splitLevel = 1)
+            }.await()
+            assertEquals("<doc><p>a</p><p>c</p><p>b</p></doc>", d1.getRoot().rootTree().toXml())
+
+            JsonTreeTest.updateAndSync(
+                JsonTreeTest.Companion.Updater(c1, d1) { root, _ ->
+                    root.rootTree().edit(2, 7)
+                },
+                JsonTreeTest.Companion.Updater(c2, d2),
+            )
+            JsonTreeTest.assertTreesXmlEquals("<doc><p>ab</p></doc>", d1, d2)
+        }
+    }
+}
diff --git a/yorkie/src/androidTest/kotlin/dev/yorkie/document/json/JsonTreeTest.kt b/yorkie/src/androidTest/kotlin/dev/yorkie/document/json/JsonTreeTest.kt
index b7d4dd86f..cc9d73bc5 100644
--- a/yorkie/src/androidTest/kotlin/dev/yorkie/document/json/JsonTreeTest.kt
+++ b/yorkie/src/androidTest/kotlin/dev/yorkie/document/json/JsonTreeTest.kt
@@ -1,7 +1,8 @@
 package dev.yorkie.document.json
 
 import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.filters.LargeTest
+import dev.yorkie.TreeBasicTest
+import dev.yorkie.TreeTest
 import dev.yorkie.core.Client
 import dev.yorkie.core.GENERAL_TIMEOUT
 import dev.yorkie.core.Presence
@@ -29,7 +30,8 @@ import kotlinx.coroutines.withTimeout
 import org.junit.Test
 import org.junit.runner.RunWith
 
-@LargeTest
+@TreeTest
+@TreeBasicTest
 @OptIn(ExperimentalCoroutinesApi::class)
 @RunWith(AndroidJUnit4::class)
 class JsonTreeTest {
@@ -494,71 +496,6 @@ class JsonTreeTest {
         }
     }
 
-    @Test
-    fun test_contained_split_and_split_at_the_same_position() {
-        withTwoClientsAndDocuments(realTimeSync = false) { c1, c2, d1, d2, _ ->
-            updateAndSync(
-                Updater(c1, d1) { root, _ ->
-                    root.setNewTree(
-                        "t",
-                        element("r") {
-                            element("p") {
-                                text { "ab" }
-                            }
-                        },
-                    )
-                },
-                Updater(c2, d2),
-            )
-            assertTreesXmlEquals("<r><p>ab</p></r>", d1, d2)
-
-            updateAndSync(
-                Updater(c1, d1) { root, _ ->
-                    root.rootTree().edit(2, 2, splitLevel = 1)
-                },
-                Updater(c2, d2) { root, _ ->
-                    root.rootTree().edit(2, 2, splitLevel = 1)
-                },
-            ) {
-                assertTreesXmlEquals("<r><p>a</p><p>b</p></r>", d1, d2)
-            }
-            assertTreesXmlEquals("<r><p>a</p><p></p><p>b</p></r>", d1, d2)
-        }
-    }
-
-    @Test
-    fun test_contained_split_and_split_at_different_positions_on_the_same_node() {
-        withTwoClientsAndDocuments(realTimeSync = false) { c1, c2, d1, d2, _ ->
-            updateAndSync(
-                Updater(c1, d1) { root, _ ->
-                    root.setNewTree(
-                        "t",
-                        element("r") {
-                            element("p") {
-                                text { "abc" }
-                            }
-                        },
-                    )
-                },
-                Updater(c2, d2),
-            )
-            assertTreesXmlEquals("<r><p>abc</p></r>", d1, d2)
-
-            updateAndSync(
-                Updater(c1, d1) { root, _ ->
-                    root.rootTree().edit(2, 2, splitLevel = 1)
-                },
-                Updater(c2, d2) { root, _ ->
-                    root.rootTree().edit(3, 3, splitLevel = 1)
-                },
-            ) {
-                assertTreesXmlEquals("<r><p>a</p><p>bc</p></r>", d1)
-                assertTreesXmlEquals("<r><p>ab</p><p>c</p></r>", d2)
-            }
-            assertTreesXmlEquals("<r><p>a</p><p>b</p><p>c</p></r>", d1, d2)
-        }
-    }
-
     @Test
     fun test_insert_side_by_side_elements_into_right_concurrently() {
         withTwoClientsAndDocuments(realTimeSync = false) { c1, c2, d1, d2, _ ->
@@ -590,139 +527,6 @@ class JsonTreeTest {
         }
     }
 
-    @Test
-    fun test_contained_split_and_insert_into_the_split_position() {
-        withTwoClientsAndDocuments(realTimeSync = false) { c1, c2, d1, d2, _ ->
-            updateAndSync(
-                Updater(c1, d1) { root, _ ->
-                    root.setNewTree(
-                        "t",
-                        element("r") {
-                            element("p") {
-                                text { "ab" }
-                            }
-                        },
-                    )
-                },
-                Updater(c2, d2),
-            )
-            assertTreesXmlEquals("<r><p>ab</p></r>", d1, d2)
-
-            updateAndSync(
-                Updater(c1, d1) { root, _ ->
-                    root.rootTree().edit(2, 2, splitLevel = 1)
-                },
-                Updater(c2, d2) { root, _ ->
-                    root.rootTree().edit(2, 2, text { "c" })
-                },
-            ) {
-                assertTreesXmlEquals("<r><p>a</p><p>b</p></r>", d1)
-                assertTreesXmlEquals("<r><p>acb</p></r>", d2)
-            }
-            assertTreesXmlEquals("<r><p>ac</p><p>b</p></r>", d1, d2)
-        }
-    }
-
-    @Test
-    fun test_contained_split_and_insert_into_original_node() {
-        withTwoClientsAndDocuments(realTimeSync = false) { c1, c2, d1, d2, _ ->
-            updateAndSync(
-                Updater(c1, d1) { root, _ ->
-                    root.setNewTree(
-                        "t",
-                        element("r") {
-                            element("p") {
-                                text { "ab" }
-                            }
-                        },
-                    )
-                },
-                Updater(c2, d2),
-            )
-            assertTreesXmlEquals("<r><p>ab</p></r>", d1, d2)
-
-            updateAndSync(
-                Updater(c1, d1) { root, _ ->
-                    root.rootTree().edit(2, 2, splitLevel = 1)
-                },
-                Updater(c2, d2) { root, _ ->
-                    root.rootTree().edit(1, 1, text { "c" })
-                },
-            ) {
-                assertTreesXmlEquals("<r><p>a</p><p>b</p></r>", d1)
-                assertTreesXmlEquals("<r><p>cab</p></r>", d2)
-            }
-            assertTreesXmlEquals("<r><p>ca</p><p>b</p></r>", d1, d2)
-        }
-    }
-
-    @Test
-    fun test_contained_split_and_insert_into_split_node() {
-        withTwoClientsAndDocuments(realTimeSync = false) { c1, c2, d1, d2, _ ->
-            updateAndSync(
-                Updater(c1, d1) { root, _ ->
-                    root.setNewTree(
-                        "t",
-                        element("r") {
-                            element("p") {
-                                text { "ab" }
-                            }
-                        },
-                    )
-                },
-                Updater(c2, d2),
-            )
-            assertTreesXmlEquals("<r><p>ab</p></r>", d1, d2)
-
-            updateAndSync(
-                Updater(c1, d1) { root, _ ->
-                    root.rootTree().edit(2, 2, splitLevel = 1)
-                },
-                Updater(c2, d2) { root, _ ->
-                    root.rootTree().edit(3, 3, text { "c" })
-                },
-            ) {
-                assertTreesXmlEquals("<r><p>a</p><p>b</p></r>", d1)
-                assertTreesXmlEquals("<r><p>abc</p></r>", d2)
-            }
-            assertTreesXmlEquals("<r><p>a</p><p>bc</p></r>", d2)
-        }
-    }
-
-    @Test
-    fun test_contained_split_and_delete_contents_in_split_node() {
-        withTwoClientsAndDocuments(realTimeSync = false) { c1, c2, d1, d2, _ ->
-            updateAndSync(
-                Updater(c1, d1) { root, _ ->
-                    root.setNewTree(
-                        "t",
-                        element("r") {
-                            element("p") {
-                                text { "ab" }
-                            }
-                        },
-                    )
-                },
-                Updater(c2, d2),
-            )
-            assertTreesXmlEquals("<r><p>ab</p></r>", d1, d2)
-
-            updateAndSync(
-                Updater(c1, d1) { root, _ ->
-                    root.rootTree().edit(2, 2, splitLevel = 1)
-                },
-                Updater(c2, d2) { root, _ ->
-                    root.rootTree().edit(2, 3)
-                },
-            ) {
-                assertTreesXmlEquals("<r><p>a</p><p>b</p></r>", d1)
-                assertTreesXmlEquals("<r><p>a</p></r>", d2)
-            }
-
-            assertTreesXmlEquals("<r><p>a</p><p></p></r>", d1, d2)
-        }
-    }
-
     @Test
     fun test_deleting_side_by_side_elements_concurrently() {
         withTwoClientsAndDocuments(realTimeSync = false) { c1, c2, d1, d2, _ ->
@@ -1512,114 +1316,6 @@ class JsonTreeTest {
         }
     }
 
-    @Test
-    fun test_split_and_merge_with_empty_paragraph_left() {
-        withTwoClientsAndDocuments(realTimeSync = false) { c1, c2, d1, d2, _ ->
-            d1.updateAsync { root, _ ->
-                root.setNewTree(
-                    "t",
-                    element("doc") {
-                        element("p") {
-                            text { "a" }
-                            text { "b" }
-                        }
-                    },
-                )
-            }.await()
-            assertTreesXmlEquals("<doc><p>ab</p></doc>", d1)
-
-            d1.updateAsync { root, _ ->
-                root.rootTree().edit(1, 1, splitLevel = 1)
-            }.await()
-            assertTreesXmlEquals("<doc><p></p><p>ab</p></doc>", d1)
-
-            updateAndSync(
-                Updater(c1, d1) { root, _ ->
-                    root.rootTree().edit(1, 3)
-                },
-                Updater(c2, d2),
-            )
-            assertTreesXmlEquals("<doc><p>ab</p></doc>", d1, d2)
-        }
-    }
-
-    @Test
-    fun test_split_and_merge_with_empty_paragraph_left_and_multiple_split_level_left() {
-        withTwoClientsAndDocuments(realTimeSync = false) { c1, c2, d1, d2, _ ->
-            d1.updateAsync { root, _ ->
-                root.setNewTree(
-                    "t",
-                    element("doc") {
-                        element("p") {
-                            element("p") {
-                                text { "a" }
-                                text { "b" }
-                            }
-                        }
-                    },
-                )
-            }.await()
-            assertEquals("<doc><p><p>ab</p></p></doc>", d1.getRoot().rootTree().toXml())
-
-            d1.updateAsync { root, _ ->
-                root.rootTree().edit(2, 2, splitLevel = 2)
-            }.await()
-            assertEquals(
-                "<doc><p><p></p></p><p><p>ab</p></p></doc>",
-                d1.getRoot().rootTree().toXml(),
-            )
-
-            updateAndSync(
-                Updater(c1, d1) { root, _ ->
-                    root.rootTree().edit(2, 6)
-                },
-                Updater(c2, d2),
-            )
-            assertTreesXmlEquals("<doc><p><p>ab</p></p></doc>", d1, d2)
-        }
-    }
-
-    @Test
-    fun test_split_same_offset_multiple_times() {
-        withTwoClientsAndDocuments(realTimeSync = false) { c1, c2, d1, d2, _ ->
-            d1.updateAsync { root, _ ->
-                root.setNewTree(
-                    "t",
-                    element("doc") {
-                        element("p") {
-                            text { "a" }
-                            text { "b" }
-                        }
-                    },
-                )
-            }.await()
-            assertEquals("<doc><p>ab</p></doc>", d1.getRoot().rootTree().toXml())
-
-            d1.updateAsync { root, _ ->
-                root.rootTree().edit(2, 2, splitLevel = 1)
-            }.await()
-            assertEquals("<doc><p>a</p><p>b</p></doc>", d1.getRoot().rootTree().toXml())
-
-            d1.updateAsync { root, _ ->
-                root.rootTree().edit(2, 2, text { "c" })
-            }.await()
-            assertEquals("<doc><p>ac</p><p>b</p></doc>", d1.getRoot().rootTree().toXml())
-
-            d1.updateAsync { root, _ ->
-                root.rootTree().edit(2, 2, splitLevel = 1)
-            }.await()
-            assertEquals("<doc><p>a</p><p>c</p><p>b</p></doc>", d1.getRoot().rootTree().toXml())
-
-            updateAndSync(
-                Updater(c1, d1) { root, _ ->
-                    root.rootTree().edit(2, 7)
-                },
-                Updater(c2, d2),
-            )
-            assertTreesXmlEquals("<doc><p>ab</p></doc>", d1, d2)
-        }
-    }
-
     @Test
     fun test_tree_change_concurrent_delete() {
         withTwoClientsAndDocuments(realTimeSync = false) { c1, c2, d1, d2, _ ->
diff --git a/yorkie/src/main/kotlin/dev/yorkie/document/operation/OperationInfo.kt b/yorkie/src/main/kotlin/dev/yorkie/document/operation/OperationInfo.kt
index da299301d..30a821c9e 100644
--- a/yorkie/src/main/kotlin/dev/yorkie/document/operation/OperationInfo.kt
+++ b/yorkie/src/main/kotlin/dev/yorkie/document/operation/OperationInfo.kt
@@ -92,7 +92,6 @@ public sealed class OperationInfo {
         val from: Int,
         val to: Int,
         val fromPath: List<Int>,
-        val toPath: List<Int>,
         val attributes: Map<String, String>,
         override var path: String = INITIAL_PATH,
     ) : OperationInfo(), TreeOperationInfo
diff --git a/yorkie/src/main/kotlin/dev/yorkie/document/operation/TreeStyleOperation.kt b/yorkie/src/main/kotlin/dev/yorkie/document/operation/TreeStyleOperation.kt
index 76eed880c..d926717d7 100644
--- a/yorkie/src/main/kotlin/dev/yorkie/document/operation/TreeStyleOperation.kt
+++ b/yorkie/src/main/kotlin/dev/yorkie/document/operation/TreeStyleOperation.kt
@@ -36,7 +36,6 @@ internal data class TreeStyleOperation(
                 it.from,
                 it.to,
                 it.fromPath,
-                it.toPath,
                 it.attributes.orEmpty(),
                 root.createPath(parentCreatedAt),
             )
diff --git a/yorkie/src/test/kotlin/dev/yorkie/document/json/JsonTreeTest.kt b/yorkie/src/test/kotlin/dev/yorkie/document/json/JsonTreeTest.kt
index f7e826358..254f6d93a 100644
--- a/yorkie/src/test/kotlin/dev/yorkie/document/json/JsonTreeTest.kt
+++ b/yorkie/src/test/kotlin/dev/yorkie/document/json/JsonTreeTest.kt
@@ -319,12 +319,10 @@ class JsonTreeTest {
                     0,
                     "$.t",
                 ),
-                // TODO(7hong13): need to check whether toPath is correctly passed
                 TreeStyleOpInfo(
                     0,
                     1,
                     listOf(0),
-                    listOf(0, 0),
                     mapOf("a" to "b"),
                     "$.t",
                 ),
@@ -387,12 +385,10 @@ class JsonTreeTest {
                     0,
                     "$.t",
                 ),
-                // TODO(7hong13): need to check whether toPath is correctly passed
                 TreeStyleOpInfo(
                     2,
                     3,
                     listOf(0, 0, 0),
-                    listOf(0, 0, 0, 0),
                     mapOf("a" to "b"),
                     "$.t",
                 ),