Files
purpur-fantasy-stick/src/nativeTest/java/games/dmg/fantasystick/FantasyParticlesNativeTest.java
T
dmg 39c58ef4d9
Release / release (push) Successful in 14m40s
feat(events): audit account aura preferences
2026-09-25 09:37:45 -04:00

807 lines
55 KiB
Java

package games.dmg.fantasystick;
import static org.junit.jupiter.api.Assertions.*;
import java.nio.file.Path;
import java.util.List;
import org.bukkit.Color;
import org.bukkit.Particle;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
/** Registered account command through the real recurring active-session aura pulse. */
class FantasyParticlesNativeTest {
@TempDir Path data;
@BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
@Test void registeredPlayersRouteDefaultsOffPersistsAndRejectsInvalidSendersAndArguments() throws Exception {
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
assertNotNull(fixture.particlesCommand);
var player = new FantasyStickLifecycleNativeTest.Actor(data);
fixture.players.put(player.core.id, player.player);
assertTrue(fixture.particlesCommand.execute(player.player, "fantasyparticles",
new String[]{"players"}));
assertEquals("Active-character aura particles are off.", player.messages.getLast());
assertTrue(fixture.particlesCommand.execute(player.player, "fantasyparticles",
new String[]{"all"}));
assertEquals("All Fantasy Stick particles are on.", player.messages.getLast());
assertEquals(List.of("all", "players"), fixture.particlesCommand.tabComplete(
player.player, "fantasyparticles", new String[]{""}));
assertEquals(List.of("off", "on"), fixture.particlesCommand.tabComplete(
player.player, "fantasyparticles", new String[]{"players", ""}));
assertEquals(List.of("off"), fixture.particlesCommand.tabComplete(
player.player, "fantasyparticles", new String[]{"players", "of"}));
assertEquals(List.of("on"), fixture.particlesCommand.tabComplete(
player.player, "fantasyparticles", new String[]{"players", "on"}));
assertFalse(java.nio.file.Files.exists(data.resolve("player-preferences.yml")),
"Status and completion perform no persistence write");
assertTrue(player.particleCalls.isEmpty(), "Status and completion emit no particles");
int before = player.messages.size();
assertTrue(fixture.particlesCommand.execute(player.player, "fantasyparticles",
new String[]{"players", "on"}));
assertEquals(before, player.messages.size(), "Persistence must complete before acknowledgement");
fixture.tick();
assertEquals("Active-character aura particles are now on.", player.messages.getLast());
fixture.particlesCommand.execute(player.player, "fantasyparticles",
new String[]{"all", "off"}); fixture.tick();
assertEquals("All Fantasy Stick particles are now off.", player.messages.getLast());
fixture.particlesCommand.execute(player.player, "fantasyparticles", new String[]{"players"});
assertEquals("Active-character aura particles are on (effectively off while all particles are off).",
player.messages.getLast());
fixture.particlesCommand.execute(player.player, "fantasyparticles",
new String[]{"all", "on"}); fixture.tick();
assertEquals("All Fantasy Stick particles are now on.", player.messages.getLast());
var console = new EquipmentAdminCommandNativeTest.Sender();
assertTrue(fixture.particlesCommand.execute(console.port, "fantasyparticles",
new String[]{"players", "off"}));
assertTrue(console.messages.getLast().contains("player-account"));
assertTrue(fixture.particlesCommand.tabComplete(console.port, "fantasyparticles",
new String[]{""}).isEmpty());
for (String[] invalid : List.of(new String[]{}, new String[]{"unknown"},
new String[]{"players", "ON"}, new String[]{"all", "ON"},
new String[]{"players", "on", "extra"}, new String[]{"all", "off", "extra"})) {
var routed = java.util.stream.Stream.concat(java.util.stream.Stream.of("particles"),
java.util.Arrays.stream(invalid)).toArray(String[]::new);
assertFalse(fixture.playerCommand.getExecutor().onCommand(player.player,
fixture.playerCommand, "fstick", routed));
}
fixture.particlesCommand.execute(player.player, "fantasyparticles",
new String[]{"all", "off"}); fixture.tick();
var other = new FantasyStickLifecycleNativeTest.Actor(data);
fixture.players.put(other.core.id, other.player);
var playerSheet = player.core.inventory.getItemInOffHand();
player.core.inventory.setItemInOffHand(other.core.inventory.getItemInOffHand());
other.core.inventory.setItemInOffHand(playerSheet);
fixture.particlesCommand.execute(player.player, "fantasyparticles", new String[]{"players"});
assertEquals("Active-character aura particles are on (effectively off while all particles are off).",
player.messages.getLast(), "The preference stays with the account after character-sheet switching");
fixture.particlesCommand.execute(player.player, "fantasyparticles", new String[]{"all"});
assertEquals("All Fantasy Stick particles are off.", player.messages.getLast());
fixture.particlesCommand.execute(other.player, "fantasyparticles", new String[]{"players"});
assertEquals("Active-character aura particles are off.", other.messages.getLast(),
"A transferred character does not transfer its prior holder's preference");
fixture.particlesCommand.execute(other.player, "fantasyparticles", new String[]{"all"});
assertEquals("All Fantasy Stick particles are on.", other.messages.getLast(),
"A transferred character does not transfer its prior holder's all-particle preference");
fixture.plugin.setEnabled(false);
fixture.plugin.setEnabled(true);
fixture.particlesCommand.execute(player.player, "fantasyparticles", new String[]{"players"});
assertEquals("Active-character aura particles are on (effectively off while all particles are off).",
player.messages.getLast());
fixture.particlesCommand.execute(player.player, "fantasyparticles", new String[]{"all"});
assertEquals("All Fantasy Stick particles are off.", player.messages.getLast());
}
}
@Test void reversedCompetingCommandCallbacksCannotPublishStaleAuraState() throws Exception {
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
var player = new FantasyStickLifecycleNativeTest.Actor(data);
fixture.players.put(player.core.id, player.player);
fixture.particlesCommand.execute(player.player, "fantasyparticles",
new String[]{"players", "on"});
fixture.particlesCommand.execute(player.player, "fantasyparticles",
new String[]{"players", "off"});
var preferences = (games.dmg.fantasystick.persistence.PlayerFeedbackPreferences)
FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "feedbackPreferences");
preferences.setPlayerAuras(java.util.UUID.randomUUID(), false).toCompletableFuture()
.get(5, java.util.concurrent.TimeUnit.SECONDS);
var callbacks = new java.util.ArrayList<Runnable>();
fixture.tasks.drainTo(callbacks);
assertEquals(2, callbacks.size());
java.util.Collections.reverse(callbacks); callbacks.forEach(Runnable::run);
assertFalse(preferences.playerAurasEnabled(player.core.id));
fixture.particlesCommand.execute(player.player, "fantasyparticles", new String[]{"players"});
assertEquals("Active-character aura particles are off.", player.messages.getLast());
fixture.particlesCommand.execute(player.player, "fantasyparticles", new String[]{"all", "off"});
fixture.particlesCommand.execute(player.player, "fantasyparticles", new String[]{"all", "on"});
preferences.setAllParticles(java.util.UUID.randomUUID(), true).toCompletableFuture()
.get(5, java.util.concurrent.TimeUnit.SECONDS);
callbacks.clear(); fixture.tasks.drainTo(callbacks);
assertEquals(2, callbacks.size());
java.util.Collections.reverse(callbacks); callbacks.forEach(Runnable::run);
assertTrue(preferences.allParticlesEnabled(player.core.id));
fixture.particlesCommand.execute(player.player, "fantasyparticles", new String[]{"all"});
assertEquals("All Fantasy Stick particles are on.", player.messages.getLast());
}
}
@Test void failedAuraPreferenceSaveKeepsPriorEffectiveStateAndReportsRefusal() throws Exception {
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
var player = new FantasyStickLifecycleNativeTest.Actor(data);
fixture.players.put(player.core.id, player.player);
java.nio.file.Files.createDirectory(data.resolve("player-preferences.yml"));
fixture.particlesCommand.execute(player.player, "fantasyparticles",
new String[]{"players", "on"});
fixture.tick();
assertTrue(player.messages.getLast().contains("could not be saved"));
fixture.particlesCommand.execute(player.player, "fantasyparticles", new String[]{"players"});
assertEquals("Active-character aura particles are off.", player.messages.getLast());
fixture.particlesCommand.execute(player.player, "fantasyparticles",
new String[]{"all", "off"});
fixture.tick();
assertTrue(player.messages.getLast().contains("could not be saved"));
fixture.particlesCommand.execute(player.player, "fantasyparticles", new String[]{"all"});
assertEquals("All Fantasy Stick particles are on.", player.messages.getLast());
}
}
@Test void allPreferenceFiltersSharedWorldAndExplicitDeliveryWithoutExpandingNativeBounds() throws Exception {
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
var enabled = new FantasyStickLifecycleNativeTest.Actor(data); enabled.accountName = "Enabled";
var enabledPeer = new FantasyStickLifecycleNativeTest.Actor(data); enabledPeer.accountName = "EnabledPeer";
var disabled = new FantasyStickLifecycleNativeTest.Actor(data); disabled.accountName = "Disabled";
var far = new FantasyStickLifecycleNativeTest.Actor(data); far.accountName = "Far";
var crossWorld = new FantasyStickLifecycleNativeTest.Actor(data); crossWorld.accountName = "CrossWorld";
enabledPeer.core.location.setWorld(enabled.world);
disabled.core.location.setWorld(enabled.world);
far.core.location.setWorld(enabled.world); far.core.location.add(40, 0, 0);
for (var actor : List.of(enabled, enabledPeer, disabled, far, crossWorld)) {
actor.core.inventory.setItemInOffHand(null); fixture.players.put(actor.core.id, actor.player);
}
fixture.particlesCommand.execute(disabled.player, "fantasyparticles", new String[]{"all", "off"});
fixture.tick(); clear(enabled, enabledPeer, disabled, far, crossWorld);
var delivery = (games.dmg.fantasystick.presentation.ParticleDelivery)
FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "particleDelivery");
var origin = enabled.player.getLocation();
var dust = new Particle.DustOptions(Color.RED, 1.5f);
delivery.world(Particle.DUST, origin, 7, 0.1, 0.2, 0.3, 0.04, dust);
assertEquals(1, enabled.particleCalls.size());
assertEquals(1, enabledPeer.particleCalls.size());
var expected = new Object[]{Particle.DUST, origin, 7, 0.1, 0.2, 0.3, 0.04, dust};
assertArrayEquals(expected, enabled.particleCalls.getFirst());
assertArrayEquals(expected, enabledPeer.particleCalls.getFirst());
assertTrue(disabled.particleCalls.isEmpty());
assertTrue(far.particleCalls.isEmpty());
assertTrue(crossWorld.particleCalls.isEmpty());
org.mockito.Mockito.verify(enabled.world, org.mockito.Mockito.never()).spawnParticle(
org.mockito.ArgumentMatchers.any(Particle.class), org.mockito.ArgumentMatchers.any(org.bukkit.Location.class),
org.mockito.ArgumentMatchers.anyInt(), org.mockito.ArgumentMatchers.anyDouble(),
org.mockito.ArgumentMatchers.anyDouble(), org.mockito.ArgumentMatchers.anyDouble(),
org.mockito.ArgumentMatchers.anyDouble(), org.mockito.ArgumentMatchers.any());
delivery.viewer(disabled.player, Particle.ANGRY_VILLAGER, origin, 8, 0.3, 0.4, 0.3, 0);
delivery.viewer(crossWorld.player, Particle.ANGRY_VILLAGER, origin, 8, 0.3, 0.4, 0.3, 0);
delivery.viewer(enabled.player, Particle.ANGRY_VILLAGER, origin, 8, 0.3, 0.4, 0.3, 0);
assertTrue(disabled.particleCalls.isEmpty());
assertTrue(crossWorld.particleCalls.isEmpty());
assertEquals(2, enabled.particleCalls.size());
assertEquals(1, enabledPeer.particleCalls.size(), "Targeted delivery is not duplicated to another viewer");
assertEquals(Particle.ANGRY_VILLAGER, enabled.particleCalls.getLast()[0]);
}
}
@Test void recurringAuraIsDefaultOffAndDeliveredOnlyToOptedInNativeViewers() throws Exception {
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
var first = new FantasyStickLifecycleNativeTest.Actor(data); first.accountName = "First";
var second = new FantasyStickLifecycleNativeTest.Actor(data); second.accountName = "Second";
var enabled = new FantasyStickLifecycleNativeTest.Actor(data); enabled.accountName = "Enabled";
var disabled = new FantasyStickLifecycleNativeTest.Actor(data); disabled.accountName = "Disabled";
var untracked = new FantasyStickLifecycleNativeTest.Actor(data); untracked.accountName = "Untracked";
var hidden = new FantasyStickLifecycleNativeTest.Actor(data); hidden.accountName = "Hidden"; hidden.visible = false;
var crossWorld = new FantasyStickLifecycleNativeTest.Actor(data); crossWorld.accountName = "CrossWorld";
second.core.location.setWorld(first.world); second.core.location.add(5, 0, 0);
enabled.core.location.setWorld(first.world);
disabled.core.location.setWorld(first.world);
untracked.core.location.setWorld(first.world);
hidden.core.location.setWorld(first.world);
enabled.core.inventory.setItemInOffHand(null);
disabled.core.inventory.setItemInOffHand(null);
untracked.core.inventory.setItemInOffHand(null);
hidden.core.inventory.setItemInOffHand(null);
crossWorld.core.inventory.setItemInOffHand(null);
for (var actor : List.of(first, second, enabled, disabled, untracked, hidden, crossWorld))
fixture.players.put(actor.core.id, actor.player);
first.tracked.add(enabled.player); first.tracked.add(disabled.player); first.tracked.add(hidden.player);
first.tracked.add(crossWorld.player);
second.tracked.add(enabled.player); second.tracked.add(disabled.player); second.tracked.add(hidden.player);
second.tracked.add(first.player);
fixture.activate(first); fixture.activate(second);
var firstInventory = first.core.snapshot(); var secondInventory = second.core.snapshot();
String firstMarker = first.core.marker(); String secondMarker = second.core.marker();
clear(first, second, enabled, disabled, untracked, hidden, crossWorld);
auraPulse(fixture);
assertTrue(first.particleCalls.isEmpty());
assertTrue(second.particleCalls.isEmpty());
assertTrue(enabled.particleCalls.isEmpty());
assertTrue(disabled.particleCalls.isEmpty());
assertTrue(hidden.particleCalls.isEmpty());
org.mockito.Mockito.verify(first.world, org.mockito.Mockito.never()).spawnParticle(
org.mockito.ArgumentMatchers.eq(Particle.DUST), org.mockito.ArgumentMatchers.any(org.bukkit.Location.class),
org.mockito.ArgumentMatchers.anyInt(), org.mockito.ArgumentMatchers.anyDouble(),
org.mockito.ArgumentMatchers.anyDouble(), org.mockito.ArgumentMatchers.anyDouble(),
org.mockito.ArgumentMatchers.anyDouble(), org.mockito.ArgumentMatchers.any(Particle.DustOptions.class));
optIn(fixture, enabled);
optIn(fixture, first);
optIn(fixture, untracked);
optIn(fixture, hidden);
optIn(fixture, crossWorld);
clear(first, second, enabled, disabled, untracked, hidden, crossWorld);
auraPulse(fixture);
assertEquals(2, blueAuraCalls(enabled).size(), "An ordinary opted-in viewer sees both tracked sources");
assertEquals(2, blueAuraCalls(first).size(), "An opted-in active viewer sees self and a tracked peer");
assertTrue(disabled.particleCalls.isEmpty(), "Default-off viewers receive no substitute packet");
assertTrue(untracked.particleCalls.isEmpty(), "Opt-in does not expand native tracking");
assertTrue(hidden.particleCalls.isEmpty(), "Opt-in preserves native player visibility");
assertTrue(crossWorld.particleCalls.isEmpty(), "Opt-in does not cross world boundaries");
assertEquals(java.util.Set.of(first.player.getLocation().add(0, 1, 0),
second.player.getLocation().add(0, 1, 0)), blueAuraCalls(enabled).stream()
.map(call -> (org.bukkit.Location) call[1]).collect(java.util.stream.Collectors.toSet()));
for (Object[] call : blueAuraCalls(enabled)) {
assertEquals(3, call[2]);
assertEquals(0.3, (Double) call[3]); assertEquals(0.4, (Double) call[4]);
assertEquals(0.3, (Double) call[5]); assertEquals(0.0, (Double) call[6]);
}
var preferences = (games.dmg.fantasystick.persistence.PlayerFeedbackPreferences)
FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "feedbackPreferences");
var allOff = preferences.setAllParticles(enabled.core.id, false).toCompletableFuture()
.get(5, java.util.concurrent.TimeUnit.SECONDS);
assertTrue(preferences.publish(allOff));
clear(enabled); auraPulse(fixture);
assertTrue(enabled.particleCalls.isEmpty(), "All-particle off takes precedence over saved aura opt-in");
assertTrue(preferences.playerAurasEnabled(enabled.core.id), "Precedence does not overwrite aura preference");
var allOn = preferences.setAllParticles(enabled.core.id, true).toCompletableFuture()
.get(5, java.util.concurrent.TimeUnit.SECONDS);
assertTrue(preferences.publish(allOn));
clear(enabled); auraPulse(fixture);
assertEquals(2, blueAuraCalls(enabled).size(), "Re-enabling all restores the saved aura preference");
assertArrayEquals(firstInventory, first.core.snapshot()); assertArrayEquals(secondInventory, second.core.snapshot());
assertEquals(firstMarker, first.core.marker()); assertEquals(secondMarker, second.core.marker());
}
}
@Test void registeredAllParticlesReadAndSavedChangeProduceAccountEvents() throws Exception {
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
var actor = new FantasyStickLifecycleNativeTest.Actor(data);
fixture.players.put(actor.core.id, actor.player);
assertTrue(fixture.playerCommand.getExecutor().onCommand(actor.player, fixture.playerCommand,
"fstick", new String[]{"particles", "all"}));
assertTrue(fixture.playerCommand.getExecutor().onCommand(actor.player, fixture.playerCommand,
"fstick", new String[]{"particles", "all", "off"}));
fixture.tick();
assertEquals("All Fantasy Stick particles are now off.", actor.messages.getLast());
var preferences = (games.dmg.fantasystick.persistence.PlayerFeedbackPreferences)
FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "feedbackPreferences");
for (int attempt = 0; attempt < 80 && !preferences.pendingEvents().isEmpty(); attempt++)
Thread.sleep(10);
assertTrue(preferences.pendingEvents().isEmpty(), "First acknowledged event was not drained");
fixture.plugin.setEnabled(false);
var records = new java.util.ArrayList<com.google.gson.JsonObject>();
try (var files = java.nio.file.Files.walk(data.resolve("events"))) {
for (var path : files.filter(p -> p.getFileName().toString().endsWith(".jsonl")).toList())
for (var line : java.nio.file.Files.readAllLines(path))
if (!line.isBlank()) records.add(com.google.gson.JsonParser.parseString(line).getAsJsonObject());
}
var read = records.stream().filter(e -> e.get("type").getAsString().endsWith("preference.read"))
.map(e -> e.getAsJsonObject("data")).filter(d -> d.get("preference_key").getAsString().equals("all-particles"))
.findFirst().orElseThrow();
assertEquals(actor.core.id.toString(), read.get("player_id").getAsString());
assertEquals("true", read.get("effective_value").getAsString());
var changed = records.stream().filter(e -> e.get("type").getAsString().endsWith("preference.changed"))
.map(e -> e.getAsJsonObject("data")).filter(d -> d.get("preference_key").getAsString().equals("all-particles"))
.findFirst().orElseThrow();
assertEquals("true", changed.get("before").getAsString());
assertEquals("false", changed.get("after").getAsString());
assertTrue(changed.get("preference_sequence").getAsLong() > 0);
assertEquals(read.get("player_id"), changed.get("player_id"));
fixture.plugin.setEnabled(true);
assertTrue(fixture.playerCommand.getExecutor().onCommand(actor.player, fixture.playerCommand,
"fstick", new String[]{"particles", "all", "on"}));
for (int attempt = 0; attempt < 80 && !actor.messages.getLast().contains("now on"); attempt++) {
var callback = fixture.tasks.poll(50, java.util.concurrent.TimeUnit.MILLISECONDS);
if (callback != null) callback.run();
}
assertEquals("All Fantasy Stick particles are now on.", actor.messages.getLast());
fixture.plugin.setEnabled(false);
var changes = preferenceRecords().stream()
.filter(e -> e.get("type").getAsString().endsWith("preference.changed"))
.map(e -> e.getAsJsonObject("data"))
.filter(d -> d.get("preference_key").getAsString().equals("all-particles"))
.toList();
var logical = changes.stream().collect(java.util.stream.Collectors.toMap(
d -> d.get("action_id").getAsString(), d -> d, (first, duplicate) -> first,
java.util.LinkedHashMap::new));
assertEquals(2, logical.size(), "At-least-once export may duplicate a physical line, not a logical change");
assertTrue(logical.values().stream().mapToLong(d -> d.get("preference_sequence").getAsLong()).max().orElseThrow()
> changed.get("preference_sequence").getAsLong(),
"The acknowledged preference revision must stay ordered across restart");
}
}
@Test void refusedAndSupersededAllParticleWritesNeverClaimAnAcceptedChange() throws Exception {
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
var actor = new FantasyStickLifecycleNativeTest.Actor(data);
fixture.players.put(actor.core.id, actor.player);
var root = fixture.playerCommand.getExecutor();
assertTrue(root.onCommand(actor.player, fixture.playerCommand, "fstick",
new String[]{"particles", "all", "off"}));
assertTrue(root.onCommand(actor.player, fixture.playerCommand, "fstick",
new String[]{"particles", "all", "on"}));
var preferences = (games.dmg.fantasystick.persistence.PlayerFeedbackPreferences)
FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "feedbackPreferences");
preferences.setAllParticles(java.util.UUID.randomUUID(), true).toCompletableFuture()
.get(5, java.util.concurrent.TimeUnit.SECONDS);
var callbacks = new java.util.ArrayList<Runnable>();
fixture.tasks.drainTo(callbacks);
assertEquals(2, callbacks.size());
java.util.Collections.reverse(callbacks); callbacks.forEach(Runnable::run);
assertTrue(preferences.allParticlesEnabled(actor.core.id));
assertFalse(root.onCommand(actor.player, fixture.playerCommand, "fstick",
new String[]{"particles", "all", "invalid"}));
fixture.plugin.setEnabled(false);
var records = preferenceRecords();
assertEquals(0, records.stream().filter(e -> e.get("type").getAsString().endsWith("preference.changed")).count());
var resolved = records.stream().filter(e -> e.get("type").getAsString().endsWith("action.resolved"))
.map(e -> e.getAsJsonObject("data"))
.filter(d -> d.has("preference_key") && d.get("preference_key").getAsString().equals("all-particles"))
.toList();
assertEquals(java.util.Set.of("superseded", "unchanged", "invalid_arguments"), resolved.stream()
.map(d -> d.get("reason").getAsString()).collect(java.util.stream.Collectors.toSet()));
assertEquals(3, resolved.size());
fixture.plugin.setEnabled(true);
fixture.plugin.setEnabled(false);
assertEquals(0, preferenceRecords().stream()
.filter(e -> e.get("type").getAsString().endsWith("preference.changed")).count(),
"Superseded and unchanged saves cannot become successes during restart recovery");
}
}
@Test void failedAllParticleSaveRemainsObservableWithoutChangingGameplay() throws Exception {
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
var actor = new FantasyStickLifecycleNativeTest.Actor(data);
fixture.players.put(actor.core.id, actor.player);
java.nio.file.Files.createDirectory(data.resolve("player-preferences.yml"));
assertTrue(fixture.playerCommand.getExecutor().onCommand(actor.player, fixture.playerCommand,
"fstick", new String[]{"particles", "all", "off"}));
fixture.tick();
assertTrue(actor.messages.getLast().contains("could not be saved"));
fixture.plugin.setEnabled(false);
var records = preferenceRecords();
assertEquals(0, records.stream().filter(e -> e.get("type").getAsString().endsWith("preference.changed")).count());
assertEquals(1, records.stream().filter(e -> e.get("type").getAsString().endsWith("action.resolved")
&& e.getAsJsonObject("data").has("reason")
&& e.getAsJsonObject("data").get("reason").getAsString().equals("save_failed")).count());
}
}
@Test void accountOptOutRetainsAuditAndCapturesCurrentCharacterWithoutBorrowingAnotherAccount() throws Exception {
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
var actor = new FantasyStickLifecycleNativeTest.Actor(data);
var other = new FantasyStickLifecycleNativeTest.Actor(data);
fixture.players.put(actor.core.id, actor.player);
fixture.players.put(other.core.id, other.player);
fixture.activate(actor);
var root = fixture.playerCommand.getExecutor();
assertTrue(root.onCommand(actor.player, fixture.playerCommand, "fstick",
new String[]{"particles", "all", "off"}));
fixture.tick();
assertTrue(root.onCommand(other.player, fixture.playerCommand, "fstick",
new String[]{"particles", "all"}));
assertEquals("All Fantasy Stick particles are on.", other.messages.getLast());
var sourceSheet = actor.core.inventory.getItemInOffHand().clone();
var sessions = (games.dmg.fantasystick.session.EquipmentSessions)
FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "sessions");
sessions.exit(actor.player);
fixture.awaitCharacterAndReceipt(actor);
other.core.inventory.setItem(8, other.core.inventory.getItemInOffHand());
other.core.inventory.setItemInOffHand(sourceSheet);
fixture.activate(other);
assertTrue(root.onCommand(other.player, fixture.playerCommand, "fstick",
new String[]{"particles", "all"}));
assertEquals("All Fantasy Stick particles are on.", other.messages.getLast());
assertTrue(root.onCommand(actor.player, fixture.playerCommand, "fstick",
new String[]{"particles", "all"}));
assertEquals("All Fantasy Stick particles are off.", actor.messages.getLast());
assertEquals(List.of("off"), fixture.playerCommand.getTabCompleter().onTabComplete(actor.player,
fixture.playerCommand, "fstick", new String[]{"particles", "all", "of"}));
fixture.plugin.setEnabled(false);
var records = preferenceRecords();
var changed = records.stream().filter(e -> e.get("type").getAsString().endsWith("preference.changed"))
.map(e -> e.getAsJsonObject("data")).toList();
assertEquals(1, changed.size(), "Particle delivery and autocomplete do not create audit events");
assertEquals(actor.core.id.toString(), changed.getFirst().get("player_id").getAsString());
assertEquals(actor.core.record.id().toString(), changed.getFirst().get("character_id").getAsString());
assertEquals(actor.world.getUID().toString(), changed.getFirst().getAsJsonObject("location")
.get("world_id").getAsString());
var read = records.stream().filter(e -> e.get("type").getAsString().endsWith("preference.read"))
.map(e -> e.getAsJsonObject("data"))
.filter(d -> d.get("player_id").getAsString().equals(other.core.id.toString()))
.findFirst().orElseThrow();
assertFalse(read.has("character_id"), "An ordinary viewer cannot borrow a playing character identity");
assertEquals("true", read.get("effective_value").getAsString());
assertTrue(records.stream().filter(e -> e.get("type").getAsString().endsWith("preference.read"))
.map(e -> e.getAsJsonObject("data"))
.anyMatch(d -> d.get("player_id").getAsString().equals(other.core.id.toString())
&& d.has("character_id")
&& d.get("character_id").getAsString().equals(actor.core.record.id().toString())
&& d.get("effective_value").getAsString().equals("true")),
"A transferred sheet carries its character, not the previous account's particle preference");
}
}
@Test void nonPlayerAllParticleRequestsAreTruthfullyRefusedWithoutInventingPreferenceSuccess() throws Exception {
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
var console = org.mockito.Mockito.mock(org.bukkit.command.ConsoleCommandSender.class);
var block = org.mockito.Mockito.mock(org.bukkit.command.BlockCommandSender.class);
var root = fixture.playerCommand.getExecutor();
assertTrue(root.onCommand(console, fixture.playerCommand, "fstick",
new String[]{"particles", "all", "off"}));
assertTrue(root.onCommand(block, fixture.playerCommand, "fstick",
new String[]{"particles", "all", "off"}));
fixture.plugin.setEnabled(false);
var records = preferenceRecords();
assertEquals(0, records.stream().filter(e -> e.get("type").getAsString().contains(".preference.")).count());
var refused = records.stream().filter(e -> e.get("type").getAsString().endsWith("action.resolved"))
.map(e -> e.getAsJsonObject("data"))
.filter(d -> d.has("reason") && d.get("reason").getAsString().equals("player_required"))
.toList();
assertEquals(java.util.Set.of("console", "command_block"), refused.stream()
.map(d -> d.get("actor_kind").getAsString()).collect(java.util.stream.Collectors.toSet()));
assertEquals(2, refused.size());
assertTrue(refused.stream().allMatch(d -> d.get("location_status").getAsString().equals("not_applicable")));
}
}
@Test void acceptedPreferenceOutlivesUnavailableEventSinkWithoutLosingItsOriginalEvent() throws Exception {
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
var actor = new FantasyStickLifecycleNativeTest.Actor(data);
fixture.players.put(actor.core.id, actor.player);
var log = (games.dmg.fantasystick.events.LocalEventLog)
FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "eventLog");
log.close(); // Logging fails after gameplay has started; the saved preference remains authoritative.
assertTrue(fixture.playerCommand.getExecutor().onCommand(actor.player, fixture.playerCommand,
"fstick", new String[]{"particles", "all", "off"}));
fixture.tick();
assertEquals("All Fantasy Stick particles are now off.", actor.messages.getLast());
var preferences = (games.dmg.fantasystick.persistence.PlayerFeedbackPreferences)
FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "feedbackPreferences");
for (int attempt = 0; attempt < 80 && preferences.pendingEvents().stream()
.noneMatch(intent -> "true".equals(intent.captured().get("published"))); attempt++)
Thread.sleep(10);
assertTrue(preferences.pendingEvents().stream()
.anyMatch(intent -> "true".equals(intent.captured().get("published"))),
"Committed publication proof must be durable before orderly restart");
fixture.plugin.setEnabled(false);
fixture.plugin.setEnabled(true);
for (int attempt = 0; attempt < 80 && preferenceRecords().stream()
.noneMatch(e -> e.get("type").getAsString().endsWith("preference.changed")); attempt++)
Thread.sleep(10);
fixture.plugin.setEnabled(false);
var events = preferenceRecords();
var changes = events.stream().filter(e -> e.get("type").getAsString().endsWith("preference.changed"))
.filter(e -> e.getAsJsonObject("data").get("preference_key").getAsString().equals("all-particles"))
.toList();
assertEquals(1, changes.stream().map(e -> e.get("id").getAsString()).distinct().count(),
"An acknowledged account change must retain one recoverable event identity");
assertEquals("true", changes.getFirst().getAsJsonObject("data").get("before").getAsString());
assertEquals("false", changes.getFirst().getAsJsonObject("data").get("after").getAsString());
}
}
@Test void readDuringDeferredPublicationDistinguishesSavedFromEffectivePreference() throws Exception {
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
var actor = new FantasyStickLifecycleNativeTest.Actor(data);
fixture.players.put(actor.core.id, actor.player);
var root = fixture.playerCommand.getExecutor();
assertTrue(root.onCommand(actor.player, fixture.playerCommand, "fstick",
new String[]{"particles", "all", "off"}));
var preferences = (games.dmg.fantasystick.persistence.PlayerFeedbackPreferences)
FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "feedbackPreferences");
preferences.setAllParticles(java.util.UUID.randomUUID(), true).toCompletableFuture()
.get(5, java.util.concurrent.TimeUnit.SECONDS); // worker barrier; do not execute deferred main callback
assertTrue(root.onCommand(actor.player, fixture.playerCommand, "fstick",
new String[]{"particles", "all"}));
assertEquals("All Fantasy Stick particles are on.", actor.messages.getLast());
fixture.plugin.setEnabled(false);
var read = preferenceRecords().stream()
.filter(e -> e.get("type").getAsString().endsWith("preference.read"))
.map(e -> e.getAsJsonObject("data"))
.filter(d -> d.get("player_id").getAsString().equals(actor.core.id.toString()))
.findFirst().orElseThrow();
assertEquals("false", read.get("saved_value").getAsString());
assertEquals("true", read.get("effective_value").getAsString());
assertEquals(0, preferenceRecords().stream()
.filter(e -> e.get("type").getAsString().endsWith("preference.changed")).count(),
"A queued native callback has not yet published a changed outcome");
}
}
@Test void twoAcknowledgedChangesSurviveEventSinkFailureWithTheirOriginalIdentities() throws Exception {
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
var actor = new FantasyStickLifecycleNativeTest.Actor(data);
fixture.players.put(actor.core.id, actor.player);
((games.dmg.fantasystick.events.LocalEventLog)
FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "eventLog")).close();
var root = fixture.playerCommand.getExecutor();
for (String value : List.of("off", "on")) {
assertTrue(root.onCommand(actor.player, fixture.playerCommand, "fstick",
new String[]{"particles", "all", value}));
for (int attempt = 0; attempt < 80 && (actor.messages.isEmpty()
|| !actor.messages.getLast().contains("now " + value)); attempt++) {
var callback = fixture.tasks.poll(50, java.util.concurrent.TimeUnit.MILLISECONDS);
if (callback != null) callback.run();
}
assertTrue(actor.messages.getLast().contains("now " + value));
}
var preferences = (games.dmg.fantasystick.persistence.PlayerFeedbackPreferences)
FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "feedbackPreferences");
for (int attempt = 0; attempt < 80 && preferences.pendingEvents().stream()
.filter(intent -> "true".equals(intent.captured().get("published"))).count() < 2; attempt++)
Thread.sleep(10);
assertEquals(2, preferences.pendingEvents().stream()
.filter(intent -> "true".equals(intent.captured().get("published"))).count());
fixture.plugin.setEnabled(false);
fixture.plugin.setEnabled(true);
for (int attempt = 0; attempt < 80 && preferenceRecords().stream()
.filter(e -> e.get("type").getAsString().endsWith("preference.changed"))
.map(e -> e.get("id").getAsString()).distinct().count() < 2; attempt++)
Thread.sleep(10);
fixture.plugin.setEnabled(false);
var changes = preferenceRecords().stream()
.filter(e -> e.get("type").getAsString().endsWith("preference.changed"))
.collect(java.util.stream.Collectors.toMap(e -> e.get("id").getAsString(), e -> e,
(first, duplicate) -> first, java.util.LinkedHashMap::new));
assertEquals(2, changes.size(), "Both acknowledged changes need distinct stable recovered outcomes");
assertEquals(java.util.Set.of("false", "true"), changes.values().stream()
.map(e -> e.getAsJsonObject("data").get("after").getAsString())
.collect(java.util.stream.Collectors.toSet()));
}
}
@Test void registeredAuraPreferenceRecordsDefaultOffAndSavedOptInUnderAllOff() throws Exception {
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
var actor = new FantasyStickLifecycleNativeTest.Actor(data);
fixture.players.put(actor.core.id, actor.player);
var root = fixture.playerCommand.getExecutor();
assertTrue(root.onCommand(actor.player, fixture.playerCommand, "fstick",
new String[]{"particles", "players"}));
assertTrue(root.onCommand(actor.player, fixture.playerCommand, "fstick",
new String[]{"particles", "all", "off"}));
fixture.tick();
assertTrue(root.onCommand(actor.player, fixture.playerCommand, "fstick",
new String[]{"particles", "players", "on"}));
fixture.tick();
assertTrue(actor.messages.getLast().contains("effectively off"));
fixture.plugin.setEnabled(false);
var records = preferenceRecords();
var aura = records.stream().filter(e -> e.getAsJsonObject("data").has("preference_key")
&& e.getAsJsonObject("data").get("preference_key").getAsString().equals("player-aura-particles"))
.toList();
var read = aura.stream().filter(e -> e.get("type").getAsString().endsWith("preference.read"))
.findFirst().orElseThrow().getAsJsonObject("data");
assertEquals("false", read.get("default_value").getAsString());
assertEquals("false", read.get("saved_value").getAsString());
assertEquals("false", read.get("effective_value").getAsString());
assertEquals("/fstick particles players", read.get("entry_point").getAsString());
var change = aura.stream().filter(e -> e.get("type").getAsString().endsWith("preference.changed"))
.findFirst().orElseThrow().getAsJsonObject("data");
assertEquals(actor.core.id.toString(), change.get("player_id").getAsString());
assertEquals("false", change.get("saved_before").getAsString());
assertEquals("true", change.get("saved_value").getAsString());
assertEquals("false", change.get("effective_value").getAsString());
assertEquals("true", change.get("after").getAsString());
assertTrue(change.get("preference_sequence").getAsLong() > 0);
}
}
@Test void auraRefusalsAndSupersededWritesNeverClaimPreferenceSuccess() throws Exception {
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
var actor = new FantasyStickLifecycleNativeTest.Actor(data);
fixture.players.put(actor.core.id, actor.player);
var root = fixture.playerCommand.getExecutor();
assertTrue(root.onCommand(actor.player, fixture.playerCommand, "fstick",
new String[]{"particles", "players", "on"}));
assertTrue(root.onCommand(actor.player, fixture.playerCommand, "fstick",
new String[]{"particles", "players", "off"}));
var preferences = (games.dmg.fantasystick.persistence.PlayerFeedbackPreferences)
FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "feedbackPreferences");
preferences.setPlayerAuras(java.util.UUID.randomUUID(), true).toCompletableFuture()
.get(5, java.util.concurrent.TimeUnit.SECONDS);
var callbacks = new java.util.ArrayList<Runnable>();
fixture.tasks.drainTo(callbacks);
assertEquals(2, callbacks.size());
java.util.Collections.reverse(callbacks); callbacks.forEach(Runnable::run);
assertFalse(root.onCommand(actor.player, fixture.playerCommand, "fstick",
new String[]{"particles", "players", "invalid"}));
assertTrue(root.onCommand(org.mockito.Mockito.mock(org.bukkit.command.ConsoleCommandSender.class),
fixture.playerCommand, "fstick", new String[]{"particles", "players", "on"}));
assertTrue(root.onCommand(org.mockito.Mockito.mock(org.bukkit.command.BlockCommandSender.class),
fixture.playerCommand, "fstick", new String[]{"particles", "players", "on"}));
fixture.plugin.setEnabled(false);
var records = preferenceRecords().stream().filter(e -> e.getAsJsonObject("data").has("preference_key")
&& e.getAsJsonObject("data").get("preference_key").getAsString().equals("player-aura-particles")).toList();
assertEquals(0, records.stream().filter(e -> e.get("type").getAsString().endsWith("preference.changed")).count());
var reasons = records.stream().filter(e -> e.get("type").getAsString().endsWith("action.resolved"))
.map(e -> e.getAsJsonObject("data").get("reason").getAsString()).toList();
assertEquals(5, reasons.size());
assertEquals(java.util.Set.of("superseded", "unchanged", "invalid_arguments", "player_required"),
java.util.Set.copyOf(reasons));
fixture.plugin.setEnabled(true);
fixture.plugin.setEnabled(false);
assertEquals(0, preferenceRecords().stream().filter(e -> e.get("type").getAsString().endsWith("preference.changed")).count());
}
}
@Test void auraSaveFailureLeavesDefaultOffAndReportsFailure() throws Exception {
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
var actor = new FantasyStickLifecycleNativeTest.Actor(data);
fixture.players.put(actor.core.id, actor.player);
java.nio.file.Files.createDirectory(data.resolve("player-preferences.yml"));
assertTrue(fixture.playerCommand.getExecutor().onCommand(actor.player, fixture.playerCommand,
"fstick", new String[]{"particles", "players", "on"}));
fixture.tick();
assertTrue(actor.messages.getLast().contains("could not be saved"));
fixture.plugin.setEnabled(false);
var records = preferenceRecords().stream().filter(e -> e.getAsJsonObject("data").has("preference_key")
&& e.getAsJsonObject("data").get("preference_key").getAsString().equals("player-aura-particles")).toList();
assertEquals(0, records.stream().filter(e -> e.get("type").getAsString().endsWith("preference.changed")).count());
assertEquals("save_failed", records.stream().filter(e -> e.get("type").getAsString().endsWith("action.resolved"))
.findFirst().orElseThrow().getAsJsonObject("data").get("reason").getAsString());
}
}
@Test void auraOptInSurvivesRestartAndCharacterTransferWithoutLeakingAccounts() throws Exception {
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
var owner = new FantasyStickLifecycleNativeTest.Actor(data);
var receiver = new FantasyStickLifecycleNativeTest.Actor(data);
fixture.players.put(owner.core.id, owner.player);
fixture.players.put(receiver.core.id, receiver.player);
var root = fixture.playerCommand.getExecutor();
assertTrue(root.onCommand(owner.player, fixture.playerCommand, "fstick",
new String[]{"particles", "players", "on"}));
fixture.tick();
fixture.activate(owner);
var sheet = owner.core.inventory.getItemInOffHand().clone();
var sessions = (games.dmg.fantasystick.session.EquipmentSessions)
FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "sessions");
sessions.exit(owner.player);
fixture.awaitCharacterAndReceipt(owner);
receiver.core.inventory.setItem(8, receiver.core.inventory.getItemInOffHand());
receiver.core.inventory.setItemInOffHand(sheet);
fixture.activate(receiver);
assertTrue(root.onCommand(receiver.player, fixture.playerCommand, "fstick",
new String[]{"particles", "players"}));
assertEquals("Active-character aura particles are off.", receiver.messages.getLast());
assertTrue(root.onCommand(owner.player, fixture.playerCommand, "fstick",
new String[]{"particles", "players"}));
assertEquals("Active-character aura particles are on.", owner.messages.getLast());
fixture.plugin.setEnabled(false);
fixture.plugin.setEnabled(true);
assertTrue(root.onCommand(receiver.player, fixture.playerCommand, "fstick",
new String[]{"particles", "players"}));
assertEquals("Active-character aura particles are off.", receiver.messages.getLast());
assertTrue(root.onCommand(owner.player, fixture.playerCommand, "fstick",
new String[]{"particles", "players"}));
assertEquals("Active-character aura particles are on.", owner.messages.getLast());
assertEquals(List.of("off"), fixture.playerCommand.getTabCompleter().onTabComplete(owner.player,
fixture.playerCommand, "fstick", new String[]{"particles", "players", "of"}));
fixture.plugin.setEnabled(false);
var records = preferenceRecords().stream()
.filter(e -> e.getAsJsonObject("data").has("preference_key")
&& e.getAsJsonObject("data").get("preference_key").getAsString().equals("player-aura-particles"))
.toList();
assertEquals(1, records.stream().filter(e -> e.get("type").getAsString().endsWith("preference.changed")).count());
var receiverRead = records.stream().filter(e -> e.get("type").getAsString().endsWith("preference.read"))
.map(e -> e.getAsJsonObject("data"))
.filter(d -> d.get("player_id").getAsString().equals(receiver.core.id.toString()))
.findFirst().orElseThrow();
assertEquals("false", receiverRead.get("saved_value").getAsString());
assertEquals(owner.core.record.id().toString(), receiverRead.get("character_id").getAsString());
assertTrue(records.stream().filter(e -> e.get("type").getAsString().endsWith("preference.read"))
.map(e -> e.getAsJsonObject("data"))
.anyMatch(d -> d.get("player_id").getAsString().equals(owner.core.id.toString())
&& d.get("saved_value").getAsString().equals("true")));
}
}
@Test void acceptedAuraOptInRecoversSameEventAfterSinkOutage() throws Exception {
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
var actor = new FantasyStickLifecycleNativeTest.Actor(data);
fixture.players.put(actor.core.id, actor.player);
((games.dmg.fantasystick.events.LocalEventLog)
FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "eventLog")).close();
assertTrue(fixture.playerCommand.getExecutor().onCommand(actor.player, fixture.playerCommand,
"fstick", new String[]{"particles", "players", "on"}));
fixture.tick();
var preferences = (games.dmg.fantasystick.persistence.PlayerFeedbackPreferences)
FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "feedbackPreferences");
for (int i = 0; i < 80 && preferences.pendingEvents().stream()
.noneMatch(p -> "true".equals(p.captured().get("published"))); i++) Thread.sleep(10);
assertTrue(preferences.pendingEvents().stream()
.anyMatch(p -> "true".equals(p.captured().get("published"))));
fixture.plugin.setEnabled(false);
fixture.plugin.setEnabled(true);
for (int i = 0; i < 80 && preferenceRecords().stream()
.noneMatch(e -> e.get("type").getAsString().endsWith("preference.changed")); i++) Thread.sleep(10);
fixture.plugin.setEnabled(false);
var changes = preferenceRecords().stream()
.filter(e -> e.get("type").getAsString().endsWith("preference.changed")
&& e.getAsJsonObject("data").get("preference_key").getAsString().equals("player-aura-particles"))
.toList();
assertEquals(1, changes.stream().map(e -> e.get("id").getAsString()).distinct().count());
assertEquals("false", changes.getFirst().getAsJsonObject("data").get("saved_before").getAsString());
assertEquals("true", changes.getFirst().getAsJsonObject("data").get("saved_value").getAsString());
}
}
private java.util.List<com.google.gson.JsonObject> preferenceRecords() throws Exception {
var records = new java.util.ArrayList<com.google.gson.JsonObject>();
try (var files = java.nio.file.Files.walk(data.resolve("events"))) {
for (var path : files.filter(p -> p.getFileName().toString().endsWith(".jsonl")).toList())
for (var line : java.nio.file.Files.readAllLines(path))
if (!line.isBlank()) records.add(com.google.gson.JsonParser.parseString(line).getAsJsonObject());
}
return records;
}
private static void optIn(FantasyStickLifecycleNativeTest.Fixture fixture,
FantasyStickLifecycleNativeTest.Actor actor) throws Exception {
fixture.particlesCommand.execute(actor.player, "fantasyparticles", new String[]{"players", "on"});
fixture.tick();
}
private static void auraPulse(FantasyStickLifecycleNativeTest.Fixture fixture) {
fixture.pulses.getLast().run();
}
private static List<Object[]> blueAuraCalls(FantasyStickLifecycleNativeTest.Actor actor) {
return actor.particleCalls.stream().filter(call -> call[0] == Particle.DUST && call[2].equals(3)
&& java.util.Arrays.stream(call).anyMatch(value -> value instanceof Particle.DustOptions dust
&& dust.getColor().equals(Color.BLUE))).toList();
}
private static void clear(FantasyStickLifecycleNativeTest.Actor... actors) {
for (var actor : actors) { actor.particles.clear(); actor.particleCalls.clear(); }
}
}