diff --git a/__tests__/benchmark.test.js b/__tests__/benchmark.test.js
index abf954b78ff4f5385ed0f2d208256cc8e2711d7a..dedc0fa4c7692f81affce139ce01272c56ce6495 100644
--- a/__tests__/benchmark.test.js
+++ b/__tests__/benchmark.test.js
@@ -326,25 +326,32 @@ describe("drawing app mesh", () => {
     const dotIDs = []
     let prevTime
 
-    let addTime
-    let addPackets = 0
+    let addLocTime
+    const addPackets = []
     let addSize = 0
-    let eraseTime
-    let erasePackets = 0
+    let eraseLocTime
+    const erasePackets = []
     let eraseSize = 0
-    let syncTime
-    let syncPackets = 0
+    let syncLocTime
+    const syncPackets = []
     let syncSize = 0
 
+    let addRemTime = 0
+    let addEvents = 0
+    let eraseRemTime = 0
+    let eraseEvents = 0
+    let syncRemTime = 0
+    let syncEvents = 0
+
     let timeout
 
     return new Promise((resolve) => {
       broadcastListener.callback = (channel, message) => {
         const currTime = process.hrtime()
 
-        addTime =
+        addLocTime =
           (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-        addPackets += 1
+        addPackets.push(message)
         addSize += message.message.length
 
         clearTimeout(timeout)
@@ -363,9 +370,9 @@ describe("drawing app mesh", () => {
             broadcastListener.callback = (channel, message) => {
               const currTime = process.hrtime()
 
-              eraseTime =
+              eraseLocTime =
                 (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-              erasePackets += 1
+              erasePackets.push(message)
               eraseSize += message.message.length
 
               clearTimeout(timeout)
@@ -390,40 +397,14 @@ describe("drawing app mesh", () => {
           new Promise((resolve) => {
             sendListener.callback = (uid, channel, message) => {
               const currTime = process.hrtime()
-              syncTime =
+              syncLocTime =
                 (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
 
-              syncPackets += 1
+              syncPackets.push(message)
               syncSize += message.message.length
 
               clearTimeout(timeout)
-              timeout = setTimeout(() => {
-                printBenchmark("single draw and erase [parallel]", ITERATIONS, {
-                  addPath: {
-                    timeLoc: addTime,
-                    packets: addPackets,
-                    size: addSize,
-                    timeRem: -1,
-                    events: -1,
-                  },
-                  extendErasureIntervals: {
-                    timeLoc: eraseTime,
-                    packets: erasePackets,
-                    size: eraseSize,
-                    timeRem: -1,
-                    events: -1,
-                  },
-                  synchronisation: {
-                    timeLoc: syncTime,
-                    packets: syncPackets,
-                    size: syncSize,
-                    timeRem: -1,
-                    events: -1,
-                  },
-                })
-
-                resolve()
-              }, 1000)
+              timeout = setTimeout(() => resolve(), 1000)
             }
 
             prevTime = process.hrtime()
@@ -434,6 +415,135 @@ describe("drawing app mesh", () => {
             )(createMessageReceivedEvent(syncStep1))
           }),
       )
+      .then(
+        () =>
+          new Promise((resolve) => {
+            updateRoom.addEventListener("addOrUpdatePath", () => {
+              const currTime = process.hrtime()
+
+              addRemTime =
+                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
+              addEvents += 1
+
+              clearTimeout(timeout)
+              timeout = setTimeout(() => resolve(), 1000)
+            })
+
+            updateRoom.addEventListener("removedIntervalsChange", () => {
+              const currTime = process.hrtime()
+
+              addRemTime =
+                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
+              addEvents += 1
+
+              clearTimeout(timeout)
+              timeout = setTimeout(() => resolve(), 1000)
+            })
+
+            for (const addPacket of addPackets) {
+              getEventListener(
+                "update",
+                "messageReceived",
+              )(createMessageReceivedEvent(addPacket))
+            }
+          }),
+      )
+      .then(
+        () =>
+          new Promise((resolve) => {
+            updateRoom.addEventListener("addOrUpdatePath", () => {
+              const currTime = process.hrtime()
+
+              eraseRemTime =
+                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
+              eraseEvents += 1
+
+              clearTimeout(timeout)
+              timeout = setTimeout(() => resolve(), 1000)
+            })
+
+            updateRoom.addEventListener("removedIntervalsChange", () => {
+              const currTime = process.hrtime()
+
+              eraseRemTime =
+                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
+              eraseEvents += 1
+
+              clearTimeout(timeout)
+              timeout = setTimeout(() => resolve(), 1000)
+            })
+
+            for (const erasePacket of erasePackets) {
+              getEventListener(
+                "update",
+                "messageReceived",
+              )(createMessageReceivedEvent(erasePacket))
+            }
+          }),
+      )
+      .then(
+        () =>
+          new Promise((resolve) => {
+            syncRoom.addEventListener("addOrUpdatePath", () => {
+              const currTime = process.hrtime()
+
+              syncRemTime =
+                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
+              syncEvents += 1
+
+              clearTimeout(timeout)
+              timeout = setTimeout(() => resolve(), 1000)
+            })
+
+            syncRoom.addEventListener("removedIntervalsChange", () => {
+              const currTime = process.hrtime()
+
+              syncRemTime =
+                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
+              syncEvents += 1
+
+              clearTimeout(timeout)
+              timeout = setTimeout(() => resolve(), 1000)
+            })
+
+            for (const syncPacket of syncPackets) {
+              getEventListener(
+                "sync",
+                "messageReceived",
+              )(createMessageReceivedEvent(syncPacket))
+            }
+          }),
+      )
+      .then(
+        () =>
+          new Promise((resolve) => {
+            printBenchmark("single draw and erase [parallel]", ITERATIONS, {
+              addPath: {
+                timeLoc: addLocTime,
+                packets: addPackets.length,
+                size: addSize,
+                timeRem: addRemTime,
+                events: addEvents,
+              },
+              extendErasureIntervals: {
+                timeLoc: eraseLocTime,
+                packets: erasePackets.length,
+                size: eraseSize,
+                timeRem: eraseRemTime,
+                events: eraseEvents,
+              },
+              synchronisation: {
+                timeLoc: syncLocTime,
+                packets: syncPackets.length,
+                size: syncSize,
+                timeRem: syncRemTime,
+                events: syncEvents,
+              },
+            })
+
+            resolve()
+          }),
+      )
   })
 
   it("communicates a single draw and erase update", () => {