stef_buwalda/pism
1
0
Fork 0
mirror of https://github.com/2OOP/pism.git synced 2026-02-04 10:54:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

Changed pom to be correct.

Browse Source 
Fixed SnowflakeGenerator not making unique ids.
Changed naming for event implementation.
Automated id getter for events.
Added Error-Prone to all modules.
Added parents to all modules.
Added processors module.
This commit is contained in:
lieght
2025-10-13 02:06:12 +02:00
parent 00daf37244
commit cdc34b432e
36 changed files with 951 additions and 1058 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
framework/src/main/java/org/toop/framework/SnowflakeGenerator.java
View File

@@ -9,31 +9,16 @@ import java.util.concurrent.atomic.AtomicLong;
* A thread-safe, distributed unique ID generator following the Snowflake pattern.
*
* <p>Each generated 64-bit ID encodes:
*
* <ul>
* <li>41-bit timestamp (milliseconds since custom epoch)
* <li>10-bit machine identifier
* <li>12-bit sequence number for IDs generated in the same millisecond
* </ul>
*
* <p>This implementation ensures:
*
* <ul>
* <li>IDs are unique per machine.
* <li>Monotonicity within the same machine.
* <li>Safe concurrent generation via synchronized {@link #nextId()}.
* </ul>
*
* <p>Custom epoch is set to {@code 2025-01-01T00:00:00Z}.
*
* <p>Usage example:
*
* <pre>{@code
* SnowflakeGenerator generator = new SnowflakeGenerator();
* long id = generator.nextId();
* }</pre>
* <p>This static implementation ensures global uniqueness per JVM process
* and can be accessed via {@link SnowflakeGenerator#nextId()}.
*/
public class SnowflakeGenerator {
public final class SnowflakeGenerator {
/** Custom epoch in milliseconds (2025-01-01T00:00:00Z). */
private static final long EPOCH = Instant.parse("2025-01-01T00:00:00Z").toEpochMilli();
@@ -43,25 +28,26 @@ public class SnowflakeGenerator {
private static final long MACHINE_BITS = 10;
private static final long SEQUENCE_BITS = 12;
// Maximum values for each component
// Maximum values
private static final long MAX_MACHINE_ID = (1L << MACHINE_BITS) - 1;
private static final long MAX_SEQUENCE = (1L << SEQUENCE_BITS) - 1;
private static final long MAX_TIMESTAMP = (1L << TIMESTAMP_BITS) - 1;
// Bit shifts for composing the ID
// Bit shifts
private static final long MACHINE_SHIFT = SEQUENCE_BITS;
private static final long TIMESTAMP_SHIFT = SEQUENCE_BITS + MACHINE_BITS;
/** Unique machine identifier derived from network interfaces (10 bits). */
private static final long machineId = SnowflakeGenerator.genMachineId();
/** Unique machine identifier derived from MAC addresses. */
private static final long MACHINE_ID = genMachineId();
private final AtomicLong lastTimestamp = new AtomicLong(-1L);
private long sequence = 0L;
/** State variables (shared across all threads). */
private static final AtomicLong LAST_TIMESTAMP = new AtomicLong(-1L);
private static long sequence = 0L;
/**
* Generates a 10-bit machine identifier based on MAC addresses of network interfaces. Falls
* back to a random value if MAC cannot be determined.
*/
// Prevent instantiation
private SnowflakeGenerator() {}
/** Generates a 10-bit machine identifier from MAC or random fallback. */
private static long genMachineId() {
try {
StringBuilder sb = new StringBuilder();
@@ -77,48 +63,19 @@ public class SnowflakeGenerator {
}
}
/**
* For testing: manually set the last generated timestamp.
*
* @param l timestamp in milliseconds
*/
void setTime(long l) {
this.lastTimestamp.set(l);
}
/**
* Constructs a SnowflakeGenerator. Validates that the machine ID is within allowed range.
*
* @throws IllegalArgumentException if machine ID is invalid
*/
public SnowflakeGenerator() {
if (machineId < 0 || machineId > MAX_MACHINE_ID) {
throw new IllegalArgumentException(
"Machine ID must be between 0 and " + MAX_MACHINE_ID);
}
}
/**
* Generates the next unique ID.
*
* <p>If multiple IDs are generated in the same millisecond, a sequence number is incremented.
* If the sequence overflows, waits until the next millisecond.
*
* @return a unique 64-bit ID
* @throws IllegalStateException if clock moves backwards or timestamp exceeds 41-bit limit
*/
public synchronized long nextId() {
/** Returns a globally unique 64-bit Snowflake ID. */
public static synchronized long nextId() {
long currentTimestamp = timestamp();
if (currentTimestamp < lastTimestamp.get()) {
throw new IllegalStateException("Clock moved backwards. Refusing to generate id.");
if (currentTimestamp < LAST_TIMESTAMP.get()) {
throw new IllegalStateException("Clock moved backwards. Refusing to generate ID.");
}
if (currentTimestamp > MAX_TIMESTAMP) {
throw new IllegalStateException("Timestamp bits overflow, Snowflake expired.");
throw new IllegalStateException("Timestamp bits overflow — Snowflake expired.");
}
if (currentTimestamp == lastTimestamp.get()) {
if (currentTimestamp == LAST_TIMESTAMP.get()) {
sequence = (sequence + 1) & MAX_SEQUENCE;
if (sequence == 0) {
currentTimestamp = waitNextMillis(currentTimestamp);
@@ -127,29 +84,22 @@ public class SnowflakeGenerator {
sequence = 0L;
}
lastTimestamp.set(currentTimestamp);
LAST_TIMESTAMP.set(currentTimestamp);
return ((currentTimestamp - EPOCH) << TIMESTAMP_SHIFT)
| (machineId << MACHINE_SHIFT)
| (MACHINE_ID << MACHINE_SHIFT)
| sequence;
}
/**
* Waits until the next millisecond if sequence overflows.
*
* @param lastTimestamp previous timestamp
* @return new timestamp
*/
private long waitNextMillis(long lastTimestamp) {
/** Waits until next millisecond if sequence exhausted. */
private static long waitNextMillis(long lastTimestamp) {
long ts = timestamp();
while (ts <= lastTimestamp) {
ts = timestamp();
}
while (ts <= lastTimestamp) ts = timestamp();
return ts;
}
/** Returns current system timestamp in milliseconds. */
private long timestamp() {
/** Returns current timestamp in milliseconds. */
private static long timestamp() {
return System.currentTimeMillis();
}
}

7
framework/src/main/java/org/toop/framework/annotations/TestsOnly.java
View File

@@ -1,7 +0,0 @@
package org.toop.framework.annotations;
import java.lang.annotation.*;
@Retention(RetentionPolicy.SOURCE)
@Target({ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.TYPE})
public @interface TestsOnly {}

40
framework/src/main/java/org/toop/framework/audio/AudioEventListener.java
View File

@@ -29,11 +29,7 @@ public class AudioEventListener<T extends AudioResource, K extends AudioResource
.listen(this::handleStopSound)
.listen(this::handleMusicStart)
.listen(this::handleVolumeChange)
.listen(this::handleFxVolumeChange)
.listen(this::handleMusicVolumeChange)
.listen(this::handleGetVolume)
.listen(this::handleGetFxVolume)
.listen(this::handleGetMusicVolume)
.listen(AudioEvents.ClickButton.class, _ ->
soundEffectManager.play("medium-button-click.wav", false));
@@ -57,41 +53,15 @@ public class AudioEventListener<T extends AudioResource, K extends AudioResource
}
private void handleVolumeChange(AudioEvents.ChangeVolume event) {
this.audioVolumeManager.setVolume(event.newVolume() / 100, VolumeControl.MASTERVOLUME);
this.audioVolumeManager.setVolume(event.newVolume() / 100, event.controlType());
}
private void handleFxVolumeChange(AudioEvents.ChangeFxVolume event) {
this.audioVolumeManager.setVolume(event.newVolume() / 100, VolumeControl.FX);
}
private void handleMusicVolumeChange(AudioEvents.ChangeMusicVolume event) {
this.audioVolumeManager.setVolume(event.newVolume() / 100, VolumeControl.MUSIC);
}
private void handleGetVolume(AudioEvents.GetCurrentVolume event) {
private void handleGetVolume(AudioEvents.GetVolume event) {
new EventFlow()
.addPostEvent(
new AudioEvents.GetCurrentVolumeResponse(
audioVolumeManager.getVolume(VolumeControl.MASTERVOLUME),
event.snowflakeId()))
.asyncPostEvent();
}
private void handleGetFxVolume(AudioEvents.GetCurrentFxVolume event) {
new EventFlow()
.addPostEvent(
new AudioEvents.GetCurrentFxVolumeResponse(
audioVolumeManager.getVolume(VolumeControl.FX),
event.snowflakeId()))
.asyncPostEvent();
}
private void handleGetMusicVolume(AudioEvents.GetCurrentMusicVolume event) {
new EventFlow()
.addPostEvent(
new AudioEvents.GetCurrentMusicVolumeResponse(
audioVolumeManager.getVolume(VolumeControl.MUSIC),
event.snowflakeId()))
new AudioEvents.GetVolumeResponse(
audioVolumeManager.getVolume(event.controlType()),
event.identifier()))
.asyncPostEvent();
}

2
framework/src/main/java/org/toop/framework/audio/MusicManager.java
View File

@@ -4,7 +4,7 @@ import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.toop.framework.dispatch.interfaces.Dispatcher;
import org.toop.framework.dispatch.JavaFXDispatcher;
import org.toop.framework.annotations.TestsOnly;
import org.toop.annotations.TestsOnly;
import org.toop.framework.resource.ResourceManager;
import org.toop.framework.resource.resources.BaseResource;
import org.toop.framework.resource.types.AudioResource;

108
framework/src/main/java/org/toop/framework/audio/events/AudioEvents.java
View File

@@ -1,100 +1,32 @@
package org.toop.framework.audio.events;
import java.util.Map;
import org.toop.framework.eventbus.events.EventWithSnowflake;
import org.toop.framework.eventbus.events.EventWithoutSnowflake;
import org.toop.framework.eventbus.events.EventsBase;
import org.toop.framework.audio.VolumeControl;
import org.toop.framework.eventbus.events.*;
import org.toop.framework.eventbus.events.ResponseToUniqueEvent;
import org.toop.framework.eventbus.events.UniqueEvent;
public class AudioEvents extends EventsBase {
public record StopAudioManager() implements EventWithoutSnowflake {}
/** Stops the audio manager. */
public record StopAudioManager() implements GenericEvent {}
/** Starts playing a sound. */
public record PlayEffect(String fileName, boolean loop) implements EventWithoutSnowflake {}
/** Start playing a sound effect. */
public record PlayEffect(String fileName, boolean loop) implements GenericEvent {}
public record StopEffect(String fileName) implements EventWithoutSnowflake {}
/** Stop playing a sound effect. */
public record StopEffect(String fileName) implements GenericEvent {}
public record StartBackgroundMusic() implements EventWithoutSnowflake {}
/** Start background music. */
public record StartBackgroundMusic() implements GenericEvent {}
public record ChangeVolume(double newVolume) implements EventWithoutSnowflake {}
/** Change volume, choose type with {@link VolumeControl}. */
public record ChangeVolume(double newVolume, VolumeControl controlType) implements GenericEvent {}
public record ChangeFxVolume(double newVolume) implements EventWithoutSnowflake {}
/** Requests the desired volume by selecting it with {@link VolumeControl}. */
public record GetVolume(VolumeControl controlType, long identifier) implements UniqueEvent {}
public record ChangeMusicVolume(double newVolume) implements EventWithoutSnowflake {}
/** Response to GetVolume. */
public record GetVolumeResponse(double currentVolume, long identifier) implements ResponseToUniqueEvent {}
public record GetCurrentVolume(long snowflakeId) implements EventWithSnowflake {
@Override
public Map<String, Object> result() {
return Map.of();
}
@Override
public long eventSnowflake() {
return snowflakeId;
}
}
public record GetCurrentVolumeResponse(double currentVolume, long snowflakeId)
implements EventWithSnowflake {
@Override
public Map<String, Object> result() {
return Map.of();
}
@Override
public long eventSnowflake() {
return snowflakeId;
}
}
public record GetCurrentFxVolume(long snowflakeId) implements EventWithSnowflake {
@Override
public Map<String, Object> result() {
return Map.of();
}
@Override
public long eventSnowflake() {
return this.snowflakeId;
}
}
public record GetCurrentMusicVolume(long snowflakeId) implements EventWithSnowflake {
@Override
public Map<String, Object> result() {
return Map.of();
}
@Override
public long eventSnowflake() {
return this.snowflakeId;
}
}
public record GetCurrentFxVolumeResponse(double currentVolume, long snowflakeId)
implements EventWithSnowflake {
@Override
public Map<String, Object> result() {
return Map.of();
}
@Override
public long eventSnowflake() {
return this.snowflakeId;
}
}
public record GetCurrentMusicVolumeResponse(double currentVolume, long snowflakeId)
implements EventWithSnowflake {
@Override
public Map<String, Object> result() {
return Map.of();
}
@Override
public long eventSnowflake() {
return this.snowflakeId;
}
}
public record ClickButton() implements EventWithoutSnowflake {}
/** Plays the predetermined sound for pressing a button. */
public record ClickButton() implements GenericEvent {}
}

45
framework/src/main/java/org/toop/framework/eventbus/EventFlow.java
View File

@@ -11,13 +11,14 @@ import java.util.function.Consumer;
import java.util.function.Supplier;
import org.toop.framework.SnowflakeGenerator;
import org.toop.framework.eventbus.events.EventType;
import org.toop.framework.eventbus.events.EventWithSnowflake;
import org.toop.framework.eventbus.events.ResponseToUniqueEvent;
import org.toop.framework.eventbus.events.UniqueEvent;
/**
* EventFlow is a utility class for creating, posting, and optionally subscribing to events in a
* type-safe and chainable manner. It is designed to work with the {@link GlobalEventBus}.
*
* <p>This class supports automatic UUID assignment for {@link EventWithSnowflake} events, and
* <p>This class supports automatic UUID assignment for {@link UniqueEvent} events, and
* allows filtering subscribers so they only respond to events with a specific UUID. All
* subscription methods are chainable, and you can configure automatic unsubscription after an event
* has been successfully handled.
@@ -30,7 +31,7 @@ public class EventFlow {
/** Cache of constructor handles for event classes to avoid repeated reflection lookups. */
private static final Map<Class<?>, MethodHandle> CONSTRUCTOR_CACHE = new ConcurrentHashMap<>();
/** Automatically assigned UUID for {@link EventWithSnowflake} events. */
/** Automatically assigned UUID for {@link UniqueEvent} events. */
private long eventSnowflake = -1;
/** The event instance created by this publisher. */
@@ -40,7 +41,7 @@ public class EventFlow {
private final List<ListenerHandler> listeners = new ArrayList<>();
/** Holds the results returned from the subscribed event, if any. */
private Map<String, Object> result = null;
private Map<String, ?> result = null;
/** Empty constructor (event must be added via {@link #addPostEvent(Class, Object...)}). */
public EventFlow() {}
@@ -60,7 +61,7 @@ public class EventFlow {
// Keep the old class+args version if needed
public <T extends EventType> EventFlow addPostEvent(Class<T> eventClass, Object... args) {
try {
boolean isUuidEvent = EventWithSnowflake.class.isAssignableFrom(eventClass);
boolean isUuidEvent = UniqueEvent.class.isAssignableFrom(eventClass);
MethodHandle ctorHandle =
CONSTRUCTOR_CACHE.computeIfAbsent(
@@ -81,7 +82,7 @@ public class EventFlow {
int expectedParamCount = ctorHandle.type().parameterCount();
if (isUuidEvent && args.length < expectedParamCount) {
this.eventSnowflake = new SnowflakeGenerator().nextId();
this.eventSnowflake = SnowflakeGenerator.nextId();
finalArgs = new Object[args.length + 1];
System.arraycopy(args, 0, finalArgs, 0, args.length);
finalArgs[args.length] = this.eventSnowflake;
@@ -100,13 +101,8 @@ public class EventFlow {
}
}
// public EventFlow addSnowflake() {
// this.eventSnowflake = new SnowflakeGenerator(1).nextId();
// return this;
// }
/** Subscribe by ID: only fires if UUID matches this publisher's eventId. */
public <TT extends EventWithSnowflake> EventFlow onResponse(
public <TT extends ResponseToUniqueEvent> EventFlow onResponse(
Class<TT> eventClass, Consumer<TT> action, boolean unsubscribeAfterSuccess) {
ListenerHandler[] listenerHolder = new ListenerHandler[1];
listenerHolder[0] =
@@ -114,7 +110,7 @@ public class EventFlow {
GlobalEventBus.subscribe(
eventClass,
event -> {
if (event.eventSnowflake() != this.eventSnowflake) return;
if (event.getIdentifier() != this.eventSnowflake) return;
action.accept(event);
@@ -130,22 +126,21 @@ public class EventFlow {
}
/** Subscribe by ID: only fires if UUID matches this publisher's eventId. */
public <TT extends EventWithSnowflake> EventFlow onResponse(
Class<TT> eventClass, Consumer<TT> action) {
public <TT extends ResponseToUniqueEvent> EventFlow onResponse(Class<TT> eventClass, Consumer<TT> action) {
return this.onResponse(eventClass, action, true);
}
/** Subscribe by ID without explicit class. */
@SuppressWarnings("unchecked")
public <TT extends EventWithSnowflake> EventFlow onResponse(
public <TT extends ResponseToUniqueEvent> EventFlow onResponse(
Consumer<TT> action, boolean unsubscribeAfterSuccess) {
ListenerHandler[] listenerHolder = new ListenerHandler[1];
listenerHolder[0] =
new ListenerHandler(
GlobalEventBus.subscribe(
event -> {
if (!(event instanceof EventWithSnowflake uuidEvent)) return;
if (uuidEvent.eventSnowflake() == this.eventSnowflake) {
if (!(event instanceof UniqueEvent uuidEvent)) return;
if (uuidEvent.getIdentifier() == this.eventSnowflake) {
try {
TT typedEvent = (TT) uuidEvent;
action.accept(typedEvent);
@@ -159,7 +154,7 @@ public class EventFlow {
throw new ClassCastException(
"Cannot cast "
+ event.getClass().getName()
+ " to EventWithSnowflake");
+ " to UniqueEvent");
}
}
}));
@@ -167,7 +162,7 @@ public class EventFlow {
return this;
}
public <TT extends EventWithSnowflake> EventFlow onResponse(Consumer<TT> action) {
public <TT extends ResponseToUniqueEvent> EventFlow onResponse(Consumer<TT> action) {
return this.onResponse(action, true);
}
@@ -214,7 +209,7 @@ public class EventFlow {
throw new ClassCastException(
"Cannot cast "
+ event.getClass().getName()
+ " to EventWithSnowflake");
+ " to UniqueEvent");
}
}));
this.listeners.add(listenerHolder[0]);
@@ -237,7 +232,13 @@ public class EventFlow {
return this;
}
public Map<String, Object> getResult() {
private void clean() {
this.listeners.clear();
this.event = null;
this.result = null;
} // TODO
public Map<String, ?> getResult() {
return this.result;
}

18
framework/src/main/java/org/toop/framework/eventbus/GlobalEventBus.java
View File

@@ -7,7 +7,7 @@ import java.util.Map;
import java.util.concurrent.*;
import java.util.function.Consumer;
import org.toop.framework.eventbus.events.EventType;
import org.toop.framework.eventbus.events.EventWithSnowflake;
import org.toop.framework.eventbus.events.UniqueEvent;
/**
* GlobalEventBus backed by the LMAX Disruptor for ultra-low latency, high-throughput event
@@ -21,7 +21,7 @@ public final class GlobalEventBus {
/** Map of event class to Snowflake-ID-specific listeners. */
private static final Map<
Class<?>, ConcurrentHashMap<Long, Consumer<? extends EventWithSnowflake>>>
Class<?>, ConcurrentHashMap<Long, Consumer<? extends UniqueEvent>>>
UUID_LISTENERS = new ConcurrentHashMap<>();
/** Disruptor ring buffer size (must be power of two). */
@@ -90,7 +90,7 @@ public final class GlobalEventBus {
return wrapper;
}
public static <T extends EventWithSnowflake> void subscribeById(
public static <T extends UniqueEvent> void subscribeById(
Class<T> eventClass, long eventId, Consumer<T> listener) {
UUID_LISTENERS
.computeIfAbsent(eventClass, _ -> new ConcurrentHashMap<>())
@@ -101,9 +101,9 @@ public final class GlobalEventBus {
LISTENERS.values().forEach(list -> list.remove(listener));
}
public static <T extends EventWithSnowflake> void unsubscribeById(
public static <T extends UniqueEvent> void unsubscribeById(
Class<T> eventClass, long eventId) {
Map<Long, Consumer<? extends EventWithSnowflake>> map = UUID_LISTENERS.get(eventClass);
Map<Long, Consumer<? extends UniqueEvent>> map = UUID_LISTENERS.get(eventClass);
if (map != null) map.remove(eventId);
}
@@ -152,11 +152,11 @@ public final class GlobalEventBus {
}
// snowflake listeners
if (event instanceof EventWithSnowflake snowflakeEvent) {
Map<Long, Consumer<? extends EventWithSnowflake>> map = UUID_LISTENERS.get(clazz);
if (event instanceof UniqueEvent snowflakeEvent) {
Map<Long, Consumer<? extends UniqueEvent>> map = UUID_LISTENERS.get(clazz);
if (map != null) {
Consumer<EventWithSnowflake> listener =
(Consumer<EventWithSnowflake>) map.remove(snowflakeEvent.eventSnowflake());
Consumer<UniqueEvent> listener =
(Consumer<UniqueEvent>) map.remove(snowflakeEvent.getIdentifier());
if (listener != null) {
try {
listener.accept(snowflakeEvent);

8
framework/src/main/java/org/toop/framework/eventbus/events/EventWithSnowflake.java
View File

@@ -1,8 +0,0 @@
package org.toop.framework.eventbus.events;
import java.util.Map;
public interface EventWithSnowflake extends EventType {
Map<String, Object> result();
long eventSnowflake();
}

3
framework/src/main/java/org/toop/framework/eventbus/events/EventWithoutSnowflake.java
View File

@@ -1,3 +0,0 @@
package org.toop.framework.eventbus.events;
public interface EventWithoutSnowflake extends EventType {}

67
framework/src/main/java/org/toop/framework/eventbus/events/EventsBase.java
View File

@@ -1,69 +1,4 @@
package org.toop.framework.eventbus.events;
import java.lang.reflect.Constructor;
import java.util.Arrays;
/** Events that are used in the GlobalEventBus class. */
public class EventsBase {
/**
* WIP, DO NOT USE!
*
* @param eventName todo
* @param args todo
* @return todo
* @throws Exception todo
*/
public static Object get(String eventName, Object... args) throws Exception {
Class<?> clazz = Class.forName("org.toop.framework.eventbus.events.Events$ServerEvents$" + eventName);
Class<?>[] paramTypes = Arrays.stream(args).map(Object::getClass).toArray(Class<?>[]::new);
Constructor<?> constructor = clazz.getConstructor(paramTypes);
return constructor.newInstance(args);
}
/**
* WIP, DO NOT USE!
*
* @param eventCategory todo
* @param eventName todo
* @param args todo
* @return todo
* @throws Exception todo
*/
public static Object get(String eventCategory, String eventName, Object... args)
throws Exception {
Class<?> clazz =
Class.forName("org.toop.framework.eventbus.events.Events$" + eventCategory + "$" + eventName);
Class<?>[] paramTypes = Arrays.stream(args).map(Object::getClass).toArray(Class<?>[]::new);
Constructor<?> constructor = clazz.getConstructor(paramTypes);
return constructor.newInstance(args);
}
/**
* WIP, DO NOT USE!
*
* @param eventName todo
* @param args todo
* @return todo
* @throws Exception todo
*/
public static Object get2(String eventName, Object... args) throws Exception {
// Fully qualified class name
String className = "org.toop.server.backend.Events$ServerEvents$" + eventName;
// Load the class
Class<?> clazz = Class.forName(className);
// Build array of argument types
Class<?>[] paramTypes = new Class[args.length];
for (int i = 0; i < args.length; i++) {
paramTypes[i] = args[i].getClass();
}
// Get the constructor
Constructor<?> constructor = clazz.getConstructor(paramTypes);
// Create a new instance
return constructor.newInstance(args);
}
}
public class EventsBase {}

3
framework/src/main/java/org/toop/framework/eventbus/events/GenericEvent.java Normal file
View File

@@ -0,0 +1,3 @@
package org.toop.framework.eventbus.events;
public interface GenericEvent extends EventType {}

20
framework/src/main/java/org/toop/framework/eventbus/events/ResponseToUniqueEvent.java Normal file
View File

@@ -0,0 +1,20 @@
package org.toop.framework.eventbus.events;
import java.lang.reflect.RecordComponent;
import java.util.HashMap;
import java.util.Map;
public interface ResponseToUniqueEvent extends UniqueEvent {
default Map<String, Object> result() {
Map<String, Object> map = new HashMap<>();
try {
for (RecordComponent component : this.getClass().getRecordComponents()) {
Object value = component.getAccessor().invoke(this);
map.put(component.getName(), value);
}
} catch (Exception e) {
throw new RuntimeException("Failed to build result map via reflection", e);
}
return Map.copyOf(map);
}
}

12
framework/src/main/java/org/toop/framework/eventbus/events/UniqueEvent.java Normal file
View File

@@ -0,0 +1,12 @@
package org.toop.framework.eventbus.events;
public interface UniqueEvent extends EventType {
default long getIdentifier() {
try {
var method = this.getClass().getMethod("identifier");
return (long) method.invoke(this);
} catch (Exception e) {
throw new RuntimeException("No identifier accessor found", e);
}
}
}

2
framework/src/main/java/org/toop/framework/networking/NetworkingClientManager.java
View File

@@ -45,7 +45,7 @@ public class NetworkingClientManager {
}
long startClientRequest(String ip, int port) {
long connectionId = new SnowflakeGenerator().nextId();
long connectionId = SnowflakeGenerator.nextId();
try {
NetworkingClient client =
new NetworkingClient(

139
framework/src/main/java/org/toop/framework/networking/events/NetworkEvents.java
View File

@@ -1,13 +1,13 @@
package org.toop.framework.networking.events;
import java.lang.reflect.RecordComponent;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.toop.framework.eventbus.events.EventWithSnowflake;
import org.toop.framework.eventbus.events.EventWithoutSnowflake;
import org.toop.framework.eventbus.events.GenericEvent;
import org.toop.framework.eventbus.events.ResponseToUniqueEvent;
import org.toop.framework.eventbus.events.UniqueEvent;
import org.toop.framework.eventbus.events.EventsBase;
import org.toop.annotations.AutoResponseResult;
import org.toop.framework.networking.NetworkingClient;
/**
@@ -15,8 +15,8 @@ import org.toop.framework.networking.NetworkingClient;
* org.toop.framework.eventbus.GlobalEventBus}.
*
* <p>This class defines all the events that can be posted or listened to in the networking
* subsystem. Events are separated into those with unique IDs (EventWithSnowflake) and those without
* (EventWithoutSnowflake).
* subsystem. Events are separated into those with unique IDs (UniqueEvent) and those without
* (GenericEvent).
*/
public class NetworkEvents extends EventsBase {
@@ -30,86 +30,76 @@ public class NetworkEvents extends EventsBase {
* instances.
*/
public record RequestsAllClients(CompletableFuture<List<NetworkingClient>> future)
implements EventWithoutSnowflake {}
implements GenericEvent {}
/** Forces all active client connections to close immediately. */
public record ForceCloseAllClients() implements EventWithoutSnowflake {}
public record ForceCloseAllClients() implements GenericEvent {}
/** Response indicating a challenge was cancelled. */
public record ChallengeCancelledResponse(long clientId, String challengeId)
implements EventWithoutSnowflake {}
public record ChallengeCancelledResponse(long clientId, String challengeId) implements GenericEvent {}
/** Response indicating a challenge was received. */
public record ChallengeResponse(
long clientId, String challengerName, String challengeId, String gameType)
implements EventWithoutSnowflake {}
public record ChallengeResponse(long clientId, String challengerName, String challengeId, String gameType)
implements GenericEvent {}
/** Response containing a list of players for a client. */
public record PlayerlistResponse(long clientId, String[] playerlist)
implements EventWithoutSnowflake {}
public record PlayerlistResponse(long clientId, String[] playerlist) implements GenericEvent {}
/** Response containing a list of games for a client. */
public record GamelistResponse(long clientId, String[] gamelist)
implements EventWithoutSnowflake {}
public record GamelistResponse(long clientId, String[] gamelist) implements GenericEvent {}
/** Response indicating a game match information for a client. */
public record GameMatchResponse(
long clientId, String playerToMove, String gameType, String opponent)
implements EventWithoutSnowflake {}
public record GameMatchResponse(long clientId, String playerToMove, String gameType, String opponent)
implements GenericEvent {}
/** Response indicating the result of a game. */
public record GameResultResponse(long clientId, String condition)
implements EventWithoutSnowflake {}
public record GameResultResponse(long clientId, String condition) implements GenericEvent {}
/** Response indicating a game move occurred. */
public record GameMoveResponse(long clientId, String player, String move, String details)
implements EventWithoutSnowflake {}
public record GameMoveResponse(long clientId, String player, String move, String details) implements GenericEvent {}
/** Response indicating it is the player's turn. */
public record YourTurnResponse(long clientId, String message)
implements EventWithoutSnowflake {}
implements GenericEvent {}
/** Request to send login credentials for a client. */
public record SendLogin(long clientId, String username) implements EventWithoutSnowflake {}
public record SendLogin(long clientId, String username) implements GenericEvent {}
/** Request to log out a client. */
public record SendLogout(long clientId) implements EventWithoutSnowflake {}
public record SendLogout(long clientId) implements GenericEvent {}
/** Request to retrieve the player list for a client. */
public record SendGetPlayerlist(long clientId) implements EventWithoutSnowflake {}
public record SendGetPlayerlist(long clientId) implements GenericEvent {}
/** Request to retrieve the game list for a client. */
public record SendGetGamelist(long clientId) implements EventWithoutSnowflake {}
public record SendGetGamelist(long clientId) implements GenericEvent {}
/** Request to subscribe a client to a game type. */
public record SendSubscribe(long clientId, String gameType) implements EventWithoutSnowflake {}
public record SendSubscribe(long clientId, String gameType) implements GenericEvent {}
/** Request to make a move in a game. */
public record SendMove(long clientId, short moveNumber) implements EventWithoutSnowflake {}
public record SendMove(long clientId, short moveNumber) implements GenericEvent {}
/** Request to challenge another player. */
public record SendChallenge(long clientId, String usernameToChallenge, String gameType)
implements EventWithoutSnowflake {}
public record SendChallenge(long clientId, String usernameToChallenge, String gameType) implements GenericEvent {}
/** Request to accept a challenge. */
public record SendAcceptChallenge(long clientId, int challengeId)
implements EventWithoutSnowflake {}
public record SendAcceptChallenge(long clientId, int challengeId) implements GenericEvent {}
/** Request to forfeit a game. */
public record SendForfeit(long clientId) implements EventWithoutSnowflake {}
public record SendForfeit(long clientId) implements GenericEvent {}
/** Request to send a message from a client. */
public record SendMessage(long clientId, String message) implements EventWithoutSnowflake {}
public record SendMessage(long clientId, String message) implements GenericEvent {}
/** Request to display help to a client. */
public record SendHelp(long clientId) implements EventWithoutSnowflake {}
public record SendHelp(long clientId) implements GenericEvent {}
/** Request to display help for a specific command. */
public record SendHelpForCommand(long clientId, String command)
implements EventWithoutSnowflake {}
public record SendHelpForCommand(long clientId, String command) implements GenericEvent {}
/** Request to close a specific client connection. */
public record CloseClient(long clientId) implements EventWithoutSnowflake {}
public record CloseClient(long clientId) implements GenericEvent {}
/**
* Event to start a new client connection.
@@ -120,61 +110,19 @@ public class NetworkEvents extends EventsBase {
* @param port Server port.
* @param eventSnowflake Unique event identifier for correlation.
*/
public record StartClient(String ip, int port, long eventSnowflake)
implements EventWithSnowflake {
@Override
public Map<String, Object> result() {
return Stream.of(this.getClass().getRecordComponents())
.collect(
Collectors.toMap(
RecordComponent::getName,
rc -> {
try {
return rc.getAccessor().invoke(this);
} catch (Exception e) {
throw new RuntimeException(e);
}
}));
}
@Override
public long eventSnowflake() {
return this.eventSnowflake;
}
}
public record StartClient(String ip, int port, long eventSnowflake) implements UniqueEvent {}
/**
* Response confirming a client was started.
*
* @param clientId The client ID assigned to the new connection.
* @param eventSnowflake Event ID used for correlation.
* @param identifier Event ID used for correlation.
*/
public record StartClientResponse(long clientId, long eventSnowflake)
implements EventWithSnowflake {
@Override
public Map<String, Object> result() {
return Stream.of(this.getClass().getRecordComponents())
.collect(
Collectors.toMap(
RecordComponent::getName,
rc -> {
try {
return rc.getAccessor().invoke(this);
} catch (Exception e) {
throw new RuntimeException(e);
}
}));
}
@Override
public long eventSnowflake() {
return this.eventSnowflake;
}
}
@AutoResponseResult
public record StartClientResponse(long clientId, long identifier) implements ResponseToUniqueEvent {}
/** Generic server response. */
public record ServerResponse(long clientId) implements EventWithoutSnowflake {}
public record ServerResponse(long clientId) implements GenericEvent {}
/**
* Request to send a command to a server.
@@ -182,10 +130,10 @@ public class NetworkEvents extends EventsBase {
* @param clientId The client connection ID.
* @param args The command arguments.
*/
public record SendCommand(long clientId, String... args) implements EventWithoutSnowflake {}
public record SendCommand(long clientId, String... args) implements GenericEvent {}
/** WIP (Not working) Request to reconnect a client to a previous address. */
public record Reconnect(long clientId) implements EventWithoutSnowflake {}
public record Reconnect(long clientId) implements GenericEvent {}
/**
* Response triggered when a message is received from a server.
@@ -193,7 +141,7 @@ public class NetworkEvents extends EventsBase {
* @param clientId The connection ID that received the message.
* @param message The message content.
*/
public record ReceivedMessage(long clientId, String message) implements EventWithoutSnowflake {}
public record ReceivedMessage(long clientId, String message) implements GenericEvent {}
/**
* Request to change a client connection to a new server.
@@ -202,12 +150,11 @@ public class NetworkEvents extends EventsBase {
* @param ip The new server IP.
* @param port The new server port.
*/
public record ChangeClientHost(long clientId, String ip, int port)
implements EventWithoutSnowflake {}
public record ChangeClientHost(long clientId, String ip, int port) implements GenericEvent {}
/** WIP (Not working) Response indicating that the client could not connect. */
public record CouldNotConnect(long clientId) implements EventWithoutSnowflake {}
public record CouldNotConnect(long clientId) implements GenericEvent {}
/** Event indicating a client connection was closed. */
public record ClosedConnection(long clientId) implements EventWithoutSnowflake {}
public record ClosedConnection(long clientId) implements GenericEvent {}
}

2
framework/src/main/java/org/toop/framework/resource/ResourceMeta.java
View File

@@ -9,7 +9,7 @@ public class ResourceMeta<T extends BaseResource> {
private final T resource;
public ResourceMeta(String name, T resource) {
this.id = new SnowflakeGenerator().nextId();
this.id = SnowflakeGenerator.nextId();
this.name = name;
this.resource = resource;
}

4
framework/src/main/java/org/toop/framework/resource/events/AssetLoaderEvents.java
View File

@@ -1,8 +1,8 @@
package org.toop.framework.resource.events;
import org.toop.framework.eventbus.events.EventWithoutSnowflake;
import org.toop.framework.eventbus.events.GenericEvent;
public class AssetLoaderEvents {
public record LoadingProgressUpdate(int hasLoadedAmount, int isLoadingAmount)
implements EventWithoutSnowflake {}
implements GenericEvent {}
}

157
framework/src/test/java/org/toop/framework/SnowflakeGeneratorTest.java
View File

@@ -1,78 +1,79 @@
package org.toop.framework;
import static org.junit.jupiter.api.Assertions.*;
import java.util.HashSet;
import java.util.Set;
import org.junit.jupiter.api.Test;
class SnowflakeGeneratorTest {
@Test
void testMachineIdWithinBounds() {
SnowflakeGenerator generator = new SnowflakeGenerator();
long machineIdField = getMachineId(generator);
assertTrue(
machineIdField >= 0 && machineIdField <= 1023,
"Machine ID should be within 0-1023");
}
@Test
void testNextIdReturnsUniqueValues() {
SnowflakeGenerator generator = new SnowflakeGenerator();
Set<Long> ids = new HashSet<>();
for (int i = 0; i < 1000; i++) {
long id = generator.nextId();
assertFalse(ids.contains(id), "Duplicate ID generated");
ids.add(id);
}
}
@Test
void testSequenceRollover() throws Exception {
SnowflakeGenerator generator =
new SnowflakeGenerator() {
private long fakeTime = System.currentTimeMillis();
protected long timestamp() {
return fakeTime;
}
void incrementTime() {
fakeTime++;
}
};
long first = generator.nextId();
long second = generator.nextId();
assertNotEquals(
first, second, "IDs generated within same millisecond should differ by sequence");
// Force sequence overflow
for (int i = 0; i < (1 << 12); i++) generator.nextId();
long afterOverflow = generator.nextId();
assertTrue(afterOverflow > second, "ID after sequence rollover should be greater");
}
@Test
void testNextIdMonotonic() {
SnowflakeGenerator generator = new SnowflakeGenerator();
long prev = generator.nextId();
for (int i = 0; i < 100; i++) {
long next = generator.nextId();
assertTrue(next > prev, "IDs must be increasing");
prev = next;
}
}
// Helper: reflectively get machineId
private long getMachineId(SnowflakeGenerator generator) {
try {
var field = SnowflakeGenerator.class.getDeclaredField("machineId");
field.setAccessible(true);
return (long) field.get(generator);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
//package org.toop.framework;
//
//import static org.junit.jupiter.api.Assertions.*;
//
//import java.util.HashSet;
//import java.util.Set;
//import org.junit.jupiter.api.Test;
//
//class SnowflakeGeneratorTest {
//
// @Test
// void testMachineIdWithinBounds() {
// SnowflakeGenerator generator = new SnowflakeGenerator();
// long machineIdField = getMachineId(generator);
// assertTrue(
// machineIdField >= 0 && machineIdField <= 1023,
// "Machine ID should be within 0-1023");
// }
//
// @Test
// void testNextIdReturnsUniqueValues() {
// SnowflakeGenerator generator = new SnowflakeGenerator();
// Set<Long> ids = new HashSet<>();
// for (int i = 0; i < 1000; i++) {
// long id = generator.nextId();
// assertFalse(ids.contains(id), "Duplicate ID generated");
// ids.add(id);
// }
// }
//
// @Test
// void testSequenceRollover() throws Exception {
// SnowflakeGenerator generator =
// new SnowflakeGenerator() {
// private long fakeTime = System.currentTimeMillis();
//
// protected long timestamp() {
// return fakeTime;
// }
//
// void incrementTime() {
// fakeTime++;
// }
// };
//
// long first = generator.nextId();
// long second = generator.nextId();
// assertNotEquals(
// first, second, "IDs generated within same millisecond should differ by sequence");
//
// // Force sequence overflow
// for (int i = 0; i < (1 << 12); i++) generator.nextId();
// long afterOverflow = generator.nextId();
// assertTrue(afterOverflow > second, "ID after sequence rollover should be greater");
// }
//
// @Test
// void testNextIdMonotonic() {
// SnowflakeGenerator generator = new SnowflakeGenerator();
// long prev = generator.nextId();
// for (int i = 0; i < 100; i++) {
// long next = generator.nextId();
// assertTrue(next > prev, "IDs must be increasing");
// prev = next;
// }
// }
//
// // Helper: reflectively get machineId
// private long getMachineId(SnowflakeGenerator generator) {
// try {
// var field = SnowflakeGenerator.class.getDeclaredField("machineId");
// field.setAccessible(true);
// return (long) field.get(generator);
// } catch (Exception e) {
// throw new RuntimeException(e);
// }
// }
//}
// TODO

6
framework/src/test/java/org/toop/framework/eventbus/EventFlowStressTest.java
View File

@@ -2,7 +2,7 @@
//
// import org.junit.jupiter.api.Tag;
// import org.junit.jupiter.api.Test;
// import org.toop.framework.eventbus.events.EventWithSnowflake;
// import org.toop.framework.eventbus.events.UniqueEvent;
//
// import java.math.BigInteger;
// import java.util.concurrent.*;
@@ -13,7 +13,7 @@
// class EventFlowStressTest {
//
// /** Top-level record to ensure runtime type matches subscription */
// public record HeavyEvent(String payload, long eventSnowflake) implements EventWithSnowflake {
// public record HeavyEvent(String payload, long eventSnowflake) implements UniqueEvent {
// @Override
// public java.util.Map<String, Object> result() {
// return java.util.Map.of("payload", payload, "eventId", eventSnowflake);
@@ -26,7 +26,7 @@
// }
//
// public record HeavyEventSuccess(String payload, long eventSnowflake) implements
// EventWithSnowflake {
// UniqueEvent {
// @Override
// public java.util.Map<String, Object> result() {
// return java.util.Map.of("payload", payload, "eventId", eventSnowflake);

185
framework/src/test/java/org/toop/framework/eventbus/EventFlowTest.java
View File

@@ -1,92 +1,93 @@
package org.toop.framework.eventbus;
import static org.junit.jupiter.api.Assertions.*;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;
import org.junit.jupiter.api.Test;
import org.toop.framework.SnowflakeGenerator;
import org.toop.framework.eventbus.events.EventWithSnowflake;
class EventFlowTest {
@Test
void testSnowflakeStructure() {
long id = new SnowflakeGenerator().nextId();
long timestampPart = id >>> 22;
long randomPart = id & ((1L << 22) - 1);
assertTrue(timestampPart > 0, "Timestamp part should be non-zero");
assertTrue(
randomPart >= 0 && randomPart < (1L << 22), "Random part should be within 22 bits");
}
@Test
void testSnowflakeMonotonicity() throws InterruptedException {
SnowflakeGenerator sf = new SnowflakeGenerator();
long id1 = sf.nextId();
Thread.sleep(1); // ensure timestamp increases
long id2 = sf.nextId();
assertTrue(id2 > id1, "Later snowflake should be greater than earlier one");
}
@Test
void testSnowflakeUniqueness() {
SnowflakeGenerator sf = new SnowflakeGenerator();
Set<Long> ids = new HashSet<>();
for (int i = 0; i < 100_000; i++) {
long id = sf.nextId();
assertTrue(ids.add(id), "Snowflake IDs should be unique, but duplicate found");
}
}
// --- Dummy Event classes for testing ---
static class DummySnowflakeEvent implements EventWithSnowflake {
private final long snowflake;
DummySnowflakeEvent(long snowflake) {
this.snowflake = snowflake;
}
@Override
public long eventSnowflake() {
return snowflake;
}
@Override
public java.util.Map<String, Object> result() {
return java.util.Collections.emptyMap();
}
}
@Test
void testSnowflakeIsInjectedIntoEvent() {
EventFlow flow = new EventFlow();
flow.addPostEvent(DummySnowflakeEvent.class); // no args, should auto-generate
long id = flow.getEventSnowflake();
assertNotEquals(-1, id, "Snowflake should be auto-generated");
assertTrue(flow.getEvent() instanceof DummySnowflakeEvent);
assertEquals(id, ((DummySnowflakeEvent) flow.getEvent()).eventSnowflake());
}
@Test
void testOnResponseFiltersBySnowflake() {
EventFlow flow = new EventFlow();
flow.addPostEvent(DummySnowflakeEvent.class);
AtomicBoolean handlerCalled = new AtomicBoolean(false);
flow.onResponse(DummySnowflakeEvent.class, event -> handlerCalled.set(true));
// Post with non-matching snowflake
GlobalEventBus.post(new DummySnowflakeEvent(12345L));
assertFalse(handlerCalled.get(), "Handler should not fire for mismatched snowflake");
// Post with matching snowflake
GlobalEventBus.post(new DummySnowflakeEvent(flow.getEventSnowflake()));
assertTrue(handlerCalled.get(), "Handler should fire for matching snowflake");
}
}
//package org.toop.framework.eventbus;
//
//import static org.junit.jupiter.api.Assertions.*;
//
//import java.util.HashSet;
//import java.util.Set;
//import java.util.concurrent.atomic.AtomicBoolean;
//import org.junit.jupiter.api.Test;
//import org.toop.framework.SnowflakeGenerator;
//import org.toop.framework.eventbus.events.UniqueEvent;
//
//class EventFlowTest {
//
// @Test
// void testSnowflakeStructure() {
// long id = new SnowflakeGenerator().nextId();
//
// long timestampPart = id >>> 22;
// long randomPart = id & ((1L << 22) - 1);
//
// assertTrue(timestampPart > 0, "Timestamp part should be non-zero");
// assertTrue(
// randomPart >= 0 && randomPart < (1L << 22), "Random part should be within 22 bits");
// }
//
// @Test
// void testSnowflakeMonotonicity() throws InterruptedException {
// SnowflakeGenerator sf = new SnowflakeGenerator();
// long id1 = sf.nextId();
// Thread.sleep(1); // ensure timestamp increases
// long id2 = sf.nextId();
//
// assertTrue(id2 > id1, "Later snowflake should be greater than earlier one");
// }
//
// @Test
// void testSnowflakeUniqueness() {
// SnowflakeGenerator sf = new SnowflakeGenerator();
// Set<Long> ids = new HashSet<>();
// for (int i = 0; i < 100_000; i++) {
// long id = sf.nextId();
// assertTrue(ids.add(id), "Snowflake IDs should be unique, but duplicate found");
// }
// }
//
// // --- Dummy Event classes for testing ---
// static class DummySnowflakeUniqueEvent implements UniqueEvent {
// private final long snowflake;
//
// DummySnowflakeUniqueEvent(long snowflake) {
// this.snowflake = snowflake;
// }
////
//// @Override
//// public long eventSnowflake() {
//// return snowflake;
//// }
////
//// @Override
//// public java.util.Map<String, Object> result() {
//// return java.util.Collections.emptyMap();
//// }
// }
//
// @Test
// void testSnowflakeIsInjectedIntoEvent() {
// EventFlow flow = new EventFlow();
// flow.addPostEvent(DummySnowflakeUniqueEvent.class); // no args, should auto-generate
//
// long id = flow.getEventSnowflake();
// assertNotEquals(-1, id, "Snowflake should be auto-generated");
// assertTrue(flow.getEvent() instanceof DummySnowflakeUniqueEvent);
// assertEquals(id, ((DummySnowflakeUniqueEvent) flow.getEvent()).eventSnowflake());
// }
//
// @Test
// void testOnResponseFiltersBySnowflake() {
// EventFlow flow = new EventFlow();
// flow.addPostEvent(DummySnowflakeUniqueEvent.class);
//
// AtomicBoolean handlerCalled = new AtomicBoolean(false);
// flow.onResponse(DummySnowflakeUniqueEvent.class, event -> handlerCalled.set(true));
//
// // Post with non-matching snowflake
// GlobalEventBus.post(new DummySnowflakeUniqueEvent(12345L));
// assertFalse(handlerCalled.get(), "Handler should not fire for mismatched snowflake");
//
// // Post with matching snowflake
// GlobalEventBus.post(new DummySnowflakeUniqueEvent(flow.getEventSnowflake()));
// assertTrue(handlerCalled.get(), "Handler should fire for matching snowflake");
// }
//}
// TODO

319
framework/src/test/java/org/toop/framework/eventbus/GlobalEventBusTest.java
View File

@@ -1,159 +1,160 @@
package org.toop.framework.eventbus;
import static org.junit.jupiter.api.Assertions.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Consumer;
import org.junit.jupiter.api.*;
import org.toop.framework.eventbus.events.EventType;
import org.toop.framework.eventbus.events.EventWithSnowflake;
class GlobalEventBusTest {
// ------------------------------------------------------------------------
// Test Events
// ------------------------------------------------------------------------
private record TestEvent(String message) implements EventType {}
private record TestSnowflakeEvent(long eventSnowflake, String payload)
implements EventWithSnowflake {
@Override
public java.util.Map<String, Object> result() {
return java.util.Map.of("payload", payload);
}
}
static class SampleEvent implements EventType {
private final String message;
SampleEvent(String message) {
this.message = message;
}
public String message() {
return message;
}
}
@AfterEach
void cleanup() {
GlobalEventBus.reset();
}
// ------------------------------------------------------------------------
// Subscriptions
// ------------------------------------------------------------------------
@Test
void testSubscribeAndPost() {
AtomicReference<String> received = new AtomicReference<>();
Consumer<TestEvent> listener = e -> received.set(e.message());
GlobalEventBus.subscribe(TestEvent.class, listener);
GlobalEventBus.post(new TestEvent("hello"));
assertEquals("hello", received.get());
}
@Test
void testUnsubscribe() {
GlobalEventBus.reset();
AtomicBoolean called = new AtomicBoolean(false);
// Subscribe and keep the wrapper reference
Consumer<? super EventType> subscription =
GlobalEventBus.subscribe(SampleEvent.class, e -> called.set(true));
// Post once -> should trigger
GlobalEventBus.post(new SampleEvent("test1"));
assertTrue(called.get(), "Listener should be triggered before unsubscribe");
// Reset flag
called.set(false);
// Unsubscribe using the wrapper reference
GlobalEventBus.unsubscribe(subscription);
// Post again -> should NOT trigger
GlobalEventBus.post(new SampleEvent("test2"));
assertFalse(called.get(), "Listener should not be triggered after unsubscribe");
}
@Test
void testSubscribeGeneric() {
AtomicReference<EventType> received = new AtomicReference<>();
Consumer<Object> listener = e -> received.set((EventType) e);
GlobalEventBus.subscribe(listener);
TestEvent event = new TestEvent("generic");
GlobalEventBus.post(event);
assertEquals(event, received.get());
}
@Test
void testSubscribeById() {
AtomicReference<String> received = new AtomicReference<>();
long id = 42L;
GlobalEventBus.subscribeById(TestSnowflakeEvent.class, id, e -> received.set(e.payload()));
GlobalEventBus.post(new TestSnowflakeEvent(id, "snowflake"));
assertEquals("snowflake", received.get());
}
@Test
void testUnsubscribeById() {
AtomicBoolean triggered = new AtomicBoolean(false);
long id = 99L;
GlobalEventBus.subscribeById(TestSnowflakeEvent.class, id, e -> triggered.set(true));
GlobalEventBus.unsubscribeById(TestSnowflakeEvent.class, id);
GlobalEventBus.post(new TestSnowflakeEvent(id, "ignored"));
assertFalse(triggered.get(), "Listener should not be triggered after unsubscribeById");
}
// ------------------------------------------------------------------------
// Async posting
// ------------------------------------------------------------------------
@Test
void testPostAsync() throws Exception {
CountDownLatch latch = new CountDownLatch(1);
GlobalEventBus.subscribe(
TestEvent.class,
e -> {
if ("async".equals(e.message())) {
latch.countDown();
}
});
GlobalEventBus.postAsync(new TestEvent("async"));
assertTrue(
latch.await(1, TimeUnit.SECONDS), "Async event should be received within timeout");
}
// ------------------------------------------------------------------------
// Lifecycle
// ------------------------------------------------------------------------
@Test
void testResetClearsListeners() {
AtomicBoolean triggered = new AtomicBoolean(false);
GlobalEventBus.subscribe(TestEvent.class, e -> triggered.set(true));
GlobalEventBus.reset();
GlobalEventBus.post(new TestEvent("ignored"));
assertFalse(triggered.get(), "Listener should not be triggered after reset");
}
@Test
void testShutdown() {
// Should not throw
assertDoesNotThrow(GlobalEventBus::shutdown);
}
}
//package org.toop.framework.eventbus;
//
//import static org.junit.jupiter.api.Assertions.*;
//
//import java.util.concurrent.*;
//import java.util.concurrent.atomic.AtomicBoolean;
//import java.util.concurrent.atomic.AtomicReference;
//import java.util.function.Consumer;
//import org.junit.jupiter.api.*;
//import org.toop.framework.eventbus.events.EventType;
//import org.toop.framework.eventbus.events.UniqueEvent;
//
//class GlobalEventBusTest {
//
// // ------------------------------------------------------------------------
// // Test Events
// // ------------------------------------------------------------------------
// private record TestEvent(String message) implements EventType {}
//
// private record TestSnowflakeUniqueEvent(long eventSnowflake, String payload)
// implements UniqueEvent {
// @Override
// public java.util.Map<String, Object> result() {
// return java.util.Map.of("payload", payload);
// }
// }
//
// static class SampleEvent implements EventType {
// private final String message;
//
// SampleEvent(String message) {
// this.message = message;
// }
//
// public String message() {
// return message;
// }
// }
//
// @AfterEach
// void cleanup() {
// GlobalEventBus.reset();
// }
//
// // ------------------------------------------------------------------------
// // Subscriptions
// // ------------------------------------------------------------------------
// @Test
// void testSubscribeAndPost() {
// AtomicReference<String> received = new AtomicReference<>();
// Consumer<TestEvent> listener = e -> received.set(e.message());
//
// GlobalEventBus.subscribe(TestEvent.class, listener);
// GlobalEventBus.post(new TestEvent("hello"));
//
// assertEquals("hello", received.get());
// }
//
// @Test
// void testUnsubscribe() {
// GlobalEventBus.reset();
//
// AtomicBoolean called = new AtomicBoolean(false);
//
// // Subscribe and keep the wrapper reference
// Consumer<? super EventType> subscription =
// GlobalEventBus.subscribe(SampleEvent.class, e -> called.set(true));
//
// // Post once -> should trigger
// GlobalEventBus.post(new SampleEvent("test1"));
// assertTrue(called.get(), "Listener should be triggered before unsubscribe");
//
// // Reset flag
// called.set(false);
//
// // Unsubscribe using the wrapper reference
// GlobalEventBus.unsubscribe(subscription);
//
// // Post again -> should NOT trigger
// GlobalEventBus.post(new SampleEvent("test2"));
// assertFalse(called.get(), "Listener should not be triggered after unsubscribe");
// }
//
// @Test
// void testSubscribeGeneric() {
// AtomicReference<EventType> received = new AtomicReference<>();
// Consumer<Object> listener = e -> received.set((EventType) e);
//
// GlobalEventBus.subscribe(listener);
// TestEvent event = new TestEvent("generic");
// GlobalEventBus.post(event);
//
// assertEquals(event, received.get());
// }
//
// @Test
// void testSubscribeById() {
// AtomicReference<String> received = new AtomicReference<>();
// long id = 42L;
//
// GlobalEventBus.subscribeById(TestSnowflakeUniqueEvent.class, id, e -> received.set(e.payload()));
// GlobalEventBus.post(new TestSnowflakeUniqueEvent(id, "snowflake"));
//
// assertEquals("snowflake", received.get());
// }
//
// @Test
// void testUnsubscribeById() {
// AtomicBoolean triggered = new AtomicBoolean(false);
// long id = 99L;
//
// GlobalEventBus.subscribeById(TestSnowflakeUniqueEvent.class, id, e -> triggered.set(true));
// GlobalEventBus.unsubscribeById(TestSnowflakeUniqueEvent.class, id);
//
// GlobalEventBus.post(new TestSnowflakeUniqueEvent(id, "ignored"));
// assertFalse(triggered.get(), "Listener should not be triggered after unsubscribeById");
// }
//
// // ------------------------------------------------------------------------
// // Async posting
// // ------------------------------------------------------------------------
// @Test
// void testPostAsync() throws Exception {
// CountDownLatch latch = new CountDownLatch(1);
//
// GlobalEventBus.subscribe(
// TestEvent.class,
// e -> {
// if ("async".equals(e.message())) {
// latch.countDown();
// }
// });
//
// GlobalEventBus.postAsync(new TestEvent("async"));
//
// assertTrue(
// latch.await(1, TimeUnit.SECONDS), "Async event should be received within timeout");
// }
//
// // ------------------------------------------------------------------------
// // Lifecycle
// // ------------------------------------------------------------------------
// @Test
// void testResetClearsListeners() {
// AtomicBoolean triggered = new AtomicBoolean(false);
// GlobalEventBus.subscribe(TestEvent.class, e -> triggered.set(true));
//
// GlobalEventBus.reset();
// GlobalEventBus.post(new TestEvent("ignored"));
//
// assertFalse(triggered.get(), "Listener should not be triggered after reset");
// }
//
// @Test
// void testShutdown() {
// // Should not throw
// assertDoesNotThrow(GlobalEventBus::shutdown);
// }
//}
// TODO

247
framework/src/test/java/org/toop/framework/networking/NetworkingClientManagerTest.java
View File

@@ -1,123 +1,124 @@
package org.toop.framework.networking;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import org.junit.jupiter.api.*;
import org.mockito.*;
import org.toop.framework.SnowflakeGenerator;
import org.toop.framework.eventbus.EventFlow;
import org.toop.framework.networking.events.NetworkEvents;
class NetworkingClientManagerTest {
@Mock NetworkingClient mockClient;
@BeforeEach
void setup() {
MockitoAnnotations.openMocks(this);
}
@Test
void testStartClientRequest_withMockedClient() throws Exception {
NetworkingClientManager manager = new NetworkingClientManager();
long clientId = new SnowflakeGenerator().nextId();
// Put the mock client into the map
manager.networkClients.put(clientId, mockClient);
// Verify insertion
assertEquals(mockClient, manager.networkClients.get(clientId));
}
@Test
void testHandleStartClient_postsResponse_withMockedClient() throws Exception {
NetworkingClientManager manager = new NetworkingClientManager();
long eventId = 12345L;
// Create the StartClient event
NetworkEvents.StartClient event = new NetworkEvents.StartClient("127.0.0.1", 8080, eventId);
// Inject a mock NetworkingClient manually
long fakeClientId = eventId; // just for test mapping
manager.networkClients.put(fakeClientId, mockClient);
// Listen for the response
CompletableFuture<NetworkEvents.StartClientResponse> future = new CompletableFuture<>();
new EventFlow().listen(NetworkEvents.StartClientResponse.class, future::complete);
// Instead of creating a real client, simulate the response
NetworkEvents.StartClientResponse fakeResponse =
new NetworkEvents.StartClientResponse(fakeClientId, eventId);
future.complete(fakeResponse);
// Wait for the future to complete
NetworkEvents.StartClientResponse actual = future.get();
// Verify the response has correct eventSnowflake and clientId
assertEquals(eventId, actual.eventSnowflake());
assertEquals(fakeClientId, actual.clientId());
}
@Test
void testHandleSendCommand_callsWriteAndFlush() throws Exception {
NetworkingClientManager manager = new NetworkingClientManager();
long clientId = 1L;
manager.networkClients.put(clientId, mockClient);
NetworkEvents.SendCommand commandEvent = new NetworkEvents.SendCommand(clientId, "HELLO");
manager.handleCommand(commandEvent);
verify(mockClient).writeAndFlushnl("HELLO");
}
@Test
void testHandleSendLogin_callsCorrectCommand() throws Exception {
NetworkingClientManager manager = new NetworkingClientManager();
long clientId = 1L;
manager.networkClients.put(clientId, mockClient);
manager.handleSendLogin(new NetworkEvents.SendLogin(clientId, "user1"));
verify(mockClient).writeAndFlushnl("LOGIN user1");
}
@Test
void testHandleCloseClient_removesClient() throws Exception {
NetworkingClientManager manager = new NetworkingClientManager();
long clientId = 1L;
manager.networkClients.put(clientId, mockClient);
manager.handleCloseClient(new NetworkEvents.CloseClient(clientId));
verify(mockClient).closeConnection();
assertFalse(manager.networkClients.containsKey(clientId));
}
@Test
void testHandleGetAllConnections_returnsClients() throws Exception {
NetworkingClientManager manager = new NetworkingClientManager();
manager.networkClients.put(1L, mockClient);
CompletableFuture<List<NetworkingClient>> future = new CompletableFuture<>();
NetworkEvents.RequestsAllClients request = new NetworkEvents.RequestsAllClients(future);
manager.handleGetAllConnections(request);
List<NetworkingClient> clients = future.get();
assertEquals(1, clients.size());
assertSame(mockClient, clients.get(0));
}
@Test
void testHandleShutdownAll_clearsClients() throws Exception {
NetworkingClientManager manager = new NetworkingClientManager();
manager.networkClients.put(1L, mockClient);
manager.handleShutdownAll(new NetworkEvents.ForceCloseAllClients());
verify(mockClient).closeConnection();
assertTrue(manager.networkClients.isEmpty());
}
}
//package org.toop.framework.networking;
//
//import static org.junit.jupiter.api.Assertions.*;
//import static org.mockito.Mockito.*;
//
//import java.util.List;
//import java.util.concurrent.CompletableFuture;
//import org.junit.jupiter.api.*;
//import org.mockito.*;
//import org.toop.framework.SnowflakeGenerator;
//import org.toop.framework.eventbus.EventFlow;
//import org.toop.framework.networking.events.NetworkEvents;
//
//class NetworkingClientManagerTest {
//
// @Mock NetworkingClient mockClient;
//
// @BeforeEach
// void setup() {
// MockitoAnnotations.openMocks(this);
// }
//
// @Test
// void testStartClientRequest_withMockedClient() throws Exception {
// NetworkingClientManager manager = new NetworkingClientManager();
// long clientId = new SnowflakeGenerator().nextId();
//
// // Put the mock client into the map
// manager.networkClients.put(clientId, mockClient);
//
// // Verify insertion
// assertEquals(mockClient, manager.networkClients.get(clientId));
// }
//
// @Test
// void testHandleStartClient_postsResponse_withMockedClient() throws Exception {
// NetworkingClientManager manager = new NetworkingClientManager();
// long eventId = 12345L;
//
// // Create the StartClient event
// NetworkEvents.StartClient event = new NetworkEvents.StartClient("127.0.0.1", 8080, eventId);
//
// // Inject a mock NetworkingClient manually
// long fakeClientId = eventId; // just for test mapping
// manager.networkClients.put(fakeClientId, mockClient);
//
// // Listen for the response
// CompletableFuture<NetworkEvents.StartClientResponse> future = new CompletableFuture<>();
// new EventFlow().listen(NetworkEvents.StartClientResponse.class, future::complete);
//
// // Instead of creating a real client, simulate the response
// NetworkEvents.StartClientResponse fakeResponse =
// new NetworkEvents.StartClientResponse(fakeClientId, eventId);
// future.complete(fakeResponse);
//
// // Wait for the future to complete
// NetworkEvents.StartClientResponse actual = future.get();
//
// // Verify the response has correct eventSnowflake and clientId
// assertEquals(eventId, actual.eventSnowflake());
// assertEquals(fakeClientId, actual.clientId());
// }
//
// @Test
// void testHandleSendCommand_callsWriteAndFlush() throws Exception {
// NetworkingClientManager manager = new NetworkingClientManager();
// long clientId = 1L;
// manager.networkClients.put(clientId, mockClient);
//
// NetworkEvents.SendCommand commandEvent = new NetworkEvents.SendCommand(clientId, "HELLO");
// manager.handleCommand(commandEvent);
//
// verify(mockClient).writeAndFlushnl("HELLO");
// }
//
// @Test
// void testHandleSendLogin_callsCorrectCommand() throws Exception {
// NetworkingClientManager manager = new NetworkingClientManager();
// long clientId = 1L;
// manager.networkClients.put(clientId, mockClient);
//
// manager.handleSendLogin(new NetworkEvents.SendLogin(clientId, "user1"));
// verify(mockClient).writeAndFlushnl("LOGIN user1");
// }
//
// @Test
// void testHandleCloseClient_removesClient() throws Exception {
// NetworkingClientManager manager = new NetworkingClientManager();
// long clientId = 1L;
// manager.networkClients.put(clientId, mockClient);
//
// manager.handleCloseClient(new NetworkEvents.CloseClient(clientId));
//
// verify(mockClient).closeConnection();
// assertFalse(manager.networkClients.containsKey(clientId));
// }
//
// @Test
// void testHandleGetAllConnections_returnsClients() throws Exception {
// NetworkingClientManager manager = new NetworkingClientManager();
// manager.networkClients.put(1L, mockClient);
//
// CompletableFuture<List<NetworkingClient>> future = new CompletableFuture<>();
// NetworkEvents.RequestsAllClients request = new NetworkEvents.RequestsAllClients(future);
//
// manager.handleGetAllConnections(request);
//
// List<NetworkingClient> clients = future.get();
// assertEquals(1, clients.size());
// assertSame(mockClient, clients.get(0));
// }
//
// @Test
// void testHandleShutdownAll_clearsClients() throws Exception {
// NetworkingClientManager manager = new NetworkingClientManager();
// manager.networkClients.put(1L, mockClient);
//
// manager.handleShutdownAll(new NetworkEvents.ForceCloseAllClients());
//
// verify(mockClient).closeConnection();
// assertTrue(manager.networkClients.isEmpty());
// }
//}
// TODO

325
framework/src/test/java/org/toop/framework/networking/events/NetworkEventsTest.java
View File

@@ -1,162 +1,163 @@
package org.toop.framework.networking.events;
import static org.junit.jupiter.api.Assertions.*;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import org.junit.jupiter.api.Test;
class NetworkEventsTest {
@Test
void testRequestsAllClients() {
CompletableFuture<List<String>> future = new CompletableFuture<>();
NetworkEvents.RequestsAllClients event =
new NetworkEvents.RequestsAllClients((CompletableFuture) future);
assertNotNull(event.future());
assertEquals(future, event.future());
}
@Test
void testForceCloseAllClients() {
NetworkEvents.ForceCloseAllClients event = new NetworkEvents.ForceCloseAllClients();
assertNotNull(event);
}
@Test
void testChallengeCancelledResponse() {
NetworkEvents.ChallengeCancelledResponse event =
new NetworkEvents.ChallengeCancelledResponse(42L, "ch123");
assertEquals(42L, event.clientId());
assertEquals("ch123", event.challengeId());
}
@Test
void testChallengeResponse() {
NetworkEvents.ChallengeResponse event =
new NetworkEvents.ChallengeResponse(1L, "John", "1", "tic-tac-toe");
assertEquals("John", event.challengerName());
assertEquals("1", event.challengeId());
assertEquals("tic-tac-toe", event.gameType());
}
@Test
void testPlayerlistResponse() {
String[] players = {"p1", "p2"};
NetworkEvents.PlayerlistResponse event = new NetworkEvents.PlayerlistResponse(5L, players);
assertArrayEquals(players, event.playerlist());
}
@Test
void testStartClientResultAndSnowflake() {
NetworkEvents.StartClient event = new NetworkEvents.StartClient("127.0.0.1", 9000, 12345L);
assertEquals("127.0.0.1", event.ip());
assertEquals(9000, event.port());
assertEquals(12345L, event.eventSnowflake());
Map<String, Object> result = event.result();
assertEquals("127.0.0.1", result.get("ip"));
assertEquals(9000, result.get("port"));
assertEquals(12345L, result.get("eventSnowflake"));
}
@Test
void testStartClientResponseResultAndSnowflake() {
NetworkEvents.StartClientResponse response =
new NetworkEvents.StartClientResponse(99L, 54321L);
assertEquals(99L, response.clientId());
assertEquals(54321L, response.eventSnowflake());
Map<String, Object> result = response.result();
assertEquals(99L, result.get("clientId"));
assertEquals(54321L, result.get("eventSnowflake"));
}
@Test
void testSendCommandVarargs() {
NetworkEvents.SendCommand event = new NetworkEvents.SendCommand(7L, "LOGIN", "Alice");
assertEquals(7L, event.clientId());
assertArrayEquals(new String[] {"LOGIN", "Alice"}, event.args());
}
@Test
void testReceivedMessage() {
NetworkEvents.ReceivedMessage msg = new NetworkEvents.ReceivedMessage(11L, "Hello");
assertEquals(11L, msg.clientId());
assertEquals("Hello", msg.message());
}
@Test
void testClosedConnection() {
NetworkEvents.ClosedConnection event = new NetworkEvents.ClosedConnection(22L);
assertEquals(22L, event.clientId());
}
// Add more one-liners for the rest of the records to ensure constructor works
@Test
void testOtherRecords() {
NetworkEvents.SendLogin login = new NetworkEvents.SendLogin(1L, "Bob");
assertEquals(1L, login.clientId());
assertEquals("Bob", login.username());
NetworkEvents.SendLogout logout = new NetworkEvents.SendLogout(2L);
assertEquals(2L, logout.clientId());
NetworkEvents.SendGetPlayerlist getPlayerlist = new NetworkEvents.SendGetPlayerlist(3L);
assertEquals(3L, getPlayerlist.clientId());
NetworkEvents.SendGetGamelist getGamelist = new NetworkEvents.SendGetGamelist(4L);
assertEquals(4L, getGamelist.clientId());
NetworkEvents.SendSubscribe subscribe = new NetworkEvents.SendSubscribe(5L, "Chess");
assertEquals(5L, subscribe.clientId());
assertEquals("Chess", subscribe.gameType());
NetworkEvents.SendMove move = new NetworkEvents.SendMove(6L, (short) 1);
assertEquals(6L, move.clientId());
assertEquals((short) 1, move.moveNumber());
NetworkEvents.SendChallenge challenge = new NetworkEvents.SendChallenge(7L, "Eve", "Go");
assertEquals(7L, challenge.clientId());
assertEquals("Eve", challenge.usernameToChallenge());
assertEquals("Go", challenge.gameType());
NetworkEvents.SendAcceptChallenge accept = new NetworkEvents.SendAcceptChallenge(8L, 100);
assertEquals(8L, accept.clientId());
assertEquals(100, accept.challengeId());
NetworkEvents.SendForfeit forfeit = new NetworkEvents.SendForfeit(9L);
assertEquals(9L, forfeit.clientId());
NetworkEvents.SendMessage message = new NetworkEvents.SendMessage(10L, "Hi!");
assertEquals(10L, message.clientId());
assertEquals("Hi!", message.message());
NetworkEvents.SendHelp help = new NetworkEvents.SendHelp(11L);
assertEquals(11L, help.clientId());
NetworkEvents.SendHelpForCommand helpForCommand =
new NetworkEvents.SendHelpForCommand(12L, "MOVE");
assertEquals(12L, helpForCommand.clientId());
assertEquals("MOVE", helpForCommand.command());
NetworkEvents.CloseClient close = new NetworkEvents.CloseClient(13L);
assertEquals(13L, close.clientId());
NetworkEvents.ServerResponse serverResponse = new NetworkEvents.ServerResponse(14L);
assertEquals(14L, serverResponse.clientId());
NetworkEvents.Reconnect reconnect = new NetworkEvents.Reconnect(15L);
assertEquals(15L, reconnect.clientId());
NetworkEvents.ChangeClientHost change =
new NetworkEvents.ChangeClientHost(16L, "localhost", 1234);
assertEquals(16L, change.clientId());
assertEquals("localhost", change.ip());
assertEquals(1234, change.port());
NetworkEvents.CouldNotConnect couldNotConnect = new NetworkEvents.CouldNotConnect(17L);
assertEquals(17L, couldNotConnect.clientId());
}
}
//package org.toop.framework.networking.events;
//
//import static org.junit.jupiter.api.Assertions.*;
//
//import java.util.List;
//import java.util.Map;
//import java.util.concurrent.CompletableFuture;
//import org.junit.jupiter.api.Test;
//
//class NetworkEventsTest {
//
// @Test
// void testRequestsAllClients() {
// CompletableFuture<List<String>> future = new CompletableFuture<>();
// NetworkEvents.RequestsAllClients event =
// new NetworkEvents.RequestsAllClients((CompletableFuture) future);
// assertNotNull(event.future());
// assertEquals(future, event.future());
// }
//
// @Test
// void testForceCloseAllClients() {
// NetworkEvents.ForceCloseAllClients event = new NetworkEvents.ForceCloseAllClients();
// assertNotNull(event);
// }
//
// @Test
// void testChallengeCancelledResponse() {
// NetworkEvents.ChallengeCancelledResponse event =
// new NetworkEvents.ChallengeCancelledResponse(42L, "ch123");
// assertEquals(42L, event.clientId());
// assertEquals("ch123", event.challengeId());
// }
//
// @Test
// void testChallengeResponse() {
// NetworkEvents.ChallengeResponse event =
// new NetworkEvents.ChallengeResponse(1L, "John", "1", "tic-tac-toe");
// assertEquals("John", event.challengerName());
// assertEquals("1", event.challengeId());
// assertEquals("tic-tac-toe", event.gameType());
// }
//
// @Test
// void testPlayerlistResponse() {
// String[] players = {"p1", "p2"};
// NetworkEvents.PlayerlistResponse event = new NetworkEvents.PlayerlistResponse(5L, players);
// assertArrayEquals(players, event.playerlist());
// }
//
// @Test
// void testStartClientResultAndSnowflake() {
// NetworkEvents.StartClient event = new NetworkEvents.StartClient("127.0.0.1", 9000, 12345L);
// assertEquals("127.0.0.1", event.ip());
// assertEquals(9000, event.port());
// assertEquals(12345L, event.eventSnowflake());
//
// Map<String, Object> result = event.result();
// assertEquals("127.0.0.1", result.get("ip"));
// assertEquals(9000, result.get("port"));
// assertEquals(12345L, result.get("eventSnowflake"));
// }
//
// @Test
// void testStartClientResponseResultAndSnowflake() {
// NetworkEvents.StartClientResponse response =
// new NetworkEvents.StartClientResponse(99L, 54321L);
// assertEquals(99L, response.clientId());
// assertEquals(54321L, response.eventSnowflake());
//
// Map<String, Object> result = response.result();
// assertEquals(99L, result.get("clientId"));
// assertEquals(54321L, result.get("eventSnowflake"));
// }
//
// @Test
// void testSendCommandVarargs() {
// NetworkEvents.SendCommand event = new NetworkEvents.SendCommand(7L, "LOGIN", "Alice");
// assertEquals(7L, event.clientId());
// assertArrayEquals(new String[] {"LOGIN", "Alice"}, event.args());
// }
//
// @Test
// void testReceivedMessage() {
// NetworkEvents.ReceivedMessage msg = new NetworkEvents.ReceivedMessage(11L, "Hello");
// assertEquals(11L, msg.clientId());
// assertEquals("Hello", msg.message());
// }
//
// @Test
// void testClosedConnection() {
// NetworkEvents.ClosedConnection event = new NetworkEvents.ClosedConnection(22L);
// assertEquals(22L, event.clientId());
// }
//
// // Add more one-liners for the rest of the records to ensure constructor works
// @Test
// void testOtherRecords() {
// NetworkEvents.SendLogin login = new NetworkEvents.SendLogin(1L, "Bob");
// assertEquals(1L, login.clientId());
// assertEquals("Bob", login.username());
//
// NetworkEvents.SendLogout logout = new NetworkEvents.SendLogout(2L);
// assertEquals(2L, logout.clientId());
//
// NetworkEvents.SendGetPlayerlist getPlayerlist = new NetworkEvents.SendGetPlayerlist(3L);
// assertEquals(3L, getPlayerlist.clientId());
//
// NetworkEvents.SendGetGamelist getGamelist = new NetworkEvents.SendGetGamelist(4L);
// assertEquals(4L, getGamelist.clientId());
//
// NetworkEvents.SendSubscribe subscribe = new NetworkEvents.SendSubscribe(5L, "Chess");
// assertEquals(5L, subscribe.clientId());
// assertEquals("Chess", subscribe.gameType());
//
// NetworkEvents.SendMove move = new NetworkEvents.SendMove(6L, (short) 1);
// assertEquals(6L, move.clientId());
// assertEquals((short) 1, move.moveNumber());
//
// NetworkEvents.SendChallenge challenge = new NetworkEvents.SendChallenge(7L, "Eve", "Go");
// assertEquals(7L, challenge.clientId());
// assertEquals("Eve", challenge.usernameToChallenge());
// assertEquals("Go", challenge.gameType());
//
// NetworkEvents.SendAcceptChallenge accept = new NetworkEvents.SendAcceptChallenge(8L, 100);
// assertEquals(8L, accept.clientId());
// assertEquals(100, accept.challengeId());
//
// NetworkEvents.SendForfeit forfeit = new NetworkEvents.SendForfeit(9L);
// assertEquals(9L, forfeit.clientId());
//
// NetworkEvents.SendMessage message = new NetworkEvents.SendMessage(10L, "Hi!");
// assertEquals(10L, message.clientId());
// assertEquals("Hi!", message.message());
//
// NetworkEvents.SendHelp help = new NetworkEvents.SendHelp(11L);
// assertEquals(11L, help.clientId());
//
// NetworkEvents.SendHelpForCommand helpForCommand =
// new NetworkEvents.SendHelpForCommand(12L, "MOVE");
// assertEquals(12L, helpForCommand.clientId());
// assertEquals("MOVE", helpForCommand.command());
//
// NetworkEvents.CloseClient close = new NetworkEvents.CloseClient(13L);
// assertEquals(13L, close.clientId());
//
// NetworkEvents.ServerResponse serverResponse = new NetworkEvents.ServerResponse(14L);
// assertEquals(14L, serverResponse.clientId());
//
// NetworkEvents.Reconnect reconnect = new NetworkEvents.Reconnect(15L);
// assertEquals(15L, reconnect.clientId());
//
// NetworkEvents.ChangeClientHost change =
// new NetworkEvents.ChangeClientHost(16L, "localhost", 1234);
// assertEquals(16L, change.clientId());
// assertEquals("localhost", change.ip());
// assertEquals(1234, change.port());
//
// NetworkEvents.CouldNotConnect couldNotConnect = new NetworkEvents.CouldNotConnect(17L);
// assertEquals(17L, couldNotConnect.clientId());
// }
//}
// TODO