diff --git a/frontend/src/ofrak/remote_resource.js b/frontend/src/ofrak/remote_resource.js
index 77cad8187..059d32ba7 100644
--- a/frontend/src/ofrak/remote_resource.js
+++ b/frontend/src/ofrak/remote_resource.js
@@ -468,13 +468,13 @@ export class RemoteResource extends Resource {
     return find_replace_results;
   }
 
-  async add_comment(optional_range, comment) {
+  async add_comment(optional_range, comment_text) {
     await fetch(`${this.uri}/add_comment`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
       },
-      body: JSON.stringify([optional_range, comment]),
+      body: JSON.stringify([optional_range, comment_text]),
     }).then(async (r) => {
       if (!r.ok) {
         throw Error(JSON.stringify(await r.json(), undefined, 2));
@@ -508,13 +508,13 @@ export class RemoteResource extends Resource {
     await this.update_script();
   }
 
-  async delete_comment(optional_range) {
+  async delete_comment(optional_range, comment_text) {
     await fetch(`${this.uri}/delete_comment`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
       },
-      body: JSON.stringify(optional_range),
+      body: JSON.stringify([optional_range, comment_text]),
     }).then(async (r) => {
       if (!r.ok) {
         throw Error(JSON.stringify(await r.json(), undefined, 2));
diff --git a/frontend/src/ofrak/resource.js b/frontend/src/ofrak/resource.js
index c9241de6e..f442ae2f1 100644
--- a/frontend/src/ofrak/resource.js
+++ b/frontend/src/ofrak/resource.js
@@ -365,11 +365,11 @@ export class Resource {
     throw new NotImplementedError("summarize_tree");
   }
 
-  async add_comment(optional_range, comment) {
+  async add_comment(optional_range, comment_text) {
     throw new NotImplementedError("add_comment");
   }
 
-  async delete_comment(optional_range) {
+  async delete_comment(optional_range, comment_text) {
     throw new NotImplementedError("delete_comment");
   }
 
diff --git a/frontend/src/resource/ResourceTreeNode.svelte b/frontend/src/resource/ResourceTreeNode.svelte
index 30df8cfcb..5325e62c8 100644
--- a/frontend/src/resource/ResourceTreeNode.svelte
+++ b/frontend/src/resource/ResourceTreeNode.svelte
@@ -244,15 +244,17 @@
   >
     {rootResource.get_caption()}
   </button>
-  {#await commentsPromise then comments}
-    {#each comments as comment}
-      <div class="comment">
-        <Comment
-          comment="{comment}"
-          rootResource="{rootResource}"
-          selfId="{selfId}"
-        />
-      </div>
+  {#await commentsPromise then comment_group}
+    {#each comment_group as [comment_range, comment_strs]}
+      {#each comment_strs as comment_text}
+        <div class="comment">
+          <Comment
+            comment="{{ comment_range, comment_text }}"
+            rootResource="{rootResource}"
+            selfId="{selfId}"
+          />
+        </div>
+      {/each}
     {/each}
   {/await}
 
diff --git a/frontend/src/views/Comment.svelte b/frontend/src/views/Comment.svelte
index d7e6b0459..dbabf6d78 100644
--- a/frontend/src/views/Comment.svelte
+++ b/frontend/src/views/Comment.svelte
@@ -20,17 +20,18 @@
   import Hoverable from "../utils/Hoverable.svelte";
   import Icon from "../utils/Icon.svelte";
   export let comment, rootResource, selfId;
-  let text = comment[1];
-  let addresses = text.matchAll("#[a-fA-F0-9]+[@0x[0-9a-fA-F]+]*", text);
+  let addresses = comment.comment_text.matchAll(
+    "#[a-fA-F0-9]+(@0x[0-9a-fA-F]+)?"
+  );
   let text_elements = [];
   Array.from(addresses).forEach((location) => {
-    let text_split = text.split(location[0]);
+    let text_split = comment.comment_text.split(location[0]);
     text_elements.push(text_split[0]);
     text_elements.push(createAddressButton(location[0]));
-    text = text_split.slice(1).join(location[0]);
+    comment.comment_text = text_split.slice(1).join(location[0]);
   });
 
-  text_elements.push(text);
+  text_elements.push(comment.comment_text);
 
   function createAddressButton(location) {
     let resource_id;
@@ -53,11 +54,14 @@
     return button;
   }
 
-  async function onDeleteClick(optional_range) {
+  async function onDeleteClick(comment) {
     // Delete the selected comment.
     // As a side effect, the corresponding resource gets selected.
     $selected = selfId;
-    await rootResource.delete_comment(optional_range);
+    await rootResource.delete_comment(
+      comment.comment_range,
+      comment.comment_text
+    );
     $resourceNodeDataMap[$selected].commentsPromise =
       rootResource.get_comments();
   }
@@ -65,7 +69,7 @@
 
 <div class="comment">
   <Hoverable let:hovering>
-    <button title="Delete this comment" on:click="{onDeleteClick(comment[0])}">
+    <button title="Delete this comment" on:click="{onDeleteClick(comment)}">
       <Icon
         class="comment_icon"
         url="{hovering ? '/icons/trash_can.svg' : '/icons/comment.svg'}"
diff --git a/ofrak_core/ofrak/core/comments.py b/ofrak_core/ofrak/core/comments.py
index 646a7da97..1d9139571 100644
--- a/ofrak_core/ofrak/core/comments.py
+++ b/ofrak_core/ofrak/core/comments.py
@@ -1,6 +1,6 @@
 from copy import deepcopy
 from dataclasses import dataclass
-from typing import Dict, Tuple, Optional
+from typing import Dict, List, Tuple, Optional
 from ofrak.component.modifier import Modifier
 from ofrak.model.component_model import ComponentConfig
 from ofrak.model.resource_model import ResourceAttributes
@@ -12,10 +12,10 @@
 @dataclass(**ResourceAttributes.DATACLASS_PARAMS)
 class CommentsAttributes(ResourceAttributes):
     """
-    User-defined comments, each comment associated with an optional range.
+    User-defined comments, list of the comments associated with an optional range.
     """
 
-    comments: Dict[Optional[Range], str]
+    comments: Dict[Optional[Range], List[str]]
 
 
 @dataclass
@@ -39,7 +39,6 @@ async def modify(self, resource: Resource, config: AddCommentModifierConfig) ->
                     f"Range {config_range} is outside the bounds of "
                     f"resource {resource.get_id().hex()}"
                 )
-
         try:
             # deepcopy the existing comments, otherwise they would be modified in place
             # and OFRAK would then compare the new attributes with the existing ones and find
@@ -48,32 +47,34 @@ async def modify(self, resource: Resource, config: AddCommentModifierConfig) ->
         except NotFoundError:
             comments = {}
 
-        # Here I'm appending appending overlapping comments with a new line.
-        # Overwriting comments that share a range is counter intuitive and not easily understood without digging into the code.
-        # TODO: Refactor comments strucutre to not key off of the range to allow individual overlapping comment attributes.
-        if config.comment[0] in comments:
-            comment = config.comment[1] + "\n" + comments[config.comment[0]]
-        else:
-            comment = config.comment[1]
-        comments[config.comment[0]] = comment
+        if config.comment[0] not in comments:
+            comments[config.comment[0]] = []
+
+        comments[config.comment[0]].append(config.comment[1])
         resource.add_attributes(CommentsAttributes(comments=comments))
 
 
 @dataclass
 class DeleteCommentModifierConfig(ComponentConfig):
+    """
+    If comment_text is provided, deletes the matching comment in that comment_range
+    If comment_text is None, deletes ALL comments in that comment_range
+    """
+
     comment_range: Optional[Range]
+    comment_text: Optional[str] = None
 
 
 class DeleteCommentModifier(Modifier[DeleteCommentModifierConfig]):
     """
-    Modifier to delete a comment from a resource.
+    Modifier to delete comment(s) from a resource.
     """
 
     targets = ()
 
     async def modify(self, resource: Resource, config: DeleteCommentModifierConfig) -> None:
         """
-        Delete the comment associated with the given range.
+        Delete the comment(s) associated with the given range.
 
         :raises NotFoundError: if the comment range is not associated with a comment.
         """
@@ -82,10 +83,22 @@ async def modify(self, resource: Resource, config: DeleteCommentModifierConfig)
         except NotFoundError:
             comments = {}
         try:
-            del comments[config.comment_range]
+            if config.comment_text is None:
+                # Delete ALL comments in this range
+                del comments[config.comment_range]
+            else:
+                comments[config.comment_range].remove(config.comment_text)
+                # Clean up if this was the last comment in this range
+                if len(comments[config.comment_range]) == 0:
+                    del comments[config.comment_range]
         except KeyError:
             raise NotFoundError(
                 f"Comment range {config.comment_range} not found in "
                 f"resource {resource.get_id().hex()}"
             )
+        except ValueError:
+            raise NotFoundError(
+                f"Comment {config.comment_text} with range {config.comment_range}"
+                f" not found in resource {resource.get_id().hex()}"
+            )
         resource.add_attributes(CommentsAttributes(comments=comments))
diff --git a/ofrak_core/ofrak/gui/server.py b/ofrak_core/ofrak/gui/server.py
index 125e5bfe3..5b73d951f 100644
--- a/ofrak_core/ofrak/gui/server.py
+++ b/ofrak_core/ofrak/gui/server.py
@@ -735,18 +735,30 @@ async def add_comment(self, request: Request) -> Response:
     @exceptions_to_http(SerializedError)
     async def delete_comment(self, request: Request) -> Response:
         resource = await self._get_resource_for_request(request)
-        comment_range = self._serializer.from_pjson(await request.json(), Optional[Range])
+        comment_data = self._serializer.from_pjson(
+            await request.json(), Union[Tuple[Optional[Range], Optional[str]], Optional[Range]]
+        )
+        comment_range: Optional[Range] = None
+        comment_text: Optional[str] = None
+
+        if type(comment_data) == tuple:
+            comment_range = comment_data[0]
+            comment_text = comment_data[1]
+        else:
+            comment_range = comment_data
+
         script_str = (
             """
         await {resource}.run"""
             f"""(
-            DeleteCommentModifier, DeleteCommentModifierConfig({comment_range})
+            DeleteCommentModifier, DeleteCommentModifierConfig(comment_range={comment_range}, comment_text="{comment_text}")
         )"""
         )
         await self.script_builder.add_action(resource, script_str, ActionType.MOD)
         try:
             result = await resource.run(
-                DeleteCommentModifier, DeleteCommentModifierConfig(comment_range)
+                DeleteCommentModifier,
+                DeleteCommentModifierConfig(comment_range=comment_range, comment_text=comment_text),
             )
             await self.script_builder.commit_to_script(resource)
         except Exception as e:
diff --git a/ofrak_core/test_ofrak/components/test_comments.py b/ofrak_core/test_ofrak/components/test_comments.py
index c03d4897d..2b5956669 100644
--- a/ofrak_core/test_ofrak/components/test_comments.py
+++ b/ofrak_core/test_ofrak/components/test_comments.py
@@ -22,6 +22,10 @@ async def executable_resource(ofrak_context, elf_executable_file) -> Resource:
     return root_resource
 
 
+def get_comment_count(comment_attributes: CommentsAttributes) -> int:
+    return sum(len(comment_list) for comment_list in comment_attributes.comments.values())
+
+
 async def test_adding_comments(executable_resource: Resource):
     """Test adding comments, including to the entire resource (range=None)."""
     await executable_resource.run(
@@ -32,8 +36,39 @@ async def test_adding_comments(executable_resource: Resource):
         AddCommentModifier,
         AddCommentModifierConfig(comment=(None, "comment")),
     )
-    comments = executable_resource.get_attributes(CommentsAttributes).comments
-    assert len(comments) == 2
+    comment_attributes = executable_resource.get_attributes(CommentsAttributes)
+    assert get_comment_count(comment_attributes) == 2
+
+
+async def test_adding_comments_same_range(executable_resource: Resource):
+    """Test adding multiple comments to the same range, including duplicated messages"""
+    await executable_resource.run(
+        AddCommentModifier,
+        AddCommentModifierConfig(comment=(Range(0, 1), "range 1 first comment")),
+    )
+    await executable_resource.run(
+        AddCommentModifier,
+        AddCommentModifierConfig(comment=(Range(0, 1), "range 1 second comment")),
+    )
+    await executable_resource.run(
+        AddCommentModifier,
+        AddCommentModifierConfig(comment=(None, "full range first comment")),
+    )
+    await executable_resource.run(
+        AddCommentModifier,
+        AddCommentModifierConfig(comment=(None, "full range second comment")),
+    )
+    # Test duplicate comments (same range, same message)
+    await executable_resource.run(
+        AddCommentModifier,
+        AddCommentModifierConfig(comment=(Range(0, 1), "range 1 second comment")),
+    )
+    await executable_resource.run(
+        AddCommentModifier,
+        AddCommentModifierConfig(comment=(None, "full range second comment")),
+    )
+    comment_attributes = executable_resource.get_attributes(CommentsAttributes)
+    assert get_comment_count(comment_attributes) == 6
 
 
 # We suppress the function_scoped_fixture health check because the executable_resource fixture
@@ -51,26 +86,13 @@ async def test_comment_content(executable_resource: Resource, comment_str: str):
         AddCommentModifierConfig(comment=(None, comment_str)),
     )
     comments = executable_resource.get_attributes(CommentsAttributes).comments
-    assert comments[None] == comment_str
+    assert comments[None] == [comment_str]
     await executable_resource.run(
         DeleteCommentModifier,
-        DeleteCommentModifierConfig(comment_range=None),
+        DeleteCommentModifierConfig(comment_range=(None)),
     )
-
-
-async def test_overriding_comment(executable_resource: Resource):
-    """Test that adding a comment to a range with an existing comment overrides the existing comment."""
-    await executable_resource.run(
-        AddCommentModifier,
-        AddCommentModifierConfig(comment=(Range(0, 1), "comment")),
-    )
-    await executable_resource.run(
-        AddCommentModifier,
-        AddCommentModifierConfig(comment=(Range(0, 1), "overriding_comment")),
-    )
-    comments = executable_resource.get_attributes(CommentsAttributes).comments
-    assert len(comments) == 1
-    assert comments[Range(0, 1)] == "overriding_comment" + "\n" + "comment"
+    comment_attributes = executable_resource.get_attributes(CommentsAttributes)
+    assert get_comment_count(comment_attributes) == 0
 
 
 async def test_range_validation(executable_resource: Resource):
@@ -97,8 +119,8 @@ async def test_comments_survive_unpacking(executable_resource: Resource, recursi
     else:
         component_run_result = await executable_resource.unpack()
     assert len(component_run_result.resources_created) > 0
-    comments = executable_resource.get_attributes(CommentsAttributes).comments
-    assert len(comments) == 1
+    comment_attributes = executable_resource.get_attributes(CommentsAttributes)
+    assert get_comment_count(comment_attributes) == 1
 
 
 @pytest.mark.parametrize("recursively", [True, False])
@@ -115,8 +137,8 @@ async def test_comments_survive_repacking(executable_resource: Resource, recursi
     else:
         await executable_resource.unpack()
         await executable_resource.pack()
-    comments = executable_resource.get_attributes(CommentsAttributes).comments
-    assert len(comments) == 1
+    comment_attributes = executable_resource.get_attributes(CommentsAttributes)
+    assert get_comment_count(comment_attributes) == 1
 
 
 async def test_comments_survive_analyzing(executable_resource: Resource):
@@ -127,40 +149,123 @@ async def test_comments_survive_analyzing(executable_resource: Resource):
     )
     # Analyze the resource
     await executable_resource.analyze(Magic)
-    comments = executable_resource.get_attributes(CommentsAttributes).comments
-    assert len(comments) == 1
+    comment_attributes = executable_resource.get_attributes(CommentsAttributes)
+    assert get_comment_count(comment_attributes) == 1
 
 
 async def test_deleting_comments(executable_resource: Resource):
     """Test deleting comments."""
     await executable_resource.run(
         AddCommentModifier,
-        AddCommentModifierConfig(comment=(Range(0, 1), "comment")),
+        AddCommentModifierConfig(comment=(Range(0, 1), "first range comment 1")),
     )
     await executable_resource.run(
         AddCommentModifier,
-        AddCommentModifierConfig(comment=(None, "comment")),
+        AddCommentModifierConfig(comment=(Range(0, 1), "first range comment 2")),
+    )
+    await executable_resource.run(
+        AddCommentModifier,
+        AddCommentModifierConfig(comment=(Range(0, 2), "second range comment 1")),
     )
-    comments = executable_resource.get_attributes(CommentsAttributes).comments
-    assert len(comments) == 2
+    await executable_resource.run(
+        AddCommentModifier,
+        AddCommentModifierConfig(comment=(Range(0, 2), "second range comment 2")),
+    )
+    await executable_resource.run(
+        AddCommentModifier,
+        AddCommentModifierConfig(comment=(Range(1, 2), "third range comment 1")),
+    )
+    await executable_resource.run(
+        AddCommentModifier,
+        AddCommentModifierConfig(comment=(Range(1, 2), "third range comment 2")),
+    )
+    await executable_resource.run(
+        AddCommentModifier,
+        AddCommentModifierConfig(comment=(None, "full range comment 1")),
+    )
+    await executable_resource.run(
+        AddCommentModifier,
+        AddCommentModifierConfig(comment=(None, "full range comment 2")),
+    )
+    await executable_resource.run(
+        AddCommentModifier,
+        AddCommentModifierConfig(comment=(None, "full range comment 3")),
+    )
+    comment_attributes = executable_resource.get_attributes(CommentsAttributes)
+    assert get_comment_count(comment_attributes) == 9
+    # Test deletion of specific comments
     await executable_resource.run(
         DeleteCommentModifier,
-        DeleteCommentModifierConfig(comment_range=Range(0, 1)),
+        DeleteCommentModifierConfig(
+            comment_range=Range(0, 1), comment_text="first range comment 1"
+        ),
     )
-    comments = executable_resource.get_attributes(CommentsAttributes).comments
-    assert len(comments) == 1
+    comment_attributes = executable_resource.get_attributes(CommentsAttributes)
+    comments = comment_attributes.comments
+    assert get_comment_count(comment_attributes) == 8
+    assert len(comments[Range(0, 1)]) == 1
+    assert comments[Range(0, 1)][0] == "first range comment 2"
+    # Test specific deletion of last comment in a range
+    await executable_resource.run(
+        DeleteCommentModifier,
+        DeleteCommentModifierConfig(
+            comment_range=Range(0, 1), comment_text="first range comment 2"
+        ),
+    )
+    comment_attributes = executable_resource.get_attributes(CommentsAttributes)
+    comments = comment_attributes.comments
+    assert get_comment_count(comment_attributes) == 7
+    with pytest.raises(KeyError):
+        # This key shouldn't exist anymore
+        assert len(comments[Range(0, 1)]) == 0
+    # Test deletion of entire ranges with new DeleteCommentModifierConfig format
+    await executable_resource.run(
+        DeleteCommentModifier,
+        DeleteCommentModifierConfig(comment_range=Range(1, 2), comment_text=None),
+    )
+    comment_attributes = executable_resource.get_attributes(CommentsAttributes)
+    assert get_comment_count(comment_attributes) == 5
+    # Test deletion of entire ranges, with old DeleteCommentModifierConfig format
     await executable_resource.run(
         DeleteCommentModifier,
         DeleteCommentModifierConfig(comment_range=None),
     )
-    comments = executable_resource.get_attributes(CommentsAttributes).comments
-    assert len(comments) == 0
+    comment_attributes = executable_resource.get_attributes(CommentsAttributes)
+    assert get_comment_count(comment_attributes) == 2
+    await executable_resource.run(
+        DeleteCommentModifier,
+        DeleteCommentModifierConfig(comment_range=Range(0, 2)),
+    )
+    comment_attributes = executable_resource.get_attributes(CommentsAttributes)
+    assert get_comment_count(comment_attributes) == 0
+    # Ensure none of the keys exist anymore
+    assert len(comment_attributes.comments.keys()) == 0
 
 
 async def test_deleting_non_existing_comment(executable_resource: Resource):
-    """Test deleting a non-existing comment."""
+    """Test deleting non-existing comments."""
     with pytest.raises(NotFoundError):
         await executable_resource.run(
             DeleteCommentModifier,
-            DeleteCommentModifierConfig(comment_range=Range(0, 1)),
+            DeleteCommentModifierConfig(comment_range=(Range(0, 1))),
         )
+
+    # Now test deleting a comment when no comments with that text exist
+    await executable_resource.run(
+        AddCommentModifier,
+        AddCommentModifierConfig(comment=(None, "this exists")),
+    )
+
+    with pytest.raises(NotFoundError):
+        await executable_resource.run(
+            DeleteCommentModifier,
+            DeleteCommentModifierConfig(comment_range=None, comment_text="this doesn't exist"),
+        )
+
+    await executable_resource.run(
+        DeleteCommentModifier,
+        DeleteCommentModifierConfig(comment_range=None, comment_text="this exists"),
+    )
+
+    comment_attributes = executable_resource.get_attributes(CommentsAttributes)
+    assert get_comment_count(comment_attributes) == 0
diff --git a/ofrak_core/test_ofrak/unit/test_ofrak_server.py b/ofrak_core/test_ofrak/unit/test_ofrak_server.py
index 3c4f46bc2..8281cac65 100644
--- a/ofrak_core/test_ofrak/unit/test_ofrak_server.py
+++ b/ofrak_core/test_ofrak/unit/test_ofrak_server.py
@@ -9,7 +9,7 @@
 import sys
 
 from multiprocessing import Process
-from typing import List
+from typing import List, Tuple
 
 from aiohttp.test_utils import TestClient
 
@@ -454,29 +454,110 @@ async def test_find_and_replace(ofrak_client: TestClient, hello_world_elf):
     assert resp.status == 200
 
 
+# Returns (comment range count, comment count)
+# comment range count = # of unique Optional[Range]s comments are mapped to
+# comment count = total # of comments across all Optional[Range]s
+def get_comment_count(resp_body_json) -> Tuple[int, int]:
+    attributes = resp_body_json["modified"][0]["attributes"]
+    comment_range_count = 0
+    comment_count = 0
+
+    for attr_array in attributes:
+        if attr_array[0] == "ofrak.core.comments.CommentsAttributes":
+            comment_data = attr_array[1][1]["comments"]
+            for kv_pair in comment_data:
+                comment_range_count += 1
+                comment_count += len(kv_pair[1])
+
+    return (comment_range_count, comment_count)
+
+
 async def test_add_comment(ofrak_server, aiohttp_client, hello_world_elf):
     client = await aiohttp_client(ofrak_server._app)
     create_resp = await client.post(
         "/create_root_resource", params={"name": "test"}, data=hello_world_elf
     )
     create_body = await create_resp.json()
-    resp = await client.post(f"/{create_body['id']}/add_comment", json=[[0, 425], "test"])
+    # Try creating comments on invalid ranges
+    resp = await client.post(
+        f"/{create_body['id']}/add_comment",
+        json=[[0, len(hello_world_elf) + 1], "test comment out of bounds"],
+    )
+    assert resp.status != 200
+    resp = await client.post(
+        f"/{create_body['id']}/add_comment",
+        json=[[-1, len(hello_world_elf)], "test comment out of bounds"],
+    )
+    assert resp.status != 200
+    # Create comment without range
+    resp = await client.post(f"/{create_body['id']}/add_comment", json=[None, "test comment 0"])
+    assert resp.status == 200
+    resp_body = await resp.json()
+    assert resp_body["modified"][0]["id"] == create_body["id"]
+    # Create comment with range
+    resp = await client.post(f"/{create_body['id']}/add_comment", json=[[0, 1], "test comment 1"])
+    assert resp.status == 200
+    resp_body = await resp.json()
+    assert resp_body["modified"][0]["id"] == create_body["id"]
+    # Create multiple comments on the same range
+    resp = await client.post(
+        f"/{create_body['id']}/add_comment", json=[[0, len(hello_world_elf)], "test comment 2"]
+    )
     assert resp.status == 200
     resp_body = await resp.json()
     assert resp_body["modified"][0]["id"] == create_body["id"]
+    resp = await client.post(
+        f"/{create_body['id']}/add_comment", json=[[0, len(hello_world_elf)], "test comment 3"]
+    )
+    assert resp.status == 200
+    resp_body = await resp.json()
+    assert resp_body["modified"][0]["id"] == create_body["id"]
+    # Check comment counts
+    comment_range_count, comment_count = get_comment_count(resp_body)
+    assert comment_range_count == 3
+    assert comment_count == 4
 
 
+# Test deleting comments using both the old and new format
 async def test_delete_comment(ofrak_server, aiohttp_client, hello_world_elf):
     client = await aiohttp_client(ofrak_server._app)
     create_resp = await client.post(
         "/create_root_resource", params={"name": "test"}, data=hello_world_elf
     )
     create_body = await create_resp.json()
-    await client.post(f"/{create_body['id']}/add_comment", json=[[0, 425], "test"])
-    resp = await client.post(f"/{create_body['id']}/delete_comment", json=[0, 425])
-    assert resp.status == 200
+    # Comments to delete
+    await client.post(f"/{create_body['id']}/add_comment", json=[None, "test comment 0"])
+    await client.post(f"/{create_body['id']}/add_comment", json=[None, "test comment 1"])
+    await client.post(
+        f"/{create_body['id']}/add_comment", json=[[0, len(hello_world_elf)], "test comment 0"]
+    )
+    resp = await client.post(
+        f"/{create_body['id']}/add_comment", json=[[0, len(hello_world_elf)], "test comment 1"]
+    )
+    resp_body = await resp.json()
+    assert resp_body["modified"][0]["id"] == create_body["id"]
+    comment_range_count, comment_count = get_comment_count(resp_body)
+    assert comment_range_count == 2
+    assert comment_count == 4
+    # Test deleting specific comments from range
+    resp = await client.post(f"/{create_body['id']}/delete_comment", json=[None, "test comment 1"])
+    resp_body = await resp.json()
+    assert resp_body["modified"][0]["id"] == create_body["id"]
+    comment_range_count, comment_count = get_comment_count(resp_body)
+    assert comment_range_count == 2
+    assert comment_count == 3
+    # Test deleting last comment from range
+    resp = await client.post(f"/{create_body['id']}/delete_comment", json=[None, "test comment 0"])
+    resp_body = await resp.json()
+    assert resp_body["modified"][0]["id"] == create_body["id"]
+    comment_range_count, comment_count = get_comment_count(resp_body)
+    assert comment_range_count == 1
+    assert comment_count == 2
+    # Test deleting entire range
+    resp = await client.post(f"/{create_body['id']}/delete_comment", json=[0, len(hello_world_elf)])
     resp_body = await resp.json()
     assert resp_body["modified"][0]["id"] == create_body["id"]
+    assert (0, 0) == get_comment_count(resp_body)  # All comments should be gone
 
 
 async def test_search_for_vaddr(ofrak_client: TestClient, hello_world_elf):