From 342d6e621e920eabf298600e89829c84f8af164c Mon Sep 17 00:00:00 2001
From: Manoel Campos <manoelcampos@gmail.com>
Date: Tue, 20 Oct 2026 18:27:07 -0300
Subject: [PATCH] Remove ListenersNotificationBenchmark dependency on the
 Listeners class

The benchmark now creates the arrays of listeners itself and builds the
lists with List.of(array), which gives the same List classes CloudSim Plus
uses. This way, it compiles against both CloudSim Plus 8.5.1 and 9, and the
cloudsimplus-8 profile doesn't need to exclude it anymore.

Closes #8

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 pom.xml                                       | 15 ---------
 .../ListenersNotificationBenchmark.java       | 31 +++++++++----------
 2 files changed, 15 insertions(+), 31 deletions(-)

diff --git a/pom.xml b/pom.xml
index 8a4ea56..da6d405 100755
--- a/pom.xml
+++ b/pom.xml
@@ -259,26 +259,11 @@
             Builds the benchmarks with CloudSim Plus 8.5.1, to compare it with the current version
             (e.g., to measure memory before the changes from cloudsimplus#586 using ListenersMemoryBenchmark):
                 ./mvnw clean package -Pcloudsimplus-8
-            Benchmarks that use classes only available in CloudSim Plus 9 are excluded.
             -->
             <id>cloudsimplus-8</id>
             <properties>
                 <cloudsimplus.version>8.5.1</cloudsimplus.version>
             </properties>
-            <build>
-                <plugins>
-                    <plugin>
-                        <groupId>org.apache.maven.plugins</groupId>
-                        <artifactId>maven-compiler-plugin</artifactId>
-                        <configuration>
-                            <excludes>
-                                <!-- Uses the Listeners class, added in CloudSim Plus 9 (to be removed by issue #8) -->
-                                <exclude>org/cloudsimplus/listeners/ListenersNotificationBenchmark.java</exclude>
-                            </excludes>
-                        </configuration>
-                    </plugin>
-                </plugins>
-            </build>
         </profile>
     </profiles>
 </project>
diff --git a/src/main/java/org/cloudsimplus/listeners/ListenersNotificationBenchmark.java b/src/main/java/org/cloudsimplus/listeners/ListenersNotificationBenchmark.java
index ce662a4..0d47c3c 100644
--- a/src/main/java/org/cloudsimplus/listeners/ListenersNotificationBenchmark.java
+++ b/src/main/java/org/cloudsimplus/listeners/ListenersNotificationBenchmark.java
@@ -25,14 +25,16 @@
 
 import org.openjdk.jmh.annotations.*;
 
-import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 
 /// Measures the time and memory to notify listeners stored in:
-/// - an immutable [List] created by [Listeners] (as CloudSim Plus does) and
+/// - an immutable [List] created by `List.of(array)` (as CloudSim Plus does) and
 /// - a plain array, which is the alternative being assessed.
 ///
+/// The lists are created directly by `List.of(array)`, instead of using the CloudSim Plus class that stores listeners,
+/// so that the benchmark compiles against different CloudSim Plus versions.
+///
 /// A for-each loop over a [List] calls [List#iterator()], which creates an object,
 /// unless the JIT removes it using escape analysis. A for-each loop over an array creates no object.
 /// Run with the GC profiler (`-prof gc`) and check `gc.alloc.rate.norm` (bytes per operation)
@@ -77,8 +79,8 @@ public static class SingleSize {
 
         @Setup(Level.Trial)
         public void setup(final Counter counter) {
-            list = newList(listenersCount, counter);
-            array = toArray(list);
+            array = newListeners(listenersCount, counter);
+            list = List.of(array);
         }
     }
 
@@ -99,8 +101,8 @@ public void setup(final Counter counter) {
             lists = new List[MAX_LISTENERS + 1];
             arrays = new EventListener[MAX_LISTENERS + 1][];
             for (int count = 0; count <= MAX_LISTENERS; count++) {
-                lists[count] = newList(count, counter);
-                arrays[count] = toArray(lists[count]);
+                arrays[count] = newListeners(count, counter);
+                lists[count] = List.of(arrays[count]);
             }
         }
     }
@@ -147,20 +149,17 @@ private static void notifyListeners(final EventListener<EventInfo>[] listeners)
         }
     }
 
-    /// Creates a list with the given number of listeners, using [Listeners#add(List, Object)].
+    /// Creates an array with the given number of listeners.
     /// Each listener is a different lambda instance, since it captures its own id.
-    private static List<EventListener<EventInfo>> newList(final int listenersCount, final Counter counter) {
-        List<EventListener<EventInfo>> list = List.of();
+    /// The callers create a list with `List.of(array)`, which copies the array, so the list and the array don't share storage.
+    @SuppressWarnings("unchecked")
+    private static EventListener<EventInfo>[] newListeners(final int listenersCount, final Counter counter) {
+        final EventListener<EventInfo>[] listeners = new EventListener[listenersCount];
         for (int i = 0; i < listenersCount; i++) {
             final int id = i + 1;
-            list = Listeners.add(list, info -> counter.calls += id);
+            listeners[i] = info -> counter.calls += id;
         }
 
-        return list;
-    }
-
-    @SuppressWarnings("unchecked")
-    private static EventListener<EventInfo>[] toArray(final List<EventListener<EventInfo>> list) {
-        return Arrays.copyOf(list.toArray(), list.size(), EventListener[].class);
+        return listeners;
     }
 }