Expand range validation and event dispatch unit tests

This commit is contained in:
tongtong committed 2026-11-20 11:17:12 +08:00
1 parent 94e19b4fe4
commit 4fe8b4c6f9
2 files changed
+168

No files matched your search

@@ -2,6 +2,11 @@ package com.arialyy.aria.core.event;
import java.util.ArrayList;
import java.util.List;
import java.util.HashSet;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import org.junit.Test;
@@ -28,4 +33,125 @@ public class EventMsgUtilTest {
bus.unRegister(receiver);
}
}
static class GateEvent {}
// A latch, rather than sleep, keeps the queue deterministically full during assertions.
static class Gate {
final CountDownLatch entered = new CountDownLatch(1);
final CountDownLatch release = new CountDownLatch(1);
@Event public void receive(GateEvent event) throws InterruptedException {
entered.countDown();
if (!release.await(5, TimeUnit.SECONDS)) throw new AssertionError("Gate timed out");
}
}
static class Collector {
final List<Integer> values = new ArrayList<>();
final CountDownLatch drained = new CountDownLatch(1);
@Event public void receive(Integer value) { values.add(value); }
@Event public void barrier(String marker) { drained.countDown(); }
}
@Test(expected = IllegalArgumentException.class) public void rejectsNullEvent() {
EventMsgUtil.getDefault().post(null);
}
@Test public void rejectsFullQueueAndRecoversWithoutLosingAcceptedEvents() throws Exception {
EventMsgUtil bus = EventMsgUtil.getDefault();
Gate gate = new Gate();
Collector collector = new Collector();
bus.register(gate);
bus.register(collector);
try {
bus.post(new GateEvent());
assertTrue(gate.entered.await(5, TimeUnit.SECONDS));
for (int i = 0; i < 9; i++) bus.post(i);
bus.post("barrier");
try {
bus.post(999);
fail("A full queue must reject the event explicitly");
} catch (RejectedExecutionException expected) {
// The rejected event must never reach the subscriber.
}
gate.release.countDown();
assertTrue(collector.drained.await(5, TimeUnit.SECONDS));
assertEquals(9, collector.values.size());
for (int i = 0; i < 9; i++) assertEquals(Integer.valueOf(i), collector.values.get(i));
Collector next = new Collector();
bus.register(next);
try {
bus.post(42);
bus.post("recovered");
assertTrue(next.drained.await(5, TimeUnit.SECONDS));
assertEquals(java.util.Collections.singletonList(42), next.values);
} finally {
bus.unRegister(next);
}
} finally {
gate.release.countDown();
bus.unRegister(gate);
bus.unRegister(collector);
}
}
@Test public void queuedEventsDoNotReachUnregisteredSubscriber() throws Exception {
EventMsgUtil bus = EventMsgUtil.getDefault();
Gate gate = new Gate();
Collector removed = new Collector();
Collector observer = new Collector();
bus.register(gate);
bus.register(removed);
bus.register(observer);
try {
bus.post(new GateEvent());
assertTrue(gate.entered.await(5, TimeUnit.SECONDS));
bus.post(1);
bus.unRegister(removed);
bus.post("barrier");
gate.release.countDown();
assertTrue(observer.drained.await(5, TimeUnit.SECONDS));
assertTrue(removed.values.isEmpty());
assertEquals(java.util.Collections.singletonList(1), observer.values);
} finally {
gate.release.countDown();
bus.unRegister(gate);
bus.unRegister(removed);
bus.unRegister(observer);
}
}
@Test public void concurrentProducersDeliverEveryAcceptedEventExactlyOnce() throws Exception {
EventMsgUtil bus = EventMsgUtil.getDefault();
Collector collector = new Collector();
ExecutorService producers = Executors.newFixedThreadPool(4);
CountDownLatch start = new CountDownLatch(1);
List<Future<?>> futures = new ArrayList<>();
bus.register(collector);
try {
for (int i = 0; i < 4; i++) {
final int producer = i;
futures.add(producers.submit(() -> {
start.await();
bus.post(producer * 2);
bus.post(producer * 2 + 1);
return null;
}));
}
start.countDown();
for (Future<?> future : futures) future.get(5, TimeUnit.SECONDS);
bus.post("barrier");
assertTrue(collector.drained.await(5, TimeUnit.SECONDS));
assertEquals(8, collector.values.size());
assertEquals(8, new HashSet<>(collector.values).size());
for (int i = 0; i < 8; i++) assertTrue(collector.values.contains(i));
for (int i = 0; i < 4; i++) {
assertTrue(collector.values.indexOf(i * 2) < collector.values.indexOf(i * 2 + 1));
}
} finally {
start.countDown();
producers.shutdownNow();
bus.unRegister(collector);
}
}
}