mirrors/Iris
1
0
Fork 0
mirror of https://github.com/VolmitSoftware/Iris.git synced 2026-10-12 03:24:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

Faster green test suite

Browse Source 
- Removed the core processResources skip that fired on test-only invocations, which packaged a core jar with no generation kernel catalog and made all 10 probe and bukkit-plugin tests that reach GenerationKernelRegistry fail on every ./gradlew test
- Set maxParallelForks on :core:test to half the available processors, overridable with -PtestForks, and left the small modules single-forked so they do not re-pay the Minecraft bootstrap per fork or steal worker leases from core
- Resolved B.registries() per bound platform instead of latching the first one for the JVM lifetime, keeping the previous unbound behaviour, so a test that binds its own platform no longer reads a foreign platform's block states
- Resolved IrisObject.States per bound platform through accessors instead of static finals fixed at class-init, removing the NoClassDefFoundError and null material-key failures that appeared whenever class partitioning changed
- Bound an explicit platform in EngineMantleCoverageTest and IrisDimensionStackActuatorMetadataTest so they no longer depend on another class leaking a binding first
- Gated BukkitSpiConformanceTest registry probes on a live RegistryAccess and restored the IrisPlatforms binding it leaked, which was silently swallowing the stderr two SettingsHotloadWatchTest assertions read
- Initialised org.bukkit.Registry and Biome inside the RegistryAccess mock scope in ObjectStudioGeometryTest so Mockito no longer instruments Registry mid-clinit
- Replaced the SettingsHotloadWatchTest fixed 1200ms diagnostic window with a 10ms condition poll bounded at 4s
- Replaced the IrisCaveCarver3DNearParityTest wall-clock speedup benchmark with a deterministic density-sample count, cutting 28 carves to 2
- Cut HydrologyPlannerTest cold-owner parity from 12 tile plans to 4 and shared the immutable baseline plan across the early-owner tests
- Built one prototype project or staged history per class in the jigsaw studio and world replacement tests and copied it per test, replacing repeated fsync-bound fixture construction
- Replaced Mockito block-state fixtures with concrete implementations in the object IO, deposit modifier and nearest-block-index tests, removing about 2.5 million interceptions
- Replaced Thread.sleep with bounded condition polling in HydrologyTileCacheTest
- Deleted 19 test classes and 60 further test methods that asserted on production .java source text rather than behaviour, and removed the 19 now-unread iris.*Source system properties that fed them
This commit is contained in:
Brian Neumann-Fopiano
2026-09-07 19:59:22 -04:00
parent d3245aa1c2
commit 266fe0d71c
66 changed files with 1481 additions and 3238 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/build.gradle
+4 -28
View File
@@ -136,12 +136,12 @@ dependencies {
testImplementation(libs.multiverseCore)
}
int coreTestForks = Math.max(1, Integer.parseInt(providers.gradleProperty('testForks')
.getOrElse(String.valueOf(Math.max(1, (int) (Runtime.runtime.availableProcessors() / 2))))))
tasks.named('test').configure {
maxHeapSize = '1g'
systemProperty('iris.packBenchmarkingSource', file('src/main/java/art/arcane/iris/core/tools/IrisPackBenchmarking.java').absolutePath)
systemProperty('iris.irisToolbeltSource', file('src/main/java/art/arcane/iris/core/tools/IrisToolbelt.java').absolutePath)
systemProperty('iris.irisCreatorSource', file('src/main/java/art/arcane/iris/core/tools/IrisCreator.java').absolutePath)
systemProperty('iris.bukkitChunkGeneratorSource', file('src/main/java/art/arcane/iris/engine/platform/BukkitChunkGenerator.java').absolutePath)
maxParallelForks = coreTestForks
}
java {
@@ -246,30 +246,6 @@ tasks.named('test', Test).configure {
configurations.matching { it.name.startsWith('slim') }.all { }
List<String> requestedTasks = gradle.startParameter.taskNames
boolean runningOnlyTestTasks = !requestedTasks.isEmpty()
&& requestedTasks.every { String taskName -> taskName.toLowerCase().contains('test') }
if (runningOnlyTestTasks) {
TaskProvider<Task> processResourcesTask = tasks.named('processResources')
tasks.named('classes').configure { Task classesTask ->
Set<Object> dependencies = new LinkedHashSet<Object>(classesTask.getDependsOn())
dependencies.removeIf { Object dependency ->
if (dependency instanceof TaskProvider) {
return ((TaskProvider<?>) dependency).name == processResourcesTask.name
}
if (dependency instanceof Task) {
return ((Task) dependency).name == processResourcesTask.name
}
String dependencyName = String.valueOf(dependency)
return dependencyName == 'processResources' || dependencyName.endsWith(':processResources')
}
classesTask.setDependsOn(dependencies)
}
processResourcesTask.configure { Task task ->
task.enabled = false
}
}
// VolmLib packages that Iris forked into art.arcane.iris.util.project.* or replaced outright. Every
// class in each of these packages is unreachable from every other class shipped in the Bukkit jar,
// and none of them is a reflective target: Matter.read() resolves only matter/slices, JarScanner
core/src/main/java/art/arcane/iris/engine/object/IrisObject.java
+51 -6
View File
@@ -25,6 +25,8 @@ import art.arcane.iris.core.loader.IrisRegistrant;
import art.arcane.iris.engine.data.cache.AtomicCache;
import art.arcane.iris.platform.bukkit.BukkitBlockState;
import art.arcane.iris.spi.IrisLogging;
import art.arcane.iris.spi.IrisPlatform;
import art.arcane.iris.spi.IrisPlatforms;
import art.arcane.iris.spi.PlatformBlockState;
import art.arcane.iris.util.common.data.B;
import art.arcane.iris.util.common.data.VectorMap;
@@ -68,11 +70,54 @@ import java.util.function.BiConsumer;
public class IrisObject extends IrisRegistrant {
protected static final IrisVector HALF = new IrisVector(0.5, 0.5, 0.5);
static final class States {
static final PlatformBlockState AIR = B.getState("CAVE_AIR");
static final PlatformBlockState STONE = B.getState("STONE");
static final PlatformBlockState VAIR = B.getState("VOID_AIR");
static final PlatformBlockState VAIR_DEBUG = B.getState("COBWEB");
static final PlatformBlockState[] SNOW_LAYERS = new PlatformBlockState[]{B.getState("minecraft:snow[layers=1]"), B.getState("minecraft:snow[layers=2]"), B.getState("minecraft:snow[layers=3]"), B.getState("minecraft:snow[layers=4]"), B.getState("minecraft:snow[layers=5]"), B.getState("minecraft:snow[layers=6]"), B.getState("minecraft:snow[layers=7]"), B.getState("minecraft:snow[layers=8]")};
private static volatile Bound bound;
private record Bound(
IrisPlatform platform,
PlatformBlockState air,
PlatformBlockState stone,
PlatformBlockState vair,
PlatformBlockState vairDebug,
PlatformBlockState[] snowLayers) {
}
private static Bound bound() {
IrisPlatform platform = IrisPlatforms.get();
Bound current = bound;
if (current != null && current.platform() == platform) {
return current;
}
Bound resolved = new Bound(
platform,
B.getState("CAVE_AIR"),
B.getState("STONE"),
B.getState("VOID_AIR"),
B.getState("COBWEB"),
new PlatformBlockState[]{B.getState("minecraft:snow[layers=1]"), B.getState("minecraft:snow[layers=2]"), B.getState("minecraft:snow[layers=3]"), B.getState("minecraft:snow[layers=4]"), B.getState("minecraft:snow[layers=5]"), B.getState("minecraft:snow[layers=6]"), B.getState("minecraft:snow[layers=7]"), B.getState("minecraft:snow[layers=8]")});
bound = resolved;
return resolved;
}
static PlatformBlockState air() {
return bound().air();
}
static PlatformBlockState stone() {
return bound().stone();
}
static PlatformBlockState vair() {
return bound().vair();
}
static PlatformBlockState vairDebug() {
return bound().vairDebug();
}
static PlatformBlockState snowLayer(int layerIndex) {
return bound().snowLayers()[layerIndex];
}
}
protected transient final Lock readLock;
protected transient final Lock writeLock;
@@ -354,7 +399,7 @@ public class IrisObject extends IrisRegistrant {
readLock.lock();
try {
for (IrisBlockVector i : blocks.keys()) {
at.clone().add(getCenter().getX(), getCenter().getY(), getCenter().getZ()).add(i.getX(), i.getY(), i.getZ()).getBlock().setBlockData((BlockData) States.AIR.nativeHandle(), false);
at.clone().add(getCenter().getX(), getCenter().getY(), getCenter().getZ()).add(i.getX(), i.getY(), i.getZ()).getBlock().setBlockData((BlockData) States.air().nativeHandle(), false);
}
} finally {
readLock.unlock();
core/src/main/java/art/arcane/iris/engine/object/IrisObjectPlacementRunner.java
+10 -10
View File
@@ -389,7 +389,7 @@ final class IrisObjectPlacementRunner {
for (int i = worldBounds.minX(); i <= worldBounds.maxX(); i++) {
for (int j = worldBounds.minY() - config.getBoreExtendMinY(); j <= worldBounds.maxY() + config.getBoreExtendMaxY(); j++) {
for (int k = worldBounds.minZ(); k <= worldBounds.maxZ(); k++) {
placer.set(i, j, k, IrisObject.States.AIR);
placer.set(i, j, k, IrisObject.States.air());
}
}
}
@@ -472,16 +472,16 @@ final class IrisObjectPlacementRunner {
} catch (Throwable e) {
IrisLogging.reportError(e);
IrisLogging.warn("Failed to read block node " + g.getBlockX() + "," + g.getBlockY() + "," + g.getBlockZ() + " in object " + self.getLoadKey() + " (cme)");
d = IrisObject.States.AIR;
d = IrisObject.States.air();
}
if (d == null) {
IrisLogging.warn("Failed to read block node " + g.getBlockX() + "," + g.getBlockY() + "," + g.getBlockZ() + " in object " + self.getLoadKey() + " (null)");
d = IrisObject.States.AIR;
d = IrisObject.States.air();
}
if (placer.isDebugSmartBore() && IrisObject.States.VAIR.equals(d)) {
d = IrisObject.States.VAIR_DEBUG;
if (placer.isDebugSmartBore() && IrisObject.States.vair().equals(d)) {
d = IrisObject.States.vairDebug();
}
PlatformBlockState data = d;
@@ -660,12 +660,12 @@ final class IrisObjectPlacementRunner {
} catch (Throwable e) {
IrisLogging.reportError(e);
IrisLogging.warn("Failed to read block node " + g.getBlockX() + "," + g.getBlockY() + "," + g.getBlockZ() + " in object " + self.getLoadKey() + " (stilt cme)");
sourceData = IrisObject.States.AIR;
sourceData = IrisObject.States.air();
}
if (sourceData == null) {
IrisLogging.warn("Failed to read block node " + g.getBlockX() + "," + g.getBlockY() + "," + g.getBlockZ() + " in object " + self.getLoadKey() + " (stilt null)");
sourceData = IrisObject.States.AIR;
sourceData = IrisObject.States.air();
}
if (!IrisObjectShaping.shouldStilt(sourceData)) {
@@ -852,7 +852,7 @@ final class IrisObjectPlacementRunner {
if (config.getSnow() > 0) {
int height = rngx.i(0, (int) (config.getSnow() * 7));
placer.set(vx, vy + 1, vz, IrisObject.States.SNOW_LAYERS[Math.max(Math.min(height, 7), 0)]);
placer.set(vx, vy + 1, vz, IrisObject.States.snowLayer(Math.max(Math.min(height, 7), 0)));
}
}
}
@@ -1096,7 +1096,7 @@ final class IrisObjectPlacementRunner {
if (targetY > origY) {
PlatformBlockState fill = complex != null ? complex.getRockStream().get(cx, cz) : null;
if (B.isAir(fill)) {
fill = IrisObject.States.STONE;
fill = IrisObject.States.stone();
}
for (int yy = origY + 1; yy <= targetY; yy++) {
placer.set(cx, yy, cz, fill);
@@ -1105,7 +1105,7 @@ final class IrisObjectPlacementRunner {
boolean inside = IrisObjectVacuum.outset(dx, lowX, highX) == 0 && IrisObjectVacuum.outset(dz, lowZ, highZ) == 0;
int carveFloor = IrisObjectVacuum.carveFloorY(targetY, topY, inside);
for (int yy = origY; yy >= carveFloor; yy--) {
placer.set(cx, yy, cz, IrisObject.States.AIR);
placer.set(cx, yy, cz, IrisObject.States.air());
}
}
}
core/src/main/java/art/arcane/iris/engine/object/IrisObjectShaping.java
+1 -1
View File
@@ -54,7 +54,7 @@ final class IrisObjectShaping {
private static void ensureSmartBoredLocked(IrisObject self) {
PrecisionStopwatch p = PrecisionStopwatch.start();
PlatformBlockState vair = IrisObject.States.VAIR;
PlatformBlockState vair = IrisObject.States.vair();
int applied = 0;
IrisBlockVector max = new IrisBlockVector(Integer.MIN_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE);
IrisBlockVector min = new IrisBlockVector(Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE);
core/src/main/java/art/arcane/iris/engine/object/IrisObjectTransforms.java
+3 -3
View File
@@ -286,7 +286,7 @@ final class IrisObjectTransforms {
}) >= 0.5) {
b.put(new IrisBlockVector(x, y, z), nearestBlockData(v, nearestBlocks, x, y, z));
} else {
b.put(new IrisBlockVector(x, y, z), IrisObject.States.AIR);
b.put(new IrisBlockVector(x, y, z), IrisObject.States.air());
}
}
}
@@ -323,7 +323,7 @@ final class IrisObjectTransforms {
}) >= 0.5) {
b.put(new IrisBlockVector(x, y, z), nearestBlockData(v, nearestBlocks, x, y, z));
} else {
b.put(new IrisBlockVector(x, y, z), IrisObject.States.AIR);
b.put(new IrisBlockVector(x, y, z), IrisObject.States.air());
}
}
}
@@ -364,7 +364,7 @@ final class IrisObjectTransforms {
}, tension, bias) >= 0.5) {
b.put(new IrisBlockVector(x, y, z), nearestBlockData(v, nearestBlocks, x, y, z));
} else {
b.put(new IrisBlockVector(x, y, z), IrisObject.States.AIR);
b.put(new IrisBlockVector(x, y, z), IrisObject.States.air());
}
}
}
core/src/main/java/art/arcane/iris/engine/object/IrisStaticObjectLayer.java
+1 -1
View File
@@ -168,7 +168,7 @@ public final class IrisStaticObjectLayer {
@Override
public PlatformBlockState get(int x, int y, int z) {
Block block = block(x, y, z);
return block == null ? IrisObject.States.AIR : block.state();
return block == null ? IrisObject.States.air() : block.state();
}
@Override
core/src/main/java/art/arcane/iris/util/common/data/B.java
+16 -7
View File
@@ -1,12 +1,16 @@
package art.arcane.iris.util.common.data;
import art.arcane.iris.spi.IrisPlatform;
import art.arcane.iris.spi.IrisPlatforms;
import art.arcane.iris.spi.PlatformBlockState;
import art.arcane.iris.spi.PlatformRegistries;
import art.arcane.volmlib.util.collection.KList;
public class B {
private static volatile PlatformRegistries registries;
private static volatile BoundRegistries bound;
private record BoundRegistries(IrisPlatform platform, PlatformRegistries registries) {
}
public static PlatformBlockState getState(String bdxf) {
return registries().block(bdxf);
@@ -117,13 +121,18 @@ public class B {
}
private static PlatformRegistries registries() {
PlatformRegistries cached = registries;
if (cached != null) {
return cached;
BoundRegistries cached = bound;
if (cached != null && !IrisPlatforms.isBound()) {
return cached.registries();
}
PlatformRegistries resolved = IrisPlatforms.get().registries();
registries = resolved;
return resolved;
IrisPlatform platform = IrisPlatforms.get();
if (cached != null && cached.platform() == platform) {
return cached.registries();
}
BoundRegistries resolved = new BoundRegistries(platform, platform.registries());
bound = resolved;
return resolved.registries();
}
}
core/src/test/java/art/arcane/iris/core/SettingsHotloadWatchTest.java
+14 -7
View File
@@ -26,6 +26,7 @@ import java.util.function.Consumer;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
public class SettingsHotloadWatchTest {
private static final String PERMISSION = "iris.all";
@@ -319,19 +320,25 @@ public class SettingsHotloadWatchTest {
}
}
private String captureErrorsWhilePolling(String expected, long durationMillis) throws Exception {
private String captureErrorsWhilePolling(String expected, long duplicateWindowMillis) throws Exception {
PrintStream originalError = System.err;
ByteArrayOutputStream captured = new ByteArrayOutputStream();
try (PrintStream capture = new PrintStream(captured, true, StandardCharsets.UTF_8)) {
System.setErr(capture);
long deadline = System.nanoTime() + TimeUnit.MILLISECONDS.toNanos(durationMillis);
boolean found = false;
while (System.nanoTime() < deadline) {
long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(4L);
while (!captured.toString(StandardCharsets.UTF_8).contains(expected)) {
if (System.nanoTime() >= deadline) {
fail("Timed out after 4000ms waiting for the hotload diagnostic '" + expected
+ "'; captured stderr was: " + captured.toString(StandardCharsets.UTF_8));
}
watch.checkConfigHotload();
found |= captured.toString(StandardCharsets.UTF_8).contains(expected);
Thread.sleep(25L);
Thread.sleep(10L);
}
long duplicateDeadline = System.nanoTime() + TimeUnit.MILLISECONDS.toNanos(duplicateWindowMillis);
while (System.nanoTime() < duplicateDeadline) {
watch.checkConfigHotload();
Thread.sleep(10L);
}
assertTrue(found);
} finally {
System.setErr(originalError);
}
core/src/test/java/art/arcane/iris/core/lifecycle/WorldReplacementBootstrapTest.java
+38 -2
View File
@@ -12,6 +12,8 @@ import art.arcane.iris.engine.history.GenerationHistory;
import art.arcane.iris.engine.history.GenerationPackFingerprint;
import art.arcane.iris.engine.history.GenerationRegistryContract;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
@@ -19,8 +21,10 @@ import org.junit.rules.TemporaryFolder;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.util.List;
import java.util.UUID;
import java.util.stream.Stream;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
@@ -31,15 +35,27 @@ public class WorldReplacementBootstrapTest {
private static final WorldSlotKey WORLD_KEY = WorldSlotKey.minecraft("the_nether");
private static final long SEED = 4242424242L;
@ClassRule
public static final TemporaryFolder prototypeFolder = new TemporaryFolder();
@Rule
public TemporaryFolder temporaryFolder = new TemporaryFolder();
private static Path underworldStagePrototype;
private Path serverRoot;
private Path dataDirectory;
private Path levelRoot;
private Path bukkitConfiguration;
private ExactWorldSlotPathPolicy.Target target;
@BeforeClass
public static void createStagePrototype() throws Exception {
Path base = prototypeFolder.newFolder("underworld-stage").toPath();
underworldStagePrototype = base.resolve("stage");
createStagedHistory(underworldStagePrototype, "underworld", "replacement", SEED);
}
@Before
public void setUp() throws Exception {
serverRoot = temporaryFolder.newFolder("server").toPath();
@@ -489,7 +505,7 @@ public class WorldReplacementBootstrapTest {
if (originalPresent) {
writeOriginalTarget(paths, originalContent);
}
Path pack = createStagedHistory(paths.stage(), "underworld", "replacement", SEED);
Path pack = copyUnderworldStage(paths.stage());
String fingerprint = WorldReplacementFilesystem.fingerprintPack(pack);
Transaction transaction = new Transaction(
id,
@@ -561,7 +577,27 @@ public class WorldReplacementBootstrapTest {
return Files.readString(activePackRoot(worldDirectory).resolve("dimensions/underworld.json"));
}
private Path createStagedHistory(Path world, String dimensionKey, String content, long seed)
private static Path copyUnderworldStage(Path world) throws Exception {
Path source = world.resolveSibling(world.getFileName() + ".underworld.pack-source");
Path dimension = source.resolve("dimensions/underworld.json");
Files.createDirectories(dimension.getParent());
Files.writeString(dimension, "replacement");
try (Stream<Path> entries = Files.walk(underworldStagePrototype)) {
for (Path entry : entries.toList()) {
Path destination = world.resolve(
underworldStagePrototype.relativize(entry).toString());
if (Files.isDirectory(entry)) {
Files.createDirectories(destination);
} else {
Files.createDirectories(destination.getParent());
Files.copy(entry, destination, StandardCopyOption.COPY_ATTRIBUTES);
}
}
}
return activePackRoot(world);
}
private static Path createStagedHistory(Path world, String dimensionKey, String content, long seed)
throws Exception {
Path source = world.resolveSibling(world.getFileName() + "." + dimensionKey + ".pack-source");
Path dimension = source.resolve("dimensions").resolve(dimensionKey + ".json");
core/src/test/java/art/arcane/iris/core/lifecycle/WorldReplacementFilesystemTest.java
+57 -3
View File
@@ -6,6 +6,8 @@ import art.arcane.iris.engine.history.GenerationHistory;
import art.arcane.iris.engine.history.GenerationPackFingerprint;
import art.arcane.iris.engine.history.GenerationRegistryContract;
import org.junit.Assume;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
@@ -16,6 +18,7 @@ import java.net.UnixDomainSocketAddress;
import java.nio.channels.ServerSocketChannel;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.util.Comparator;
import java.util.UUID;
import java.util.stream.Stream;
@@ -30,9 +33,21 @@ public class WorldReplacementFilesystemTest {
private static final UUID TRANSACTION_ID = UUID.fromString("00000000-0000-0000-0000-000000000001");
private static final UUID OTHER_TRANSACTION_ID = UUID.fromString("00000000-0000-0000-0000-000000000002");
@ClassRule
public static final TemporaryFolder prototypeFolder = new TemporaryFolder();
@Rule
public TemporaryFolder temporaryFolder = new TemporaryFolder();
private static StagePrototype replacementStage;
private static StagePrototype originalStage;
@BeforeClass
public static void createStagePrototypes() throws Exception {
replacementStage = createStagePrototype("replacement");
originalStage = createStagePrototype("original-stage");
}
@Test
public void publishesReplacementAndRetainsOriginalBackup() throws Exception {
WorldReplacementFilesystem.ReplacementPaths paths = paths("publish-existing", TRANSACTION_ID);
@@ -501,20 +516,59 @@ public class WorldReplacementFilesystemTest {
Path contentFile = source.resolve("dimensions/underworld.json");
Files.createDirectories(contentFile.getParent());
Files.writeString(contentFile, content);
StagePrototype prototype = stagePrototype(content);
copyTree(prototype.stage(), paths.stage());
return prototype.fingerprint();
}
private static StagePrototype stagePrototype(String content) {
if ("replacement".equals(content)) {
return replacementStage;
}
if ("original-stage".equals(content)) {
return originalStage;
}
throw new AssertionError("No staged generation history prototype for " + content);
}
private static StagePrototype createStagePrototype(String content) throws Exception {
Path base = prototypeFolder.newFolder("stage-" + content).toPath();
Path source = base.resolve("pack-source");
Path contentFile = source.resolve("dimensions/underworld.json");
Files.createDirectories(contentFile.getParent());
Files.writeString(contentFile, content);
String generationFingerprint = GenerationPackFingerprint.compute(
source,
GenerationPackFingerprint.CURRENT_VERSION
);
Files.createDirectory(paths.stage());
Path stage = base.resolve("stage");
Files.createDirectory(stage);
GenerationHistory history = GenerationHistory.create(
paths.stage(),
stage,
source,
generationFingerprint,
42L,
generationContract("underworld"),
GenerationRegistryContract.empty()
);
return WorldReplacementFilesystem.fingerprintPack(history.activePackRoot());
return new StagePrototype(stage, WorldReplacementFilesystem.fingerprintPack(history.activePackRoot()));
}
private static void copyTree(Path source, Path target) throws IOException {
try (Stream<Path> entries = Files.walk(source)) {
for (Path entry : entries.toList()) {
Path destination = target.resolve(source.relativize(entry).toString());
if (Files.isDirectory(entry)) {
Files.createDirectories(destination);
} else {
Files.createDirectories(destination.getParent());
Files.copy(entry, destination, StandardCopyOption.COPY_ATTRIBUTES);
}
}
}
}
private record StagePrototype(Path stage, String fingerprint) {
}
private void writeOriginalTarget(WorldReplacementFilesystem.ReplacementPaths paths, String content) throws Exception {
core/src/test/java/art/arcane/iris/core/runtime/jigsaw/JigsawStudioGraphEditorResizeTest.java
+58 -32
View File
@@ -10,6 +10,8 @@ import art.arcane.iris.util.common.math.IrisBlockVector;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
@@ -18,9 +20,11 @@ import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.util.LinkedHashMap;
import java.util.Locale;
import java.util.Map;
import java.util.stream.Stream;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertArrayEquals;
@@ -32,23 +36,41 @@ import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class JigsawStudioGraphEditorResizeTest {
private static final String STRUCTURE_KEY = "resize/planar";
@ClassRule
public static final TemporaryFolder prototypeFolder = new TemporaryFolder();
@Rule
public final TemporaryFolder temporaryFolder = new TemporaryFolder();
private static Path prototypePackRoot;
@BeforeClass
public static void createPrototypeProject() throws Exception {
prototypePackRoot = prototypeFolder.newFolder("prototype").toPath();
JigsawStudioProjectCreator.Options options = new JigsawStudioProjectCreator.Options(
STRUCTURE_KEY,
JigsawStudioMode.PLANAR_JIGSAW,
JigsawStudioCompatibilityTarget.IRIS_EXTENDED,
new JigsawStudioCellDimensions(16, 16, 16));
assertTrue(JigsawStudioProjectCreator.create(prototypePackRoot, options).successful());
JigsawStudioGraphEditor.duplicateActiveFamily(
prototypePackRoot,
STRUCTURE_KEY,
planarSources(STRUCTURE_KEY),
"variant-2");
}
@Test
public void resizesOnlyTheRequestedVariantWithinWorkcellCapacity() throws Exception {
Path packRoot = createPlanarProject("resize/atomic");
JigsawStudioGraphEditor.duplicateActiveFamily(
packRoot,
"resize/atomic",
planarSources("resize/atomic"),
"variant-2");
Path packRoot = createPlanarProjectWithVariantFamily();
JigsawStudioGraphEditor.VariantResizeResult result =
JigsawStudioGraphEditor.resizePieceObject(
packRoot,
"resize/atomic",
"resize/atomic/variants/corner/variant-2",
STRUCTURE_KEY,
"resize/planar/variants/corner/variant-2",
new JigsawStudioCellDimensions(7, 4, 9));
assertTrue(result.writeResult().successful());
@@ -56,19 +78,19 @@ public class JigsawStudioGraphEditorResizeTest {
assertEquals(new JigsawStudioCellDimensions(7, 4, 9), result.dimensions());
assertEquals(2, result.relocatedConnectors());
assertEquals(new IrisBlockVector(16, 16, 16), IrisObject.sampleSize(
packRoot.resolve("objects/resize/atomic/corner.iob").toFile()));
packRoot.resolve("objects/resize/planar/corner.iob").toFile()));
assertEquals(new IrisBlockVector(7, 4, 9), IrisObject.sampleSize(
packRoot.resolve("objects/resize/atomic/variants/corner/variant-2.iob").toFile()));
packRoot.resolve("objects/resize/planar/variants/corner/variant-2.iob").toFile()));
assertEquals(new IrisBlockVector(16, 16, 16), IrisObject.sampleSize(
packRoot.resolve("objects/resize/atomic/end.iob").toFile()));
packRoot.resolve("objects/resize/planar/end.iob").toFile()));
JsonObject structure = readJson(packRoot.resolve("structures/resize/atomic.json"));
JsonObject structure = readJson(packRoot.resolve("structures/resize/planar.json"));
JsonObject workcell = workcell(structure.getAsJsonArray("planarWorkcells"), "CORNER");
assertEquals(16, workcell.get("width").getAsInt());
assertEquals(16, workcell.get("height").getAsInt());
assertEquals(16, workcell.get("depth").getAsInt());
JsonArray connectors = readJson(packRoot.resolve(
"jigsaw-pieces/resize/atomic/variants/corner/variant-2.json"))
"jigsaw-pieces/resize/planar/variants/corner/variant-2.json"))
.getAsJsonArray("connectors");
assertEquals(new IrisPosition(3, 2, 0), connectorPosition(connectors, "NORTH_NEGATIVE_Z"));
assertEquals(new IrisPosition(6, 2, 4), connectorPosition(connectors, "EAST_POSITIVE_X"));
@@ -76,14 +98,9 @@ public class JigsawStudioGraphEditorResizeTest {
@Test
public void capacityChangesNeverRewriteVariantObjects() throws Exception {
Path packRoot = createPlanarProject("resize/capacity");
JigsawStudioGraphEditor.duplicateActiveFamily(
packRoot,
"resize/capacity",
planarSources("resize/capacity"),
"variant-2");
Path sourceObject = packRoot.resolve("objects/resize/capacity/corner.iob");
Path familyObject = packRoot.resolve("objects/resize/capacity/variants/corner/variant-2.iob");
Path packRoot = createPlanarProjectWithVariantFamily();
Path sourceObject = packRoot.resolve("objects/resize/planar/corner.iob");
Path familyObject = packRoot.resolve("objects/resize/planar/variants/corner/variant-2.iob");
byte[] sourceBefore = Files.readAllBytes(sourceObject);
byte[] familyBefore = Files.readAllBytes(familyObject);
@@ -91,7 +108,7 @@ public class JigsawStudioGraphEditorResizeTest {
IOException.class,
() -> JigsawStudioGraphEditor.updatePlanarWorkcellCapacity(
packRoot,
"resize/capacity",
STRUCTURE_KEY,
JigsawPlanarArchetype.CORNER,
new JigsawStudioCellDimensions(7, 4, 9)));
@@ -102,7 +119,7 @@ public class JigsawStudioGraphEditorResizeTest {
JigsawStudioGraphEditor.WorkcellCapacityResult result =
JigsawStudioGraphEditor.updatePlanarWorkcellCapacity(
packRoot,
"resize/capacity",
STRUCTURE_KEY,
JigsawPlanarArchetype.CORNER,
new JigsawStudioCellDimensions(24, 18, 20));
@@ -110,7 +127,7 @@ public class JigsawStudioGraphEditorResizeTest {
assertEquals(2, result.checkedVariants());
assertArrayEquals(sourceBefore, Files.readAllBytes(sourceObject));
assertArrayEquals(familyBefore, Files.readAllBytes(familyObject));
JsonObject structure = readJson(packRoot.resolve("structures/resize/capacity.json"));
JsonObject structure = readJson(packRoot.resolve("structures/resize/planar.json"));
JsonObject workcell = workcell(structure.getAsJsonArray("planarWorkcells"), "CORNER");
assertEquals(24, workcell.get("width").getAsInt());
assertEquals(18, workcell.get("height").getAsInt());
@@ -191,17 +208,26 @@ public class JigsawStudioGraphEditorResizeTest {
assertSame(collision, blockAt(source, 3, 1, 0));
}
private Path createPlanarProject(String structureKey) throws Exception {
Path packRoot = temporaryFolder.newFolder(structureKey.replace('/', '-')).toPath();
JigsawStudioProjectCreator.Options options = new JigsawStudioProjectCreator.Options(
structureKey,
JigsawStudioMode.PLANAR_JIGSAW,
JigsawStudioCompatibilityTarget.IRIS_EXTENDED,
new JigsawStudioCellDimensions(16, 16, 16));
assertTrue(JigsawStudioProjectCreator.create(packRoot, options).successful());
private Path createPlanarProjectWithVariantFamily() throws Exception {
Path packRoot = temporaryFolder.newFolder("pack").toPath();
copyTree(prototypePackRoot, packRoot);
return packRoot;
}
private static void copyTree(Path source, Path target) throws IOException {
try (Stream<Path> entries = Files.walk(source)) {
for (Path entry : entries.toList()) {
Path destination = target.resolve(source.relativize(entry).toString());
if (Files.isDirectory(entry)) {
Files.createDirectories(destination);
} else {
Files.createDirectories(destination.getParent());
Files.copy(entry, destination, StandardCopyOption.COPY_ATTRIBUTES);
}
}
}
}
private static IrisJigsawPiece endPiece(IrisDirection direction, IrisPosition position) {
IrisJigsawPiece piece = new IrisJigsawPiece().setObject("resize/end");
piece.getConnectors().add(new IrisJigsawConnector()
core/src/test/java/art/arcane/iris/core/runtime/jigsaw/JigsawStudioManagedAuthoringGuardTest.java
+62 -31
View File
@@ -5,6 +5,8 @@ import art.arcane.iris.core.structure.authoring.StructureKey;
import art.arcane.iris.core.structure.authoring.StructureOwnershipManifest;
import art.arcane.iris.core.structure.authoring.StructureTransactionWriter;
import art.arcane.iris.core.structure.authoring.StructureWriteResult;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
@@ -13,9 +15,11 @@ import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.util.Map;
import java.util.TreeMap;
import java.util.UUID;
import java.util.stream.Stream;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertFalse;
@@ -23,39 +27,58 @@ import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
public class JigsawStudioManagedAuthoringGuardTest {
private static final String STRUCTURE_KEY = "managed/project";
@ClassRule
public static final TemporaryFolder prototypeFolder = new TemporaryFolder();
@Rule
public final TemporaryFolder temporaryFolder = new TemporaryFolder();
private static Path prototypePackRoot;
@BeforeClass
public static void createPrototypeProject() throws Exception {
prototypePackRoot = prototypeFolder.newFolder("prototype").toPath();
JigsawStudioProjectCreator.Options options = new JigsawStudioProjectCreator.Options(
STRUCTURE_KEY,
JigsawStudioMode.PLANAR_JIGSAW,
JigsawStudioCompatibilityTarget.IRIS_EXTENDED,
new JigsawStudioCellDimensions(16, 16, 16));
StructureWriteResult result = JigsawStudioProjectCreator.create(prototypePackRoot, options);
assertTrue(result.successful());
}
@Test
public void graphEditorRejectsManagedDatapackOwnership() throws Exception {
Path packRoot = createManagedProject("managed/graph");
Path packRoot = createManagedProject();
IOException lookupFailure = assertThrows(IOException.class,
() -> JigsawStudioGraphEditor.ownedPoolKeys(packRoot, "managed/graph"));
() -> JigsawStudioGraphEditor.ownedPoolKeys(packRoot, STRUCTURE_KEY));
IOException editFailure = assertThrows(IOException.class,
() -> JigsawStudioGraphEditor.createPool(
packRoot,
"managed/graph",
"managed/graph/terminal",
STRUCTURE_KEY,
"managed/project/terminal",
""));
assertManagedGuidance(lookupFailure);
assertManagedGuidance(editFailure);
assertFalse(Files.exists(packRoot.resolve("jigsaw-pools/managed/graph/terminal.json")));
assertFalse(Files.exists(packRoot.resolve("jigsaw-pools/managed/project/terminal.json")));
}
@Test
public void poolEditorRejectsManagedDatapackOwnershipWithoutChangingThePool() throws Exception {
Path packRoot = createManagedProject("managed/pool");
Path poolPath = packRoot.resolve("jigsaw-pools/managed/pool/start.json");
Path packRoot = createManagedProject();
Path poolPath = packRoot.resolve("jigsaw-pools/managed/project/start.json");
byte[] before = Files.readAllBytes(poolPath);
IOException failure = assertThrows(IOException.class,
() -> JigsawStudioPoolEditor.updateWeight(
packRoot,
"managed/pool",
"managed/pool/start",
"managed/pool/start",
STRUCTURE_KEY,
"managed/project/start",
"managed/project/start",
9));
assertManagedGuidance(failure);
@@ -64,14 +87,14 @@ public class JigsawStudioManagedAuthoringGuardTest {
@Test
public void structureEditorRejectsManagedDatapackOwnershipWithoutChangingRules() throws Exception {
Path packRoot = createManagedProject("managed/rules");
Path structurePath = packRoot.resolve("structures/managed/rules.json");
Path packRoot = createManagedProject();
Path structurePath = packRoot.resolve("structures/managed/project.json");
byte[] before = Files.readAllBytes(structurePath);
IOException failure = assertThrows(IOException.class,
() -> JigsawStudioStructureEditor.updateLimits(
packRoot,
"managed/rules",
STRUCTURE_KEY,
12,
6));
@@ -81,8 +104,8 @@ public class JigsawStudioManagedAuthoringGuardTest {
@Test
public void centralAccessRuleMatchesManagedDatapackProvenanceOnly() throws Exception {
Path packRoot = createProject("managed/access");
StructureOwnershipManifest created = readManifest(packRoot, "managed/access");
Path packRoot = createProject();
StructureOwnershipManifest created = readManifest(packRoot, STRUCTURE_KEY);
assertTrue(JigsawStudioAuthoringAccess.isEditable(created));
@@ -95,38 +118,46 @@ public class JigsawStudioManagedAuthoringGuardTest {
@Test
public void projectDeletionRejectsManagedDatapackOwnership() throws Exception {
Path packRoot = createManagedProject("managed/deletion");
Path packRoot = createManagedProject();
IOException failure = assertThrows(
IOException.class,
() -> JigsawStudioProjectDeletionService.inspect(packRoot, "managed/deletion"));
() -> JigsawStudioProjectDeletionService.inspect(packRoot, STRUCTURE_KEY));
assertManagedGuidance(failure);
assertTrue(Files.exists(packRoot.resolve("structures/managed/deletion.json")));
assertTrue(Files.exists(packRoot.resolve("structures/managed/project.json")));
}
private Path createManagedProject(String structureKey) throws Exception {
Path packRoot = createProject(structureKey);
StructureOwnershipManifest manifest = readManifest(packRoot, structureKey);
private Path createManagedProject() throws Exception {
Path packRoot = createProject();
StructureOwnershipManifest manifest = readManifest(packRoot, STRUCTURE_KEY);
StructureTransactionWriter writer = new StructureTransactionWriter(packRoot);
Files.write(
writer.ownershipManifestPath(StructureKey.parse(structureKey, "iris")),
writer.ownershipManifestPath(StructureKey.parse(STRUCTURE_KEY, "iris")),
withManagedProvenance(manifest).toJson());
return packRoot;
}
private Path createProject(String structureKey) throws Exception {
Path packRoot = temporaryFolder.newFolder(structureKey.replace('/', '-')).toPath();
JigsawStudioProjectCreator.Options options = new JigsawStudioProjectCreator.Options(
structureKey,
JigsawStudioMode.PLANAR_JIGSAW,
JigsawStudioCompatibilityTarget.IRIS_EXTENDED,
new JigsawStudioCellDimensions(16, 16, 16));
StructureWriteResult result = JigsawStudioProjectCreator.create(packRoot, options);
assertTrue(result.successful());
private Path createProject() throws Exception {
Path packRoot = temporaryFolder.newFolder("pack").toPath();
copyTree(prototypePackRoot, packRoot);
return packRoot;
}
private static void copyTree(Path source, Path target) throws IOException {
try (Stream<Path> entries = Files.walk(source)) {
for (Path entry : entries.toList()) {
Path destination = target.resolve(source.relativize(entry).toString());
if (Files.isDirectory(entry)) {
Files.createDirectories(destination);
} else {
Files.createDirectories(destination.getParent());
Files.copy(entry, destination, StandardCopyOption.COPY_ATTRIBUTES);
}
}
}
}
private static StructureOwnershipManifest readManifest(
Path packRoot,
String structureKey
core/src/test/java/art/arcane/iris/core/runtime/jigsaw/JigsawStudioPersistenceEditorsTest.java
+155 -128
View File
@@ -16,6 +16,8 @@ import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import org.junit.Assume;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
@@ -24,10 +26,12 @@ import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.stream.Stream;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
@@ -36,26 +40,55 @@ import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
public class JigsawStudioPersistenceEditorsTest {
private static final String PLANAR_KEY = "studio/planar";
private static final String SPATIAL_KEY = "studio/spatial";
@ClassRule
public static final TemporaryFolder prototypeFolder = new TemporaryFolder();
@Rule
public final TemporaryFolder temporaryFolder = new TemporaryFolder();
private static Path planarPrototype;
private static Path spatialPrototype;
@BeforeClass
public static void createPrototypeProjects() throws Exception {
planarPrototype = prototypeFolder.newFolder("planar-prototype").toPath();
assertTrue(JigsawStudioProjectCreator.create(
planarPrototype,
new JigsawStudioProjectCreator.Options(
PLANAR_KEY,
JigsawStudioMode.PLANAR_JIGSAW,
JigsawStudioCompatibilityTarget.IRIS_EXTENDED,
new JigsawStudioCellDimensions(16, 16, 16))).successful());
spatialPrototype = prototypeFolder.newFolder("spatial-prototype").toPath();
assertTrue(JigsawStudioProjectCreator.create(
spatialPrototype,
new JigsawStudioProjectCreator.Options(
SPATIAL_KEY,
JigsawStudioMode.SPATIAL_JIGSAW,
JigsawStudioCompatibilityTarget.IRIS_EXTENDED,
new JigsawStudioCellDimensions(16, 16, 16))).successful());
}
@Test
public void createsCoherentThemeSetAndAppliesAtomicMetadataEditors() throws Exception {
Path packRoot = createPlanarProject("theme/test");
Path packRoot = createPlanarProject();
JigsawStudioPoolEditor.WeightUpdate weight = JigsawStudioPoolEditor.updateWeightAtIndex(
packRoot,
"theme/test",
"theme/test/pieces",
"studio/planar",
"studio/planar/pieces",
0,
"theme/test/end",
"studio/planar/end",
4);
JigsawStudioPoolEditor.ChanceUpdate chance = JigsawStudioPoolEditor.updateChanceAtIndex(
packRoot,
"theme/test",
"theme/test/pieces",
"studio/planar",
"studio/planar/pieces",
0,
"theme/test/end",
"studio/planar/end",
0.35D);
assertTrue(weight.changed());
@@ -63,60 +96,60 @@ public class JigsawStudioPersistenceEditorsTest {
JigsawStudioGraphEditor.VariantFamilyCreation creation = JigsawStudioGraphEditor.duplicateActiveFamily(
packRoot,
"theme/test",
planarSources("theme/test"),
"studio/planar",
planarSources("studio/planar"),
"variant-2");
assertTrue(creation.writeResult().successful());
assertEquals(6, creation.pieceKeysByWorkcell().size());
assertEquals(
"theme/test/variants/end/variant-2",
"studio/planar/variants/end/variant-2",
creation.pieceKeysByWorkcell().get(JigsawPlanarArchetype.END.stableId()));
JsonObject piecePool = readJson(packRoot.resolve("jigsaw-pools/theme/test/pieces.json"));
JsonObject piecePool = readJson(packRoot.resolve("jigsaw-pools/studio/planar/pieces.json"));
JsonArray entries = piecePool.getAsJsonArray("pieces");
assertEquals("theme/test/end", entries.get(0).getAsJsonObject().get("piece").getAsString());
assertEquals("theme/test/variants/end/variant-2",
assertEquals("studio/planar/end", entries.get(0).getAsJsonObject().get("piece").getAsString());
assertEquals("studio/planar/variants/end/variant-2",
entries.get(1).getAsJsonObject().get("piece").getAsString());
assertEquals(4, entries.get(1).getAsJsonObject().get("weight").getAsInt());
assertEquals(0.35D, entries.get(1).getAsJsonObject().get("chance").getAsDouble(), 0D);
JsonObject duplicatedEnd = readJson(
packRoot.resolve("jigsaw-pieces/theme/test/variants/end/variant-2.json"));
packRoot.resolve("jigsaw-pieces/studio/planar/variants/end/variant-2.json"));
assertEquals(1, duplicatedEnd.getAsJsonArray("themes").size());
assertEquals("variant-2", duplicatedEnd.getAsJsonArray("themes").get(0).getAsString());
assertTrue(JigsawStudioGraphEditor.updatePieceThemes(
packRoot,
"theme/test",
"theme/test/blank",
"studio/planar",
"studio/planar/blank",
List.of()).successful());
JigsawStudioPieceRules terminalRules = new JigsawStudioPieceRules(0, 30, 0, 0, true);
assertTrue(JigsawStudioGraphEditor.updatePieceRules(
packRoot,
"theme/test",
"theme/test/end",
"studio/planar",
"studio/planar/end",
terminalRules).successful());
assertTrue(JigsawStudioGraphEditor.updatePieceRules(
packRoot,
"theme/test",
"theme/test/variants/end/variant-2",
"studio/planar",
"studio/planar/variants/end/variant-2",
terminalRules).successful());
assertTrue(JigsawStudioStructureEditor.updateThemeSets(
packRoot,
"theme/test",
"studio/planar",
List.of(
new IrisJigsawThemeSet("variant-1", 2),
new IrisJigsawThemeSet("variant-2", 3))).successful());
assertTrue(JigsawStudioStructureEditor.updateRequireCaps(
packRoot,
"theme/test",
"studio/planar",
true).successful());
JsonObject structure = readJson(packRoot.resolve("structures/theme/test.json"));
JsonObject structure = readJson(packRoot.resolve("structures/studio/planar.json"));
assertTrue(structure.get("requireCaps").getAsBoolean());
assertEquals("FAIL_ASSEMBLY", structure.get("branchFailurePolicy").getAsString());
assertEquals(3, structure.getAsJsonArray("themeSets").get(1)
.getAsJsonObject().get("weight").getAsInt());
JsonObject savedRules = readJson(packRoot.resolve("jigsaw-pieces/theme/test/end.json"))
JsonObject savedRules = readJson(packRoot.resolve("jigsaw-pieces/studio/planar/end.json"))
.getAsJsonObject("rules");
assertTrue(savedRules.get("terminal").getAsBoolean());
}
@@ -150,53 +183,53 @@ public class JigsawStudioPersistenceEditorsTest {
@Test
public void duplicateEndVariantCopiesPiecesAndCapsMembershipsExactly() throws Exception {
Path packRoot = createPlanarProject("variant/end");
String sourcePiece = "variant/end/end";
String targetPiece = "variant/end/variants/end/variant-2";
Path packRoot = createPlanarProject();
String sourcePiece = "studio/planar/end";
String targetPiece = "studio/planar/variants/end/variant-2";
assertTrue(JigsawStudioPoolEditor.updateWeightAtIndex(
packRoot,
"variant/end",
"variant/end/pieces",
"studio/planar",
"studio/planar/pieces",
0,
sourcePiece,
4).changed());
assertTrue(JigsawStudioPoolEditor.updateChanceAtIndex(
packRoot,
"variant/end",
"variant/end/pieces",
"studio/planar",
"studio/planar/pieces",
0,
sourcePiece,
0.35D).changed());
assertTrue(JigsawStudioPoolEditor.updateWeightAtIndex(
packRoot,
"variant/end",
"variant/end/caps",
"studio/planar",
"studio/planar/caps",
0,
sourcePiece,
7).changed());
assertTrue(JigsawStudioPoolEditor.updateChanceAtIndex(
packRoot,
"variant/end",
"variant/end/caps",
"studio/planar",
"studio/planar/caps",
0,
sourcePiece,
0.8D).changed());
StructureWriteResult duplicated = JigsawStudioGraphEditor.duplicatePiece(
packRoot,
"variant/end",
"studio/planar",
sourcePiece,
targetPiece);
assertTrue(duplicated.successful());
assertMembershipCopy(
packRoot.resolve("jigsaw-pools/variant/end/pieces.json"),
packRoot.resolve("jigsaw-pools/studio/planar/pieces.json"),
sourcePiece,
targetPiece,
4,
0.35D);
assertMembershipCopy(
packRoot.resolve("jigsaw-pools/variant/end/caps.json"),
packRoot.resolve("jigsaw-pools/studio/planar/caps.json"),
sourcePiece,
targetPiece,
7,
@@ -209,53 +242,53 @@ public class JigsawStudioPersistenceEditorsTest {
@Test
public void newCrossVariantCopiesStartAndPiecesMembershipsExactly() throws Exception {
Path packRoot = createPlanarProject("variant/cross");
String sourcePiece = "variant/cross/cross";
String targetPiece = "variant/cross/variants/cross/variant-2";
Path packRoot = createPlanarProject();
String sourcePiece = "studio/planar/cross";
String targetPiece = "studio/planar/variants/cross/variant-2";
assertTrue(JigsawStudioPoolEditor.updateWeightAtIndex(
packRoot,
"variant/cross",
"variant/cross/start",
"studio/planar",
"studio/planar/start",
0,
sourcePiece,
9).changed());
assertTrue(JigsawStudioPoolEditor.updateChanceAtIndex(
packRoot,
"variant/cross",
"variant/cross/start",
"studio/planar",
"studio/planar/start",
0,
sourcePiece,
0.6D).changed());
assertTrue(JigsawStudioPoolEditor.updateWeightAtIndex(
packRoot,
"variant/cross",
"variant/cross/pieces",
"studio/planar",
"studio/planar/pieces",
4,
sourcePiece,
5).changed());
assertTrue(JigsawStudioPoolEditor.updateChanceAtIndex(
packRoot,
"variant/cross",
"variant/cross/pieces",
"studio/planar",
"studio/planar/pieces",
4,
sourcePiece,
0.45D).changed());
StructureWriteResult created = JigsawStudioGraphEditor.createBlankVariant(
packRoot,
"variant/cross",
"studio/planar",
sourcePiece,
targetPiece);
assertTrue(created.successful());
assertMembershipCopy(
packRoot.resolve("jigsaw-pools/variant/cross/start.json"),
packRoot.resolve("jigsaw-pools/studio/planar/start.json"),
sourcePiece,
targetPiece,
9,
0.6D);
assertMembershipCopy(
packRoot.resolve("jigsaw-pools/variant/cross/pieces.json"),
packRoot.resolve("jigsaw-pools/studio/planar/pieces.json"),
sourcePiece,
targetPiece,
5,
@@ -267,16 +300,16 @@ public class JigsawStudioPersistenceEditorsTest {
@Test
public void deletesExactVariantMembershipsButProtectsFinalEnabledArchetype() throws Exception {
Path packRoot = createPlanarProject("delete/variant");
Path packRoot = createPlanarProject();
JigsawStudioGraphEditor.VariantFamilyCreation creation = JigsawStudioGraphEditor.duplicateActiveFamily(
packRoot,
"delete/variant",
planarSources("delete/variant"),
"studio/planar",
planarSources("studio/planar"),
"variant-2");
String corner = creation.pieceKeysByWorkcell().get(JigsawPlanarArchetype.CORNER.stableId());
JigsawStudioGraphEditor.PieceDeletionResult deleted =
JigsawStudioGraphEditor.deletePieceVariant(packRoot, "delete/variant", corner);
JigsawStudioGraphEditor.deletePieceVariant(packRoot, "studio/planar", corner);
assertTrue(deleted.writeResult().successful());
assertEquals(1, deleted.removedPoolMemberships());
@@ -290,23 +323,23 @@ public class JigsawStudioPersistenceEditorsTest {
IOException.class,
() -> JigsawStudioGraphEditor.deletePieceVariant(
packRoot,
"delete/variant",
"delete/variant/corner"));
"studio/planar",
"studio/planar/corner"));
assertTrue(failure.getMessage().contains("final variant for enabled planar workcell"));
}
@Test
public void projectDeletionPlansBlockReferencesAndRejectStaleGraphs() throws Exception {
Path packRoot = createPlanarProject("delete/project");
Path packRoot = createPlanarProject();
Path biome = packRoot.resolve("biomes/reference.json");
Files.createDirectories(biome.getParent());
Files.writeString(
biome,
"{\"structures\":[{\"structures\":[\"delete/project\"]}]}",
"{\"structures\":[{\"structures\":[\"studio/planar\"]}]}",
StandardCharsets.UTF_8);
JigsawStudioProjectDeletionService.DeletionPlan blocked =
JigsawStudioProjectDeletionService.inspect(packRoot, "delete/project");
JigsawStudioProjectDeletionService.inspect(packRoot, "studio/planar");
assertFalse(blocked.deletable());
assertEquals("biomes/reference.json", blocked.blockers().getFirst().ownerPath());
@@ -316,11 +349,11 @@ public class JigsawStudioPersistenceEditorsTest {
Files.delete(biome);
JigsawStudioProjectDeletionService.DeletionPlan stale =
JigsawStudioProjectDeletionService.inspect(packRoot, "delete/project");
JigsawStudioProjectDeletionService.inspect(packRoot, "studio/planar");
assertTrue(stale.deletable());
assertTrue(JigsawStudioStructureEditor.updateLimits(
packRoot,
"delete/project",
"studio/planar",
9,
8).successful());
IOException staleFailure = assertThrows(
@@ -329,21 +362,21 @@ public class JigsawStudioPersistenceEditorsTest {
assertTrue(staleFailure.getMessage().contains("changed after deletion was inspected"));
JigsawStudioProjectDeletionService.DeletionPlan current =
JigsawStudioProjectDeletionService.inspect(packRoot, "delete/project");
JigsawStudioProjectDeletionService.inspect(packRoot, "studio/planar");
JigsawStudioProjectDeletionService.ProjectDeletionResult deleted =
JigsawStudioProjectDeletionService.delete(current);
assertTrue(deleted.manifestRemoved());
assertTrue(deleted.removedResourceCount() > 0);
assertFalse(Files.exists(packRoot.resolve("structures/delete/project.json")));
assertFalse(Files.exists(packRoot.resolve("jigsaw-pools/delete/project/start.json")));
assertFalse(Files.exists(packRoot.resolve("structures/studio/planar.json")));
assertFalse(Files.exists(packRoot.resolve("jigsaw-pools/studio/planar/start.json")));
}
@Test
public void projectDeletionRejectsCoordinatedReferenceWrittenAfterInspectionWithoutRemovingOwnedBytes()
throws Exception {
String structureKey = "delete/coordinated-race";
Path packRoot = createPlanarProject(structureKey);
String structureKey = "studio/planar";
Path packRoot = createPlanarProject();
JigsawStudioProjectDeletionService.DeletionPlan plan =
JigsawStudioProjectDeletionService.inspect(packRoot, structureKey);
StructureTransactionWriter writer = new StructureTransactionWriter(packRoot);
@@ -378,8 +411,8 @@ public class JigsawStudioPersistenceEditorsTest {
@Test
public void projectDeletionThroughSymbolicPackRootFindsReverseReferences() throws Exception {
String structureKey = "delete/symbolic-blocked";
Path packRoot = createPlanarProject(structureKey);
String structureKey = "studio/planar";
Path packRoot = createPlanarProject();
Path biome = packRoot.resolve("biomes/reference.json");
Files.createDirectories(biome.getParent());
Files.writeString(
@@ -400,8 +433,8 @@ public class JigsawStudioPersistenceEditorsTest {
@Test
public void projectDeletionThroughSymbolicPackRootRemovesCompleteOwnedClosure() throws Exception {
String structureKey = "delete/symbolic-complete";
Path packRoot = createPlanarProject(structureKey);
String structureKey = "studio/planar";
Path packRoot = createPlanarProject();
StructureTransactionWriter writer = new StructureTransactionWriter(packRoot);
Path manifestPath = writer.ownershipManifestPath(StructureKey.parse(structureKey, "iris"));
StructureOwnershipManifest manifest = StructureOwnershipManifest.fromJson(
@@ -424,72 +457,60 @@ public class JigsawStudioPersistenceEditorsTest {
@Test
public void chanceUpdateRejectsStaleMembershipIdentityAndInvalidBounds() throws Exception {
Path packRoot = createPlanarProject("chance/test");
Path packRoot = createPlanarProject();
assertThrows(
IllegalArgumentException.class,
() -> JigsawStudioPoolEditor.updateChanceAtIndex(
packRoot,
"chance/test",
"chance/test/pieces",
"studio/planar",
"studio/planar/pieces",
0,
"chance/test/end",
"studio/planar/end",
Double.NaN));
IOException stale = assertThrows(
IOException.class,
() -> JigsawStudioPoolEditor.updateChanceAtIndex(
packRoot,
"chance/test",
"chance/test/pieces",
"studio/planar",
"studio/planar/pieces",
0,
"chance/test/straight",
"studio/planar/straight",
0.5D));
assertTrue(stale.getMessage().contains("changed before the update"));
}
@Test
public void createsSpatialThemeSetFromTheSelectedSpatialWorkcellSource() throws Exception {
Path packRoot = temporaryFolder.newFolder("spatial-theme").toPath();
JigsawStudioProjectCreator.Options options = new JigsawStudioProjectCreator.Options(
"spatial/theme",
JigsawStudioMode.SPATIAL_JIGSAW,
JigsawStudioCompatibilityTarget.IRIS_EXTENDED,
new JigsawStudioCellDimensions(16, 16, 16));
assertTrue(JigsawStudioProjectCreator.create(packRoot, options).successful());
Path packRoot = createSpatialProject("spatial-theme");
JigsawStudioGraphEditor.VariantFamilyCreation creation = JigsawStudioGraphEditor.duplicateActiveFamily(
packRoot,
"spatial/theme",
Map.of(JigsawStudioLayout.SPATIAL_WORKCELL_ID, "spatial/theme/start"),
"studio/spatial",
Map.of(JigsawStudioLayout.SPATIAL_WORKCELL_ID, "studio/spatial/start"),
"variant-2");
assertTrue(creation.writeResult().successful());
assertEquals(
"spatial/theme/variants/spatial/variant-2",
"studio/spatial/variants/spatial/variant-2",
creation.pieceKeysByWorkcell().get(JigsawStudioLayout.SPATIAL_WORKCELL_ID));
JsonObject pool = readJson(packRoot.resolve("jigsaw-pools/spatial/theme/start.json"));
JsonObject pool = readJson(packRoot.resolve("jigsaw-pools/studio/spatial/start.json"));
assertEquals(8, pool.getAsJsonArray("pieces").size());
}
@Test
public void createsSpatialThemeSetAcrossEveryDedicatedSpatialWorkcell() throws Exception {
Path packRoot = temporaryFolder.newFolder("spatial-theme-row").toPath();
JigsawStudioProjectCreator.Options options = new JigsawStudioProjectCreator.Options(
"spatial/row",
JigsawStudioMode.SPATIAL_JIGSAW,
JigsawStudioCompatibilityTarget.IRIS_EXTENDED,
new JigsawStudioCellDimensions(15, 15, 15));
assertTrue(JigsawStudioProjectCreator.create(packRoot, options).successful());
Path packRoot = createSpatialProject("spatial-theme-row");
Map<String, String> sources = new LinkedHashMap<>();
sources.put(JigsawStudioLayout.SPATIAL_WORKCELL_ID, "spatial/row/start");
sources.put(JigsawStudioLayout.SPATIAL_WORKCELL_ID, "studio/spatial/start");
for (int connectorCount = 1; connectorCount <= 6; connectorCount++) {
String pieceKey = "spatial/row/connectors-" + connectorCount;
String pieceKey = "studio/spatial/connectors-" + connectorCount;
sources.put(JigsawStudioLayout.SPATIAL_WORKCELL_ID + "/" + pieceKey, pieceKey);
}
JigsawStudioGraphEditor.VariantFamilyCreation creation = JigsawStudioGraphEditor.duplicateActiveFamily(
packRoot,
"spatial/row",
"studio/spatial",
sources,
"variant-2");
@@ -499,56 +520,50 @@ public class JigsawStudioPersistenceEditorsTest {
assertTrue(Files.isRegularFile(packRoot.resolve("jigsaw-pieces/" + targetPieceKey + ".json")));
assertTrue(Files.isRegularFile(packRoot.resolve("objects/" + targetPieceKey + ".iob")));
}
JsonObject pool = readJson(packRoot.resolve("jigsaw-pools/spatial/row/start.json"));
JsonObject pool = readJson(packRoot.resolve("jigsaw-pools/studio/spatial/start.json"));
assertEquals(14, pool.getAsJsonArray("pieces").size());
}
@Test
public void persistsVariantPlanarWorkcellAndSpatialWorkcellLabelsWithoutRewritingObjects() throws Exception {
Path planarRoot = createPlanarProject("labels/planar");
Path planarObject = planarRoot.resolve("objects/labels/planar/end.iob");
Path planarPool = planarRoot.resolve("jigsaw-pools/labels/planar/pieces.json");
Path planarRoot = createPlanarProject();
Path planarObject = planarRoot.resolve("objects/studio/planar/end.iob");
Path planarPool = planarRoot.resolve("jigsaw-pools/studio/planar/pieces.json");
byte[] objectBefore = Files.readAllBytes(planarObject);
byte[] poolBefore = Files.readAllBytes(planarPool);
assertTrue(JigsawStudioGraphEditor.updatePieceDisplayName(
planarRoot,
"labels/planar",
"labels/planar/end",
"studio/planar",
"studio/planar/end",
"Grand Longhouse").successful());
assertTrue(JigsawStudioStructureEditor.updateWorkcellDisplayName(
planarRoot,
"labels/planar",
"studio/planar",
JigsawPlanarArchetype.END,
"Village Entrances").successful());
assertArrayEquals(objectBefore, Files.readAllBytes(planarObject));
assertArrayEquals(poolBefore, Files.readAllBytes(planarPool));
assertEquals("Grand Longhouse", readJson(planarRoot.resolve(
"jigsaw-pieces/labels/planar/end.json")).get("displayName").getAsString());
JsonObject planarStructure = readJson(planarRoot.resolve("structures/labels/planar.json"));
"jigsaw-pieces/studio/planar/end.json")).get("displayName").getAsString());
JsonObject planarStructure = readJson(planarRoot.resolve("structures/studio/planar.json"));
assertEquals("Village Entrances", workcell(
planarStructure.getAsJsonArray("planarWorkcells"),
"END").get("displayName").getAsString());
Path spatialRoot = temporaryFolder.newFolder("labels-spatial").toPath();
JigsawStudioProjectCreator.Options spatialOptions = new JigsawStudioProjectCreator.Options(
"labels/spatial",
JigsawStudioMode.SPATIAL_JIGSAW,
JigsawStudioCompatibilityTarget.IRIS_EXTENDED,
new JigsawStudioCellDimensions(16, 16, 16));
assertTrue(JigsawStudioProjectCreator.create(spatialRoot, spatialOptions).successful());
Path spatialObject = spatialRoot.resolve("objects/labels/spatial/start.iob");
Path spatialRoot = createSpatialProject("labels-spatial");
Path spatialObject = spatialRoot.resolve("objects/studio/spatial/start.iob");
byte[] spatialBefore = Files.readAllBytes(spatialObject);
assertTrue(JigsawStudioStructureEditor.updateSpatialWorkcellDisplayName(
spatialRoot,
"labels/spatial",
"studio/spatial",
"Stronghold Rooms").successful());
assertArrayEquals(spatialBefore, Files.readAllBytes(spatialObject));
assertEquals("Stronghold Rooms", readJson(spatialRoot.resolve(
"structures/labels/spatial.json")).get("spatialWorkcellDisplayName").getAsString());
"structures/studio/spatial.json")).get("spatialWorkcellDisplayName").getAsString());
}
@Test
@@ -565,15 +580,27 @@ public class JigsawStudioPersistenceEditorsTest {
() -> JigsawStudioGraphEditor.normalizeDisplayName("§aFormatted"));
}
private Path createPlanarProject(String structureKey) throws Exception {
Path packRoot = temporaryFolder.newFolder(structureKey.replace('/', '-')).toPath();
JigsawStudioProjectCreator.Options options = new JigsawStudioProjectCreator.Options(
structureKey,
JigsawStudioMode.PLANAR_JIGSAW,
JigsawStudioCompatibilityTarget.IRIS_EXTENDED,
new JigsawStudioCellDimensions(16, 16, 16));
StructureWriteResult result = JigsawStudioProjectCreator.create(packRoot, options);
assertTrue(result.successful());
private Path createPlanarProject() throws Exception {
return copyPrototype(planarPrototype, "planar-pack");
}
private Path createSpatialProject(String folderName) throws Exception {
return copyPrototype(spatialPrototype, folderName);
}
private Path copyPrototype(Path prototype, String folderName) throws IOException {
Path packRoot = temporaryFolder.newFolder(folderName).toPath();
try (Stream<Path> entries = Files.walk(prototype)) {
for (Path entry : entries.toList()) {
Path destination = packRoot.resolve(prototype.relativize(entry).toString());
if (Files.isDirectory(entry)) {
Files.createDirectories(destination);
} else {
Files.createDirectories(destination.getParent());
Files.copy(entry, destination, StandardCopyOption.COPY_ATTRIBUTES);
}
}
}
return packRoot;
}
core/src/test/java/art/arcane/iris/core/runtime/jigsaw/JigsawStudioProjectCreatorTest.java
+47 -24
View File
@@ -13,6 +13,8 @@ import art.arcane.iris.util.common.math.IrisBlockVector;
import art.arcane.volmlib.util.math.RNG;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
@@ -21,7 +23,9 @@ import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.util.List;
import java.util.stream.Stream;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
@@ -31,9 +35,29 @@ import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
public class JigsawStudioProjectCreatorTest {
private static final JigsawStudioProjectCreator.Options DEFAULT_PLANAR_OPTIONS =
new JigsawStudioProjectCreator.Options(
"settlement/test",
JigsawStudioMode.PLANAR_JIGSAW,
JigsawStudioCompatibilityTarget.IRIS_EXTENDED,
new JigsawStudioCellDimensions(16, 16, 16));
@ClassRule
public static final TemporaryFolder prototypeFolder = new TemporaryFolder();
@Rule
public TemporaryFolder temporaryFolder = new TemporaryFolder();
private static Path defaultPlanarPrototype;
@BeforeClass
public static void createPrototypeProject() throws Exception {
defaultPlanarPrototype = prototypeFolder.newFolder("planar-prototype").toPath();
assertTrue(JigsawStudioProjectCreator.create(
defaultPlanarPrototype,
DEFAULT_PLANAR_OPTIONS).successful());
}
@Test
public void createsCompletePlanarProjectAtomicallyWithoutOverwritingIt() throws Exception {
Path temporaryDirectory = temporaryFolder.getRoot().toPath();
@@ -146,24 +170,18 @@ public class JigsawStudioProjectCreatorTest {
@Test
public void defaultIrisPlanarProjectCanEnableMandatoryCaps() throws Exception {
Path temporaryDirectory = temporaryFolder.getRoot().toPath();
JigsawStudioProjectCreator.Options options = new JigsawStudioProjectCreator.Options(
"caps/default",
JigsawStudioMode.PLANAR_JIGSAW,
JigsawStudioCompatibilityTarget.IRIS_EXTENDED,
new JigsawStudioCellDimensions(16, 16, 16));
Path temporaryDirectory = createDefaultPlanarProject();
assertTrue(JigsawStudioProjectCreator.create(temporaryDirectory, options).successful());
assertTrue(JigsawStudioStructureEditor.updateRequireCaps(
temporaryDirectory,
"caps/default",
"settlement/test",
true).successful());
JsonObject structure = JsonParser.parseString(Files.readString(
temporaryDirectory.resolve("structures/caps/default.json"),
temporaryDirectory.resolve("structures/settlement/test.json"),
StandardCharsets.UTF_8)).getAsJsonObject();
JsonObject end = JsonParser.parseString(Files.readString(
temporaryDirectory.resolve("jigsaw-pieces/caps/default/end.json"),
temporaryDirectory.resolve("jigsaw-pieces/settlement/test/end.json"),
StandardCharsets.UTF_8)).getAsJsonObject();
assertTrue(structure.get("requireCaps").getAsBoolean());
assertEquals("FAIL_ASSEMBLY", structure.get("branchFailurePolicy").getAsString());
@@ -266,13 +284,7 @@ public class JigsawStudioProjectCreatorTest {
@Test
public void updatesOwnedPoolThroughWholeGraphTransaction() throws Exception {
Path temporaryDirectory = temporaryFolder.getRoot().toPath();
JigsawStudioProjectCreator.Options options = new JigsawStudioProjectCreator.Options(
"settlement/test",
JigsawStudioMode.PLANAR_JIGSAW,
JigsawStudioCompatibilityTarget.IRIS_EXTENDED,
new JigsawStudioCellDimensions(16, 16, 16));
assertTrue(JigsawStudioProjectCreator.create(temporaryDirectory, options).successful());
Path temporaryDirectory = createDefaultPlanarProject();
Path pool = temporaryDirectory.resolve("jigsaw-pools/settlement/test/pieces.json");
StructureWriteResult terminalPool = JigsawStudioGraphEditor.createPool(
@@ -479,13 +491,7 @@ public class JigsawStudioProjectCreatorTest {
@Test
public void duplicatesVariantsAndEditsOnePinnedPoolEntry() throws Exception {
Path temporaryDirectory = temporaryFolder.getRoot().toPath();
JigsawStudioProjectCreator.Options options = new JigsawStudioProjectCreator.Options(
"settlement/test",
JigsawStudioMode.PLANAR_JIGSAW,
JigsawStudioCompatibilityTarget.IRIS_EXTENDED,
new JigsawStudioCellDimensions(16, 16, 16));
assertTrue(JigsawStudioProjectCreator.create(temporaryDirectory, options).successful());
Path temporaryDirectory = createDefaultPlanarProject();
List<String> pools = JigsawStudioGraphEditor.ownedPoolKeys(
temporaryDirectory,
@@ -552,4 +558,21 @@ public class JigsawStudioProjectCreatorTest {
StandardCharsets.UTF_8)).getAsJsonObject();
assertEquals(5, afterRemoval.getAsJsonArray("pieces").size());
}
private Path createDefaultPlanarProject() throws IOException {
Path packRoot = temporaryFolder.getRoot().toPath();
try (Stream<Path> entries = Files.walk(defaultPlanarPrototype)) {
for (Path entry : entries.toList()) {
Path destination = packRoot.resolve(
defaultPlanarPrototype.relativize(entry).toString());
if (Files.isDirectory(entry)) {
Files.createDirectories(destination);
} else {
Files.createDirectories(destination.getParent());
Files.copy(entry, destination, StandardCopyOption.COPY_ATTRIBUTES);
}
}
}
return packRoot;
}
}
core/src/test/java/art/arcane/iris/core/service/JigsawStudioResourceBundleAssemblerTest.java
+61 -31
View File
@@ -21,6 +21,8 @@ import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
@@ -30,10 +32,12 @@ import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.UUID;
import java.util.stream.Stream;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
@@ -43,13 +47,31 @@ import static org.junit.Assert.assertTrue;
public class JigsawStudioResourceBundleAssemblerTest {
private static final Gson PRETTY_GSON = new GsonBuilder().setPrettyPrinting().create();
private static final String STRUCTURE_KEY = "fort";
@ClassRule
public static final TemporaryFolder prototypeFolder = new TemporaryFolder();
@Rule
public TemporaryFolder temporaryFolder = new TemporaryFolder();
private static Path prototypePackRoot;
@BeforeClass
public static void createPrototypeProject() throws Exception {
prototypePackRoot = prototypeFolder.newFolder("prototype").toPath();
JigsawStudioProjectCreator.Options options = new JigsawStudioProjectCreator.Options(
STRUCTURE_KEY,
JigsawStudioMode.SPATIAL_JIGSAW,
JigsawStudioCompatibilityTarget.IRIS_EXTENDED,
new JigsawStudioCellDimensions(4, 4, 4));
StructureWriteResult result = JigsawStudioProjectCreator.create(prototypePackRoot, options);
assertTrue(result.successful());
}
@Test
public void assemblesAndAtomicallyOverwritesTheWholeOwnedGraph() throws Exception {
Path packRoot = createProject("fort");
Path packRoot = createProject();
Path structurePath = packRoot.resolve("structures/fort.json");
byte[] structureBefore = Files.readAllBytes(structurePath);
IrisJigsawConnector connector = connector();
@@ -120,8 +142,8 @@ public class JigsawStudioResourceBundleAssemblerTest {
@Test
public void capturePreservesAbsentDefaultsAndUnknownPieceMetadata() throws Exception {
Path packRoot = createProject("preserved");
String pieceResource = "jigsaw-pieces/preserved/start.json";
Path packRoot = createProject();
String pieceResource = "jigsaw-pieces/fort/start.json";
Path piecePath = packRoot.resolve(pieceResource);
JsonObject source = JsonParser.parseString(
Files.readString(piecePath, StandardCharsets.UTF_8)).getAsJsonObject();
@@ -135,8 +157,8 @@ public class JigsawStudioResourceBundleAssemblerTest {
JigsawStudioResourceBundleAssembler.Assembly unchangedAssembly =
JigsawStudioResourceBundleAssembler.assemble(
packRoot,
"preserved",
"preserved/start",
STRUCTURE_KEY,
"fort/start",
emptyObject(),
List.copyOf(sourcePiece.getConnectors()),
false);
@@ -144,14 +166,14 @@ public class JigsawStudioResourceBundleAssemblerTest {
sourceContent,
unchangedAssembly.bundle().resources().get(pieceResource).content());
IrisJigsawConnector updated = connector()
.setPool("preserved/start")
.setPool("fort/start")
.setName("iris:updated");
JigsawStudioResourceBundleAssembler.Assembly assembly =
JigsawStudioResourceBundleAssembler.assemble(
packRoot,
"preserved",
"preserved/start",
STRUCTURE_KEY,
"fort/start",
emptyObject(),
List.of(updated),
false);
@@ -172,15 +194,15 @@ public class JigsawStudioResourceBundleAssemblerTest {
@Test
public void refusesAProjectWithoutAnOwnershipManifest() throws Exception {
Path packRoot = createProject("unowned");
Path packRoot = createProject();
StructureTransactionWriter writer = new StructureTransactionWriter(packRoot);
Files.delete(writer.ownershipManifestPath(new StructureKey("iris", "unowned")));
Files.delete(writer.ownershipManifestPath(new StructureKey("iris", STRUCTURE_KEY)));
IOException exception = assertThrows(IOException.class,
() -> JigsawStudioResourceBundleAssembler.assemble(
packRoot,
"unowned",
"unowned/start",
STRUCTURE_KEY,
"fort/start",
emptyObject(),
List.of(connector()),
false));
@@ -190,16 +212,16 @@ public class JigsawStudioResourceBundleAssemblerTest {
@Test
public void refusesManagedDatapackOwnershipWithoutAssemblingAStudioSave() throws Exception {
Path packRoot = createProject("managed");
Path objectPath = packRoot.resolve("objects/managed/start.iob");
Path packRoot = createProject();
Path objectPath = packRoot.resolve("objects/fort/start.iob");
byte[] before = Files.readAllBytes(objectPath);
markManagedDatapack(packRoot, "managed");
markManagedDatapack(packRoot, STRUCTURE_KEY);
IOException exception = assertThrows(IOException.class,
() -> JigsawStudioResourceBundleAssembler.assemble(
packRoot,
"managed",
"managed/start",
STRUCTURE_KEY,
"fort/start",
emptyObject(),
List.of(connector()),
false));
@@ -211,16 +233,16 @@ public class JigsawStudioResourceBundleAssemblerTest {
@Test
public void writerRejectsAResourceModifiedOutsideTheOwnershipTransaction() throws Exception {
Path packRoot = createProject("modified");
Path piecePath = packRoot.resolve("jigsaw-pieces/modified/start.json");
Path packRoot = createProject();
Path piecePath = packRoot.resolve("jigsaw-pieces/fort/start.json");
Files.writeString(piecePath, Files.readString(piecePath, StandardCharsets.UTF_8) + "\n");
JigsawStudioResourceBundleAssembler.Assembly assembly =
JigsawStudioResourceBundleAssembler.assemble(
packRoot,
"modified",
"modified/start",
STRUCTURE_KEY,
"fort/start",
emptyObject(),
List.of(connector().setPool("modified/start")),
List.of(connector().setPool("fort/start")),
false);
StructureWriteResult result = new StructureTransactionWriter(packRoot)
@@ -231,18 +253,26 @@ public class JigsawStudioResourceBundleAssemblerTest {
assertFalse(result.conflicts().isEmpty());
}
private Path createProject(String structureKey) throws Exception {
Path packRoot = temporaryFolder.newFolder(structureKey).toPath();
JigsawStudioProjectCreator.Options options = new JigsawStudioProjectCreator.Options(
structureKey,
JigsawStudioMode.SPATIAL_JIGSAW,
JigsawStudioCompatibilityTarget.IRIS_EXTENDED,
new JigsawStudioCellDimensions(4, 4, 4));
StructureWriteResult result = JigsawStudioProjectCreator.create(packRoot, options);
assertTrue(result.successful());
private Path createProject() throws Exception {
Path packRoot = temporaryFolder.newFolder("pack").toPath();
copyTree(prototypePackRoot, packRoot);
return packRoot;
}
private static void copyTree(Path source, Path target) throws IOException {
try (Stream<Path> entries = Files.walk(source)) {
for (Path entry : entries.toList()) {
Path destination = target.resolve(source.relativize(entry).toString());
if (Files.isDirectory(entry)) {
Files.createDirectories(destination);
} else {
Files.createDirectories(destination.getParent());
Files.copy(entry, destination, StandardCopyOption.COPY_ATTRIBUTES);
}
}
}
}
private static void markManagedDatapack(Path packRoot, String structureKey) throws IOException {
StructureTransactionWriter writer = new StructureTransactionWriter(packRoot);
Path manifestPath = writer.ownershipManifestPath(new StructureKey("iris", structureKey));
core/src/test/java/art/arcane/iris/core/tools/IrisCreatorMultiverseRegistrationContractTest.java
-37
View File
@@ -1,37 +0,0 @@
package art.arcane.iris.core.tools;
import org.junit.Test;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class IrisCreatorMultiverseRegistrationContractTest {
@Test
public void bukkitAndMultiverseRegistrationShareOneConfiguredName() throws IOException {
String source = compact(Files.readString(Path.of(System.getProperty("iris.irisCreatorSource"))));
assertTrue("bukkit.yml must be registered under the shared configured name",
source.contains("BukkitWorldConfiguration.register(BUKKIT_YML,registrationName,dimension,seed)"));
assertTrue("Multiverse must be registered under the same configured name",
source.contains(".updateWorld(createdWorld,registrationName,dimension)"));
assertFalse("Multiverse must never be registered under the transient created-world name",
source.contains(".updateWorld(createdWorld,dimension)"));
}
@Test
public void multiverseRollbackUsesTheSameConfiguredName() throws IOException {
String source = compact(Files.readString(Path.of(System.getProperty("iris.irisCreatorSource"))));
assertTrue("rollback must unregister the name creation registered",
source.contains(".removeFromConfig(IrisWorldStorage.configuredWorldName(worldKey,"
+ "IrisWorldStorage.levelRoot().getName()))"));
}
private static String compact(String source) {
return source.replaceAll("\\s+", "");
}
}
core/src/test/java/art/arcane/iris/core/tools/IrisCreatorProgressContractTest.java
-94
View File
@@ -1,94 +0,0 @@
package art.arcane.iris.core.tools;
import org.junit.Test;
import java.nio.file.Files;
import java.nio.file.Path;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class IrisCreatorProgressContractTest {
@Test
public void persistentCreateReportsTheWholeLifecycleInsteadOfOnlySpawnChunks() throws Exception {
String source = Files.readString(Path.of("src/main/java/art/arcane/iris/core/tools/IrisCreator.java")).replace("\r\n", "\n");
int startReporter = source.indexOf("WorldCreationProgressReporter.start(sender, name)");
int resolve = source.indexOf("0.02D, \"resolve_dimension\"", startReporter);
int validate = source.indexOf("0.06D, \"validate_pack\"", resolve);
int datapacks = source.indexOf("0.10D, \"install_datapacks\"", validate);
int pack = source.indexOf("0.26D, \"prepare_world_pack\"", datapacks);
int generator = source.indexOf("0.36D, \"prepare_generator\"", pack);
int createWorld = source.indexOf("0.44D, \"create_world\"", generator);
int register = source.indexOf("0.84D, \"register_world\"", createWorld);
int teleport = source.indexOf("0.92D, \"teleport_player\"", register);
int finalize = source.indexOf("0.99D, \"finalize\"", teleport);
int createReserved = source.indexOf("createReserved(worldKey, resolvedDimension, creationReporter)", validate);
int succeed = source.indexOf("creationReporter.succeed()", createReserved);
assertTrue(startReporter >= 0);
assertTrue(resolve > startReporter);
assertTrue(validate > resolve);
assertTrue(datapacks > validate);
assertTrue(pack > datapacks);
assertTrue(generator > pack);
assertTrue(createWorld > generator);
assertTrue(register > createWorld);
assertTrue(teleport > register);
assertTrue(finalize > teleport);
assertTrue(createReserved > validate);
assertTrue(succeed > createReserved);
assertTrue(source.contains("creationReporter.fail()"));
assertTrue(source.contains("Form.f(generated) + \"/\" + Form.f(required) + \" chunks)\""));
assertFalse(source.contains("RuntimeProgressMessages.WORLD_CREATE_ACTION"));
assertFalse(source.contains("RuntimeProgressMessages.WORLD_CREATE_CONSOLE"));
}
@Test
public void persistentCreateReadinessPrecedesSuccessRegistrationAndLeaseRelease() throws Exception {
String source = Files.readString(Path.of(System.getProperty("iris.irisCreatorSource")))
.replace("\r\n", "\n");
int acquireLease = source.indexOf("worldLease = coordinator.acquire(");
int createReserved = source.indexOf(
"createReserved(worldKey, resolvedDimension, creationReporter)",
acquireLease);
int reportSuccess = source.indexOf("creationReporter.succeed()", createReserved);
int releaseLease = source.indexOf("worldLease.close()", reportSuccess);
int createWorld = source.indexOf("INMS.get().createWorldAsync(wc, request)", createReserved);
int persistentGuard = source.indexOf("if (!studio && !benchmark) {", createWorld);
int awaitSpawn = source.indexOf("awaitInitialSpawnPreparation(access, name)", persistentGuard);
int creationDone = source.indexOf("done.set(true)", awaitSpawn);
int registerWorld = source.indexOf("BukkitWorldConfiguration.register(", creationDone);
int returnWorld = source.indexOf("return world;", registerWorld);
assertTrue(acquireLease >= 0);
assertTrue(createReserved > acquireLease);
assertTrue(reportSuccess > createReserved);
assertTrue(releaseLease > reportSuccess);
assertTrue(createWorld > createReserved);
assertTrue(persistentGuard > createWorld);
assertTrue(awaitSpawn > persistentGuard);
assertTrue(creationDone > awaitSpawn);
assertTrue(registerWorld > creationDone);
assertTrue(returnWorld > registerWorld);
}
@Test
public void spawnReadinessFailureReachesWorldCreationRollback() throws Exception {
String source = Files.readString(Path.of(System.getProperty("iris.irisCreatorSource")))
.replace("\r\n", "\n");
int awaitSpawn = source.indexOf("awaitInitialSpawnPreparation(access, name)");
int createReservedFailure = source.indexOf("} catch (Throwable failure) {", awaitSpawn);
int rollback = source.indexOf(
"rollbackWorldCreation(worldKey, world, stagedGenerator, storageRoot, bukkitRegistered, failure)",
createReservedFailure);
int rethrow = source.indexOf("throw irisException", rollback);
assertTrue(awaitSpawn >= 0);
assertTrue(createReservedFailure > awaitSpawn);
assertTrue(rollback > createReservedFailure);
assertTrue(rethrow > rollback);
}
}
core/src/test/java/art/arcane/iris/core/tools/IrisCreatorStudioGenerationHistoryContractTest.java
-28
View File
@@ -1,28 +0,0 @@
package art.arcane.iris.core.tools;
import org.junit.Test;
import java.nio.file.Files;
import java.nio.file.Path;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class IrisCreatorStudioGenerationHistoryContractTest {
@Test
public void studioPublishesHistoryBeforePreparingItsGeneratorAndKeepsTheAuthoringSource() throws Exception {
Path creatorPath = Path.of(System.getProperty("iris.irisCreatorSource"));
String creator = Files.readString(creatorPath);
String factory = Files.readString(creatorPath.resolveSibling("IrisWorldCreator.java"));
int snapshot = creator.indexOf("studioService.installIntoWorld(sender, resolvedDimension, dimensionRoot, seed)");
int generator = creator.indexOf("new IrisWorldCreator()");
assertTrue(snapshot >= 0);
assertTrue(generator > snapshot);
assertFalse(creator.contains("if (!studio() || benchmark)"));
assertTrue(creator.contains(".dimension(installedDimension)"));
assertTrue(creator.contains(".studioPackSource(resolvedDimension.getLoader().getDataFolder())"));
assertTrue(factory.contains("GenerationHistory generationHistory = persistent || studio"));
assertTrue(factory.contains("File packRoot = studio\n ? Objects.requireNonNull(studioPackSource, \"Studio authoring source\")"));
}
}
core/src/test/java/art/arcane/iris/core/tools/IrisPackBenchmarkingLifecycleContractTest.java
-62
View File
@@ -1,62 +0,0 @@
package art.arcane.iris.core.tools;
import org.junit.Test;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import static org.junit.Assert.assertTrue;
public class IrisPackBenchmarkingLifecycleContractTest {
@Test
public void benchmarkAppliesProfileBeforeCreatingItsWorld() throws IOException {
String source = Files.readString(Path.of(System.getProperty("iris.packBenchmarkingSource")));
String runBenchmark = method(source, "private void runBenchmark()");
assertBefore(runBenchmark, "IrisToolbelt.applyPregenPerformanceProfile()", "createBenchmark()");
}
@Test
public void liveEngineProfileUsesTheBoundPlatformGenerator() throws IOException {
String source = Files.readString(Path.of(System.getProperty("iris.irisToolbeltSource")));
String applyProfile = method(source, "public static void applyPregenPerformanceProfile(Engine engine)");
assertBefore(applyProfile, "PregenPerformanceProfile.applyToGenerator(generator)", "PregenPerformanceProfile.apply(engine)");
}
@Test
public void bukkitComplexHotloadUsesExclusiveGenerationControl() throws IOException {
String source = Files.readString(Path.of(System.getProperty("iris.bukkitChunkGeneratorSource")));
String hotload = method(source, "public CompletableFuture<Void> hotloadComplexAsync(long acquisitionTimeout, TimeUnit unit)");
assertTrue(hotload.contains("withExclusiveControlFuture(activeEngine::hotloadComplex, acquisitionTimeout, unit)"));
}
private static void assertBefore(String source, String first, String second) {
int firstIndex = source.indexOf(first);
int secondIndex = source.indexOf(second);
assertTrue(firstIndex >= 0);
assertTrue(secondIndex > firstIndex);
}
private static String method(String source, String signature) {
int start = source.indexOf(signature);
assertTrue(start >= 0);
int openingBrace = source.indexOf('{', start);
assertTrue(openingBrace >= 0);
int depth = 0;
for (int index = openingBrace; index < source.length(); index++) {
char character = source.charAt(index);
if (character == '{') {
depth++;
} else if (character == '}') {
depth--;
if (depth == 0) {
return source.substring(start, index + 1);
}
}
}
throw new AssertionError("Method body did not close: " + signature);
}
}
core/src/test/java/art/arcane/iris/core/tools/IrisToolbeltShutdownContractTest.java
-26
View File
@@ -1,26 +0,0 @@
package art.arcane.iris.core.tools;
import org.junit.Test;
import java.nio.file.Files;
import java.nio.file.Path;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class IrisToolbeltShutdownContractTest {
@Test
public void disabledPluginDoesNotImplyServerShutdown() throws Exception {
String source = Files.readString(Path.of(System.getProperty("iris.irisToolbeltSource")));
int start = source.indexOf("public static boolean isServerStopping()");
int end = source.indexOf("public static void beginWorldMaintenance", start);
assertTrue(start >= 0);
assertTrue(end > start);
String stopping = source.substring(start, end);
assertTrue(stopping.contains("return INMS.isBound() && INMS.get().isServerStopping();"));
assertFalse(stopping.contains("isEnabled()"));
assertFalse(stopping.contains("hasPlugin()"));
assertFalse(stopping.contains("getMethod("));
}
}
core/src/test/java/art/arcane/iris/engine/actuator/IrisDimensionStackActuatorMetadataTest.java
+31
View File
@@ -1,6 +1,10 @@
package art.arcane.iris.engine.actuator;
import art.arcane.iris.engine.hydrology.cave.HydrologyCaveCell;
import art.arcane.iris.spi.IrisPlatform;
import art.arcane.iris.spi.IrisPlatforms;
import art.arcane.iris.spi.PlatformBlockState;
import art.arcane.iris.spi.PlatformRegistries;
import art.arcane.iris.engine.hydrology.cave.HydrologyCaveAction;
import art.arcane.iris.engine.mantle.TerrainMatterView;
import art.arcane.iris.util.project.matter.IrisMatterSupport;
@@ -10,19 +14,46 @@ import art.arcane.volmlib.util.matter.MatterCavern;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import art.arcane.volmlib.util.mantle.runtime.MantleChunk;
import art.arcane.volmlib.util.matter.Matter;
import art.arcane.volmlib.util.matter.MatterSlice;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
public class IrisDimensionStackActuatorMetadataTest {
@Before
public void bindPlatform() {
IrisPlatforms.unbind();
Map<String, PlatformBlockState> states = new HashMap<>();
PlatformRegistries registries = mock(PlatformRegistries.class);
when(registries.block(anyString())).thenAnswer(invocation -> states.computeIfAbsent(
invocation.getArgument(0),
key -> {
PlatformBlockState state = mock(PlatformBlockState.class);
when(state.key()).thenReturn(key);
return state;
}));
IrisPlatform platform = mock(IrisPlatform.class);
when(platform.registries()).thenReturn(registries);
IrisPlatforms.bind(platform);
}
@After
public void unbindPlatform() {
IrisPlatforms.unbind();
}
@Test
@SuppressWarnings("unchecked")
public void stackCleanupPersistsNaturalCarveAndFluidFactsForLaterRerenders() throws IOException {
core/src/test/java/art/arcane/iris/engine/hydrology/HydrologyPlannerGlobalInvariantTest.java
+1 -1
View File
@@ -607,7 +607,7 @@ public class HydrologyPlannerGlobalInvariantTest {
assertTrue(sources.stream().anyMatch((HydrologyPoint point) -> point.x() >= 0));
assertTrue(sources.stream().anyMatch((HydrologyPoint point) -> point.z() < 0));
ArrayList<HydrologyTileKey> positiveKeys = new ArrayList<>();
for (HydrologyTileKey key : keys) {
for (HydrologyTileKey key : tileKeys(1)) {
positiveKeys.add(new HydrologyTileKey(key.tileX(), key.tileZ() + 8));
}
HydrologyPlanner positivePlanner = new HydrologyPlanner(
core/src/test/java/art/arcane/iris/engine/hydrology/HydrologyPlannerTest.java
+38 -33
View File
@@ -46,6 +46,13 @@ import static org.junit.Assert.assertTrue;
public class HydrologyPlannerTest {
private static final HydrologyTileKey TILE = new HydrologyTileKey(0, 0);
private static final HydrologyTileKey EARLY_OWNER_TILE = new HydrologyTileKey(-1, -1);
private static final HydrologyPlannerSettings EARLY_OWNER_SETTINGS =
withPeriodTwo(standardSettings(4D, 2D, true, false, List.of()));
private static final HydrologyTerrainSampler EARLY_OWNER_TERRAIN =
shiftedByTile(rollingCoast(112), EARLY_OWNER_SETTINGS.routing().tileSize());
private static final HydrologyTile EARLY_OWNER_BASELINE =
new HydrologyPlanner(77L, EARLY_OWNER_SETTINGS, EARLY_OWNER_TERRAIN).plan(EARLY_OWNER_TILE);
@Test
public void sharedOwnerFutureExcludesMutableCompilerWhileCreatorRetainsIt() throws Exception {
@@ -296,33 +303,34 @@ public class HydrologyPlannerTest {
@Test
public void earlyNeighborOwnersPreserveCompleteColdOwnerOutputs() throws Exception {
HydrologyTileKey key = new HydrologyTileKey(-1, -1);
Set<Thread> parallelThreads = ConcurrentHashMap.newKeySet();
boolean observedParallelOwner = false;
ForkJoinPool pool = new ForkJoinPool(4);
try {
for (boolean organic : new boolean[]{false, true}) {
HydrologyPlannerSettings settings = organic ? organicShapeSettings()
: standardSettings(4D, 2D, true, false, List.of());
settings = withPeriodTwo(settings);
long seed = organic ? 642L : 77L;
HydrologyPlannerSettings settings = organic
? withPeriodTwo(organicShapeSettings())
: EARLY_OWNER_SETTINGS;
assertEquals(2, settings.crossTileColorPeriod());
HydrologyTerrainSampler original = organic ? organicShapeTerrain() : rollingCoast(112);
int tileSize = settings.routing().tileSize();
HydrologyTerrainSampler terrain = (x, z) -> original.sample(x + tileSize, z + tileSize);
HydrologyTerrainSampler counted = (x, z) -> {
HydrologyTerrainSampler terrain = organic
? shiftedByTile(organicShapeTerrain(), settings.routing().tileSize())
: EARLY_OWNER_TERRAIN;
HydrologyTile expected = organic
? new HydrologyPlanner(seed, settings, terrain).plan(EARLY_OWNER_TILE)
: EARLY_OWNER_BASELINE;
HydrologyTerrainSampler counted = (int x, int z) -> {
parallelThreads.add(Thread.currentThread());
return terrain.sample(x, z);
};
for (long seed : new long[]{19L, 77L, 642L}) {
HydrologyTile expected = new HydrologyPlanner(seed, settings, terrain).plan(key);
HydrologyPlanner candidate = new HydrologyPlanner(seed, settings, counted);
parallelThreads.clear();
HydrologyTile actual = pool.submit(() -> candidate.plan(key)).get(30, TimeUnit.SECONDS);
observedParallelOwner |= parallelThreads.size() > 1;
assertTileContentsEqual(expected, actual);
assertEquals(expected.courses(), actual.courses());
assertEquals(expected.diagnosticCandidates(), actual.diagnosticCandidates());
}
HydrologyPlanner candidate = new HydrologyPlanner(seed, settings, counted);
parallelThreads.clear();
HydrologyTile actual = pool.submit(() -> candidate.plan(EARLY_OWNER_TILE))
.get(30, TimeUnit.SECONDS);
observedParallelOwner |= parallelThreads.size() > 1;
assertTileContentsEqual(expected, actual);
assertEquals(expected.courses(), actual.courses());
assertEquals(expected.diagnosticCandidates(), actual.diagnosticCandidates());
}
} finally {
pool.shutdownNow();
@@ -332,30 +340,23 @@ public class HydrologyPlannerTest {
@Test
public void earlyOwnersCompleteWithOneWorkerAndSaturatedRootCallers() throws Exception {
HydrologyTileKey key = new HydrologyTileKey(-1, -1);
HydrologyPlannerSettings settings = standardSettings(4D, 2D, true, false, List.of());
settings = withPeriodTwo(settings);
int tileSize = settings.routing().tileSize();
HydrologyTerrainSampler base = rollingCoast(112);
HydrologyTerrainSampler terrain = (x, z) -> base.sample(x + tileSize, z + tileSize);
HydrologyTile expected = new HydrologyPlanner(77L, settings, terrain).plan(key);
for (int workers : new int[]{1, 2}) {
ForkJoinPool pool = new ForkJoinPool(workers);
CountDownLatch started = new CountDownLatch(workers);
ArrayList<Future<HydrologyTile>> results = new ArrayList<>();
try {
HydrologyPlanner shared = new HydrologyPlanner(77L, settings, terrain);
HydrologyPlanner shared = new HydrologyPlanner(77L, EARLY_OWNER_SETTINGS, EARLY_OWNER_TERRAIN);
for (int index = 0; index < workers; index++) {
results.add(pool.submit(() -> {
started.countDown();
if (!started.await(5, TimeUnit.SECONDS)) {
throw new AssertionError("Owner callers did not start");
}
return shared.plan(key);
return shared.plan(EARLY_OWNER_TILE);
}));
}
for (Future<HydrologyTile> result : results) {
assertTileContentsEqual(expected, result.get(30, TimeUnit.SECONDS));
assertTileContentsEqual(EARLY_OWNER_BASELINE, result.get(30, TimeUnit.SECONDS));
}
} finally {
pool.shutdownNow();
@@ -363,6 +364,10 @@ public class HydrologyPlannerTest {
}
}
private static HydrologyTerrainSampler shiftedByTile(HydrologyTerrainSampler sampler, int tileSize) {
return (int x, int z) -> sampler.sample(x + tileSize, z + tileSize);
}
private static void assertTileContentsEqual(HydrologyTile expected, HydrologyTile actual) {
assertEquals("nodes", expected.nodes(), actual.nodes());
assertEquals("edges", expected.edges(), actual.edges());
@@ -2536,7 +2541,7 @@ public class HydrologyPlannerTest {
return distance < 80 ? 106 : 98;
}
private HydrologyPlannerSettings standardSettings(
private static HydrologyPlannerSettings standardSettings(
double surfaceDensity,
double undergroundDensity,
boolean oceanEnabled,
@@ -2605,7 +2610,7 @@ public class HydrologyPlannerTest {
);
}
private HydrologyPlannerSettings.Geometry stableGeometry() {
private static HydrologyPlannerSettings.Geometry stableGeometry() {
HydrologyPlannerSettings.ChannelShape stableChannel =
HydrologyPlannerSettings.ChannelShape.of(2D, 0D, 0D, 11);
return new HydrologyPlannerSettings.Geometry(
@@ -2678,7 +2683,7 @@ public class HydrologyPlannerTest {
};
}
private HydrologyTerrainSampler rollingCoast(int coastX) {
private static HydrologyTerrainSampler rollingCoast(int coastX) {
return (int x, int z) -> {
if (x >= coastX) {
return oceanTerrain();
@@ -2771,7 +2776,7 @@ public class HydrologyPlannerTest {
};
}
private HydrologyTerrainSample oceanTerrain() {
private static HydrologyTerrainSample oceanTerrain() {
return new HydrologyTerrainSample(
54,
0D,
@@ -2843,7 +2848,7 @@ public class HydrologyPlannerTest {
);
}
private HydrologyTerrainSample terrain(
private static HydrologyTerrainSample terrain(
int height,
double slope,
boolean ocean,
core/src/test/java/art/arcane/iris/engine/hydrology/HydrologyPlannerTributaryTest.java
+4 -4
View File
@@ -12,6 +12,8 @@ import static org.junit.Assert.assertTrue;
public class HydrologyPlannerTributaryTest {
private static final HydrologyTileKey TILE = new HydrologyTileKey(0, 0);
private static final HydrologyTile SPLIT_TILE =
new HydrologyPlanner(19L, settings(1), HydrologyPlannerTributaryTest::valley).plan(TILE);
@Test
public void heightOnlySamplingPreservesSurfacePlansWithFewerSlopeSamples() {
@@ -51,7 +53,7 @@ public class HydrologyPlannerTributaryTest {
HydrologyTerrainSampler terrain = HydrologyPlannerTributaryTest::valley;
HydrologyTile single = new HydrologyPlanner(19L, settings(0), terrain).plan(TILE);
HydrologyTile split = new HydrologyPlanner(19L, settings(1), terrain).plan(TILE);
HydrologyTile split = SPLIT_TILE;
List<RiverCourse> singleCourses = surface(single);
List<RiverCourse> splitCourses = surface(split);
@@ -302,9 +304,7 @@ public class HydrologyPlannerTributaryTest {
}
@Test
public void aTributaryOwnsOnlyTheDrainageUpstreamOfItsJunctionAndMeetsTheStemWater() {
HydrologyTerrainSampler terrain = HydrologyPlannerTributaryTest::valley;
HydrologyTile split = new HydrologyPlanner(19L, settings(1), terrain).plan(TILE);
HydrologyTile split = SPLIT_TILE;
List<RiverCourse> courses = surface(split);
assertEquals(split.diagnosticCandidates().toString(), 2, courses.size());
core/src/test/java/art/arcane/iris/engine/hydrology/HydrologyTileCacheTest.java
+38 -3
View File
@@ -16,6 +16,7 @@ import java.util.Set;
import java.util.UUID;
import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ExecutionException;
@@ -1138,7 +1139,7 @@ public class HydrologyTileCacheTest {
List<HydrologyTileKey> planned = java.util.Collections.synchronizedList(new ArrayList<>());
doAnswer(invocation -> {
peak.accumulateAndGet(inFlight.incrementAndGet(), Math::max);
Thread.sleep(20L);
awaitConcurrentPlan(inFlight, 20L);
planned.add(invocation.getArgument(0));
inFlight.decrementAndGet();
return tile;
@@ -1161,6 +1162,36 @@ public class HydrologyTileCacheTest {
}
}
private static void awaitConcurrentPlan(AtomicInteger inFlight, long boundMillis) throws InterruptedException {
long deadline = System.nanoTime() + TimeUnit.MILLISECONDS.toNanos(boundMillis);
while (inFlight.get() < 2 && System.nanoTime() < deadline) {
Thread.sleep(1L);
}
}
private static void awaitParkedCallers(List<Thread> callers, int expected) throws InterruptedException {
long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(5);
while (System.nanoTime() < deadline) {
if (callers.size() == expected && allParked(callers)) {
return;
}
Thread.sleep(1L);
}
throw new AssertionError("Callers did not park on the in-flight plan");
}
private static boolean allParked(List<Thread> callers) {
for (Thread caller : callers) {
Thread.State state = caller.getState();
if (state != Thread.State.WAITING
&& state != Thread.State.TIMED_WAITING
&& state != Thread.State.BLOCKED) {
return false;
}
}
return true;
}
@Test
public void tileBatchesWithoutAPrefetchExecutorPlanInlineInKeyOrder() {
HydrologyPlanner planner = mock(HydrologyPlanner.class);
@@ -1198,11 +1229,15 @@ public class HydrologyTileCacheTest {
HydrologyTileKey key = new HydrologyTileKey(5, 5);
ExecutorService callers = Executors.newFixedThreadPool(3);
try {
List<Thread> callerThreads = new CopyOnWriteArrayList<>();
List<Future<List<HydrologyTile>>> results = new ArrayList<>();
for (int caller = 0; caller < 3; caller++) {
results.add(callers.submit(() -> cache.tiles(List.of(key))));
results.add(callers.submit(() -> {
callerThreads.add(Thread.currentThread());
return cache.tiles(List.of(key));
}));
}
Thread.sleep(100L);
awaitParkedCallers(callerThreads, 3);
release.countDown();
for (Future<List<HydrologyTile>> result : results) {
assertSame(tile, result.get(5, TimeUnit.SECONDS).getFirst());
core/src/test/java/art/arcane/iris/engine/mantle/EngineMantleCoverageTest.java
+31
View File
@@ -1,13 +1,21 @@
package art.arcane.iris.engine.mantle;
import art.arcane.iris.engine.IrisEngineMantle;
import art.arcane.iris.spi.IrisPlatform;
import art.arcane.iris.spi.IrisPlatforms;
import art.arcane.iris.spi.PlatformBlockState;
import art.arcane.iris.spi.PlatformRegistries;
import art.arcane.volmlib.util.mantle.flag.MantleFlag;
import art.arcane.volmlib.util.mantle.runtime.Mantle;
import art.arcane.volmlib.util.mantle.runtime.MantleChunk;
import art.arcane.volmlib.util.matter.Matter;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
@@ -18,6 +26,7 @@ import static org.junit.Assert.assertTrue;
import static org.mockito.Answers.CALLS_REAL_METHODS;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doReturn;
@@ -25,6 +34,28 @@ import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class EngineMantleCoverageTest {
@Before
public void bindPlatform() {
IrisPlatforms.unbind();
Map<String, PlatformBlockState> states = new HashMap<>();
PlatformRegistries registries = mock(PlatformRegistries.class);
when(registries.block(anyString())).thenAnswer(invocation -> states.computeIfAbsent(
invocation.getArgument(0),
key -> {
PlatformBlockState state = mock(PlatformBlockState.class);
when(state.key()).thenReturn(key);
return state;
}));
IrisPlatform platform = mock(IrisPlatform.class);
when(platform.registries()).thenReturn(registries);
IrisPlatforms.bind(platform);
}
@After
public void unbindPlatform() {
IrisPlatforms.unbind();
}
@Test
public void zeroRadiusCleansOnlyItsRealChunkOnce() {
CoverageFixture fixture = fixture(0);
core/src/test/java/art/arcane/iris/engine/mantle/components/IrisCaveCarver3DNearParityTest.java
+53 -37
View File
@@ -36,6 +36,7 @@ import java.util.Set;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.TimeUnit;
@@ -63,6 +64,9 @@ public class IrisCaveCarver3DNearParityTest {
private static Method aquiferCupSupportMethod;
private static Method deepAdaptivePlaneMethod;
private static Field baseDensityField;
private static Field detailDensityField;
private static Field modulesField;
private static Field moduleDensityField;
private static Field engineField;
private static Field dataField;
private static Field profileField;
@@ -97,6 +101,12 @@ public class IrisCaveCarver3DNearParityTest {
deepAdaptivePlaneMethod.setAccessible(true);
baseDensityField = IrisCaveCarver3D.class.getDeclaredField("baseDensity");
baseDensityField.setAccessible(true);
detailDensityField = IrisCaveCarver3D.class.getDeclaredField("detailDensity");
detailDensityField.setAccessible(true);
modulesField = IrisCaveCarver3D.class.getDeclaredField("modules");
modulesField.setAccessible(true);
moduleDensityField = CaveFieldModuleState.class.getDeclaredField("density");
moduleDensityField.setAccessible(true);
engineField = IrisCaveCarver3D.class.getDeclaredField("engine");
engineField.setAccessible(true);
dataField = IrisCaveCarver3D.class.getDeclaredField("data");
@@ -774,30 +784,29 @@ public class IrisCaveCarver3DNearParityTest {
double[] columnWeights = fullWeights();
int[] precomputedSurfaceHeights = filledHeights(92);
IrisRange worldYRange = new IrisRange(0D, 96D);
AtomicLong optimizedSamples = new AtomicLong();
AtomicLong naiveSamples = new AtomicLong();
countSkippableSamples(optimizedCarver, optimizedSamples);
countSkippableSamples(naiveCarver, naiveSamples);
for (int warmup = 0; warmup < 4; warmup++) {
runOptimizedOnce(optimizedCarver, 3, -2, columnWeights, worldYRange, precomputedSurfaceHeights, 128);
runNaiveOnce(naiveCarver, 3, -2, columnWeights, worldYRange, precomputedSurfaceHeights, 128);
}
WriterCapture optimizedCapture = createWriterCapture(128);
int optimizedCarved = optimizedCarver.carve(optimizedCapture.writer, 3, -2, columnWeights, 0D, 0D,
worldYRange, precomputedSurfaceHeights);
WriterCapture naiveCapture = createWriterCapture(128);
int naiveCarved = carveNaiveExact(naiveCarver, naiveCapture.writer, 3, -2, columnWeights,
worldYRange, precomputedSurfaceHeights);
long optimizedTime = Long.MAX_VALUE;
long naiveTime = Long.MAX_VALUE;
for (int iteration = 0; iteration < 10; iteration++) {
if ((iteration & 1) == 0) {
optimizedTime = Math.min(optimizedTime, runOptimizedOnce(optimizedCarver, 3, -2, columnWeights, worldYRange, precomputedSurfaceHeights, 128));
naiveTime = Math.min(naiveTime, runNaiveOnce(naiveCarver, 3, -2, columnWeights, worldYRange, precomputedSurfaceHeights, 128));
continue;
}
assertTrue(optimizedCarved > 0);
assertEquals(naiveCarved, optimizedCarved);
assertEquals(naiveCapture.carvedCells, optimizedCapture.carvedCells);
assertEquals(naiveCapture.carvedLiquids, optimizedCapture.carvedLiquids);
naiveTime = Math.min(naiveTime, runNaiveOnce(naiveCarver, 3, -2, columnWeights, worldYRange, precomputedSurfaceHeights, 128));
optimizedTime = Math.min(optimizedTime, runOptimizedOnce(optimizedCarver, 3, -2, columnWeights, worldYRange, precomputedSurfaceHeights, 128));
}
// Fastest of ten alternating runs, not the sum: one scheduling hiccup decides a summed comparison.
// The bar is deliberately well under the measured ratio; a loaded machine reaches 1.6x while a
// regression that drops the skip logic lands at 1.0x, which is what this guard has to catch.
double speedup = naiveTime / (double) optimizedTime;
assertTrue("expected at least 1.4x speedup but was " + speedup, speedup >= 1.4D);
long optimizedSampleCount = optimizedSamples.get();
long naiveSampleCount = naiveSamples.get();
assertTrue(optimizedSampleCount > 0L);
double sampleRatio = naiveSampleCount / (double) optimizedSampleCount;
assertTrue("expected at least 1.4x fewer detail and module samples but was " + sampleRatio,
sampleRatio >= 1.4D);
}
@Test
@@ -879,28 +888,18 @@ public class IrisCaveCarver3DNearParityTest {
assertEquals(optimizedCapture.carvedLiquids, naiveCapture.carvedLiquids);
}
private long runOptimizedOnce(IrisCaveCarver3D carver, int chunkX, int chunkZ, double[] columnWeights, IrisRange worldYRange, int[] precomputedSurfaceHeights, int worldHeight) {
WriterCapture capture = createWriterCapture(worldHeight);
long start = System.nanoTime();
carver.carve(capture.writer, chunkX, chunkZ, columnWeights, 0D, 0D, worldYRange, precomputedSurfaceHeights);
long elapsed = System.nanoTime() - start;
assertTrue(!capture.carvedCells.isEmpty());
return elapsed;
private void countSkippableSamples(IrisCaveCarver3D carver, AtomicLong samples) throws Exception {
detailDensityField.set(carver, new CountingCNG((CNG) detailDensityField.get(carver), samples));
CaveFieldModuleState[] modules = (CaveFieldModuleState[]) modulesField.get(carver);
for (CaveFieldModuleState module : modules) {
moduleDensityField.set(module, new CountingCNG((CNG) moduleDensityField.get(module), samples));
}
}
private double sampleDensity(IrisCaveCarver3D carver, int x, int y, int z) throws Exception {
return (double) sampleDensityMethod.invoke(carver, x, y, z);
}
private long runNaiveOnce(IrisCaveCarver3D carver, int chunkX, int chunkZ, double[] columnWeights, IrisRange worldYRange, int[] precomputedSurfaceHeights, int worldHeight) throws Exception {
WriterCapture capture = createWriterCapture(worldHeight);
long start = System.nanoTime();
int carved = carveNaiveExact(carver, capture.writer, chunkX, chunkZ, columnWeights, worldYRange, precomputedSurfaceHeights);
long elapsed = System.nanoTime() - start;
assertTrue(carved > 0);
return elapsed;
}
private int carveNaiveExact(IrisCaveCarver3D carver, MantleWriter writer, int chunkX, int chunkZ, double[] columnWeights, IrisRange worldYRange, int[] precomputedSurfaceHeights) throws Exception {
Engine engine = (Engine) engineField.get(carver);
IrisData data = (IrisData) dataField.get(carver);
@@ -1516,6 +1515,23 @@ public class IrisCaveCarver3DNearParityTest {
return min;
}
private static final class CountingCNG extends CNG {
private final CNG delegate;
private final AtomicLong samples;
private CountingCNG(CNG delegate, AtomicLong samples) {
super(new RNG(41_117L));
this.delegate = delegate;
this.samples = samples;
}
@Override
public double noiseFastSigned3D(double x, double y, double z) {
samples.incrementAndGet();
return delegate.noiseFastSigned3D(x, y, z);
}
}
private static final class CoordinateDensityCNG extends CNG {
private final Map<String, Double> densityByCoordinate;
private final List<String> sampledCoordinates = new ArrayList<>();
core/src/test/java/art/arcane/iris/engine/modifier/IrisDepositModifierOrderingTest.java
+154 -4
View File
@@ -105,10 +105,160 @@ public class IrisDepositModifierOrderingTest {
}
private static PlatformBlockState state(String material) {
PlatformBlockState state = mock(PlatformBlockState.class);
when(state.key()).thenReturn("minecraft:" + material);
when(state.materialKey()).thenReturn("minecraft:" + material);
return state;
return new KeyedBlockState("minecraft:" + material);
}
private static final class KeyedBlockState implements PlatformBlockState {
private final String key;
private KeyedBlockState(String key) {
this.key = key;
}
@Override
public String key() {
return key;
}
@Override
public String namespace() {
return null;
}
@Override
public String materialKey() {
return key;
}
@Override
public boolean isAir() {
return false;
}
@Override
public boolean isSolid() {
return false;
}
@Override
public boolean isOccluding() {
return false;
}
@Override
public boolean isCustom() {
return false;
}
@Override
public String deferredPlacementKey() {
return null;
}
@Override
public PlatformBlockState placementBaseState() {
return null;
}
@Override
public boolean isFluid() {
return false;
}
@Override
public boolean isWater() {
return false;
}
@Override
public boolean isWaterLogged() {
return false;
}
@Override
public boolean isLit() {
return false;
}
@Override
public boolean isUpdatable() {
return false;
}
@Override
public boolean isFoliage() {
return false;
}
@Override
public boolean isTreeBlock() {
return false;
}
@Override
public boolean isFoliagePlantable() {
return false;
}
@Override
public boolean isDecorant() {
return false;
}
@Override
public boolean isStorage() {
return false;
}
@Override
public boolean isStorageChest() {
return false;
}
@Override
public boolean isOre() {
return false;
}
@Override
public boolean isDeepSlate() {
return false;
}
@Override
public boolean isVineBlock() {
return false;
}
@Override
public boolean canPlaceOnto(PlatformBlockState onto) {
return false;
}
@Override
public boolean matches(PlatformBlockState state) {
return false;
}
@Override
public boolean isAirOrFluid() {
return false;
}
@Override
public boolean hasTileEntity() {
return false;
}
@Override
public PlatformBlockState withProperty(String name, String value) {
return null;
}
@Override
public Object nativeHandle() {
return null;
}
}
private static final class Fixture implements AutoCloseable {
core/src/test/java/art/arcane/iris/engine/modifier/IrisDepositModifierParityTest.java
+160 -9
View File
@@ -197,15 +197,166 @@ public class IrisDepositModifierParityTest {
private PlatformBlockState state(String block) {
String key = block.contains(":") ? block : "minecraft:" + block;
return states.computeIfAbsent(key, value -> {
PlatformBlockState state = mock(PlatformBlockState.class);
when(state.key()).thenReturn(value);
when(state.materialKey()).thenReturn(value);
when(state.isOre()).thenReturn(value.endsWith("_ore"));
when(state.isDeepSlate()).thenReturn(value.contains("deepslate"));
when(state.isAir()).thenReturn(value.endsWith("air"));
return state;
});
return states.computeIfAbsent(key, KeyedBlockState::new);
}
private static final class KeyedBlockState implements PlatformBlockState {
private final String key;
private final boolean ore;
private final boolean deepSlate;
private final boolean air;
private KeyedBlockState(String key) {
this.key = key;
this.ore = key.endsWith("_ore");
this.deepSlate = key.contains("deepslate");
this.air = key.endsWith("air");
}
@Override
public String key() {
return key;
}
@Override
public String namespace() {
return null;
}
@Override
public String materialKey() {
return key;
}
@Override
public boolean isAir() {
return air;
}
@Override
public boolean isSolid() {
return false;
}
@Override
public boolean isOccluding() {
return false;
}
@Override
public boolean isCustom() {
return false;
}
@Override
public String deferredPlacementKey() {
return null;
}
@Override
public PlatformBlockState placementBaseState() {
return null;
}
@Override
public boolean isFluid() {
return false;
}
@Override
public boolean isWater() {
return false;
}
@Override
public boolean isWaterLogged() {
return false;
}
@Override
public boolean isLit() {
return false;
}
@Override
public boolean isUpdatable() {
return false;
}
@Override
public boolean isFoliage() {
return false;
}
@Override
public boolean isTreeBlock() {
return false;
}
@Override
public boolean isFoliagePlantable() {
return false;
}
@Override
public boolean isDecorant() {
return false;
}
@Override
public boolean isStorage() {
return false;
}
@Override
public boolean isStorageChest() {
return false;
}
@Override
public boolean isOre() {
return ore;
}
@Override
public boolean isDeepSlate() {
return deepSlate;
}
@Override
public boolean isVineBlock() {
return false;
}
@Override
public boolean canPlaceOnto(PlatformBlockState onto) {
return false;
}
@Override
public boolean matches(PlatformBlockState state) {
return false;
}
@Override
public boolean isAirOrFluid() {
return false;
}
@Override
public boolean hasTileEntity() {
return false;
}
@Override
public PlatformBlockState withProperty(String name, String value) {
return null;
}
@Override
public Object nativeHandle() {
return null;
}
}
private static final class PaletteGenerator extends IrisDepositGenerator {
core/src/test/java/art/arcane/iris/engine/object/IrisObjectIoWriteLimitsTest.java
+179 -18
View File
@@ -2,6 +2,7 @@ package art.arcane.iris.engine.object;
import art.arcane.iris.spi.PlatformBlockState;
import art.arcane.iris.util.common.math.IrisBlockVector;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
@@ -9,7 +10,6 @@ import org.junit.rules.TemporaryFolder;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Proxy;
import java.nio.file.Files;
import static org.junit.Assert.assertArrayEquals;
@@ -18,25 +18,18 @@ import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
public class IrisObjectIoWriteLimitsTest {
private static IrisObject oversizedPaletteObject;
@Rule
public TemporaryFolder folder = new TemporaryFolder();
@BeforeClass
public static void buildSharedObjects() {
oversizedPaletteObject = objectWithDistinctStates(32_768);
}
private static PlatformBlockState state(String key) {
return (PlatformBlockState) Proxy.newProxyInstance(
IrisObjectIoWriteLimitsTest.class.getClassLoader(),
new Class<?>[]{PlatformBlockState.class},
(proxy, method, args) -> switch (method.getName()) {
case "key" -> key;
case "toString" -> key;
case "hashCode" -> key.hashCode();
case "equals" -> proxy == args[0];
default -> switch (method.getReturnType().getName()) {
case "boolean" -> false;
case "int" -> 0;
case "double" -> 0D;
default -> null;
};
});
return new KeyedBlockState(key);
}
private static IrisObject objectWithDistinctStates(int paletteSize) {
@@ -60,7 +53,7 @@ public class IrisObjectIoWriteLimitsTest {
@Test
public void rejectsPaletteOverflowInsteadOfWrappingTheShort() {
IrisObject object = objectWithDistinctStates(32_768);
IrisObject object = oversizedPaletteObject;
try {
IrisObjectIO.write(object, new ByteArrayOutputStream());
@@ -103,7 +96,7 @@ public class IrisObjectIoWriteLimitsTest {
IrisObjectIO.write(valid, file);
byte[] before = Files.readAllBytes(file.toPath());
IrisObject oversized = objectWithDistinctStates(32_768);
IrisObject oversized = oversizedPaletteObject;
try {
IrisObjectIO.write(oversized, file);
fail("expected the oversized write to be rejected");
@@ -113,4 +106,172 @@ public class IrisObjectIoWriteLimitsTest {
assertArrayEquals("a rejected write must not truncate the previous object", before,
Files.readAllBytes(file.toPath()));
}
private static final class KeyedBlockState implements PlatformBlockState {
private final String key;
private KeyedBlockState(String key) {
this.key = key;
}
@Override
public String key() {
return key;
}
@Override
public String namespace() {
return null;
}
@Override
public String materialKey() {
return null;
}
@Override
public boolean isAir() {
return false;
}
@Override
public boolean isSolid() {
return false;
}
@Override
public boolean isOccluding() {
return false;
}
@Override
public boolean isCustom() {
return false;
}
@Override
public String deferredPlacementKey() {
return null;
}
@Override
public PlatformBlockState placementBaseState() {
return null;
}
@Override
public boolean isFluid() {
return false;
}
@Override
public boolean isWater() {
return false;
}
@Override
public boolean isWaterLogged() {
return false;
}
@Override
public boolean isLit() {
return false;
}
@Override
public boolean isUpdatable() {
return false;
}
@Override
public boolean isFoliage() {
return false;
}
@Override
public boolean isTreeBlock() {
return false;
}
@Override
public boolean isFoliagePlantable() {
return false;
}
@Override
public boolean isDecorant() {
return false;
}
@Override
public boolean isStorage() {
return false;
}
@Override
public boolean isStorageChest() {
return false;
}
@Override
public boolean isOre() {
return false;
}
@Override
public boolean isDeepSlate() {
return false;
}
@Override
public boolean isVineBlock() {
return false;
}
@Override
public boolean canPlaceOnto(PlatformBlockState onto) {
return false;
}
@Override
public boolean matches(PlatformBlockState state) {
return false;
}
@Override
public boolean isAirOrFluid() {
return false;
}
@Override
public boolean hasTileEntity() {
return false;
}
@Override
public PlatformBlockState withProperty(String name, String value) {
return null;
}
@Override
public Object nativeHandle() {
return null;
}
@Override
public int hashCode() {
return key.hashCode();
}
@Override
public boolean equals(Object other) {
return this == other;
}
@Override
public String toString() {
return key;
}
}
}
core/src/test/java/art/arcane/iris/engine/object/IrisObjectPlacementRunnerRegressionTest.java
+6 -6
View File
@@ -126,7 +126,7 @@ public class IrisObjectPlacementRunnerRegressionTest {
int resultY = lineObject(3).place(0, ANCHOR_Y, 0, placer, placement, new RNG(2L), data);
List<BlockWrite> airWrites = placer.writesOf(IrisObject.States.AIR);
List<BlockWrite> airWrites = placer.writesOf(IrisObject.States.air());
assertFalse(airWrites.isEmpty());
assertTrue(airWrites.stream().allMatch(write -> write.y() >= resultY && write.y() <= resultY));
assertTrue(airWrites.stream().allMatch(write -> write.x() == 0));
@@ -194,7 +194,7 @@ public class IrisObjectPlacementRunnerRegressionTest {
object.place(0, ANCHOR_Y, 0, placer, placement, new RNG(2L), data);
List<BlockWrite> snowWrites = placer.writesOf(IrisObject.States.SNOW_LAYERS[0]);
List<BlockWrite> snowWrites = placer.writesOf(IrisObject.States.snowLayer(0));
assertEquals(1, snowWrites.size());
assertEquals(ANCHOR_Y, snowWrites.get(0).y());
}
@@ -202,7 +202,7 @@ public class IrisObjectPlacementRunnerRegressionTest {
@Test
public void debugPlacementDoesNotMutateSmartBoreCache() {
IrisObject object = new IrisObject(1, 1, 1);
object.setUnsigned(0, 0, 0, IrisObject.States.VAIR);
object.setUnsigned(0, 0, 0, IrisObject.States.vair());
object.setSmartBored(true);
IrisObjectPlacement placement = placement();
placement.setSmartBore(true);
@@ -214,9 +214,9 @@ public class IrisObjectPlacementRunnerRegressionTest {
object.place(0, ANCHOR_Y, 0, normal, placement, new RNG(2L), data);
PlatformBlockState cachedState = object.getBlocks().get(object.getSigned(0, 0, 0));
assertSame(IrisObject.States.VAIR, cachedState);
if (IrisObject.States.VAIR != IrisObject.States.VAIR_DEBUG) {
assertTrue(cachedState != IrisObject.States.VAIR_DEBUG);
assertSame(IrisObject.States.vair(), cachedState);
if (IrisObject.States.vair() != IrisObject.States.vairDebug()) {
assertTrue(cachedState != IrisObject.States.vairDebug());
}
}
core/src/test/java/art/arcane/iris/engine/object/IrisObjectShapingTest.java
+3 -3
View File
@@ -55,8 +55,8 @@ public class IrisObjectShapingTest {
for (int index = 0; index < 36; index++) {
Cell cell = new Cell(offset + random.nextInt(6), offset + random.nextInt(6), offset + random.nextInt(6));
PlatformBlockState state = switch (index % 3) {
case 0 -> IrisObject.States.AIR;
case 1 -> IrisObject.States.VAIR;
case 0 -> IrisObject.States.air();
case 1 -> IrisObject.States.vair();
default -> stone;
};
object.getBlocks().put(cell.vector(), state);
@@ -97,7 +97,7 @@ public class IrisObjectShapingTest {
continue;
}
for (int position = start.coordinate(axis); position <= end.coordinate(axis); position++) {
blocks.putIfAbsent(start.with(axis, position), IrisObject.States.VAIR);
blocks.putIfAbsent(start.with(axis, position), IrisObject.States.vair());
}
}
}
core/src/test/java/art/arcane/iris/engine/object/IrisObjectTransformsNearestBlockIndexTest.java
+156 -8
View File
@@ -12,9 +12,6 @@ import java.util.Map;
import java.util.Random;
import static org.junit.Assert.assertSame;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.withSettings;
import static org.mockito.Mockito.when;
public class IrisObjectTransformsNearestBlockIndexTest {
@Test
@@ -22,7 +19,7 @@ public class IrisObjectTransformsNearestBlockIndexTest {
VectorMap<PlatformBlockState> blocks = new VectorMap<>();
Random random = new Random(812734L);
for (int i = 0; i < 120; i++) {
PlatformBlockState state = mock(PlatformBlockState.class, withSettings().stubOnly());
PlatformBlockState state = new SolidBlockState(false);
blocks.put(new IrisBlockVector(
random.nextInt(25) - 12,
random.nextInt(25) - 12,
@@ -30,8 +27,7 @@ public class IrisObjectTransformsNearestBlockIndexTest {
), state);
}
PlatformBlockState explicitAir = mock(PlatformBlockState.class, withSettings().stubOnly());
when(explicitAir.isAir()).thenReturn(true);
PlatformBlockState explicitAir = new SolidBlockState(true);
blocks.put(new IrisBlockVector(0, 0, 0), explicitAir);
IrisObjectTransforms.NearestBlockIndex index = IrisObjectTransforms.NearestBlockIndex.create(blocks);
List<Map.Entry<IrisBlockVector, PlatformBlockState>> candidates = new ArrayList<>();
@@ -55,8 +51,7 @@ public class IrisObjectTransformsNearestBlockIndexTest {
@Test
public void emptyIndexRetainsMissingAndExplicitAirFallbacks() {
VectorMap<PlatformBlockState> blocks = new VectorMap<>();
PlatformBlockState explicitAir = mock(PlatformBlockState.class, withSettings().stubOnly());
when(explicitAir.isAir()).thenReturn(true);
PlatformBlockState explicitAir = new SolidBlockState(true);
blocks.put(new IrisBlockVector(1, 2, 3), explicitAir);
IrisObjectTransforms.NearestBlockIndex index = IrisObjectTransforms.NearestBlockIndex.create(blocks);
@@ -89,4 +84,157 @@ public class IrisObjectTransformsNearestBlockIndexTest {
}
return result;
}
private static final class SolidBlockState implements PlatformBlockState {
private final boolean air;
private SolidBlockState(boolean air) {
this.air = air;
}
@Override
public String key() {
return null;
}
@Override
public String namespace() {
return null;
}
@Override
public String materialKey() {
return null;
}
@Override
public boolean isAir() {
return air;
}
@Override
public boolean isSolid() {
return false;
}
@Override
public boolean isOccluding() {
return false;
}
@Override
public boolean isCustom() {
return false;
}
@Override
public String deferredPlacementKey() {
return null;
}
@Override
public PlatformBlockState placementBaseState() {
return null;
}
@Override
public boolean isFluid() {
return false;
}
@Override
public boolean isWater() {
return false;
}
@Override
public boolean isWaterLogged() {
return false;
}
@Override
public boolean isLit() {
return false;
}
@Override
public boolean isUpdatable() {
return false;
}
@Override
public boolean isFoliage() {
return false;
}
@Override
public boolean isTreeBlock() {
return false;
}
@Override
public boolean isFoliagePlantable() {
return false;
}
@Override
public boolean isDecorant() {
return false;
}
@Override
public boolean isStorage() {
return false;
}
@Override
public boolean isStorageChest() {
return false;
}
@Override
public boolean isOre() {
return false;
}
@Override
public boolean isDeepSlate() {
return false;
}
@Override
public boolean isVineBlock() {
return false;
}
@Override
public boolean canPlaceOnto(PlatformBlockState onto) {
return false;
}
@Override
public boolean matches(PlatformBlockState state) {
return false;
}
@Override
public boolean isAirOrFluid() {
return false;
}
@Override
public boolean hasTileEntity() {
return false;
}
@Override
public PlatformBlockState withProperty(String name, String value) {
return null;
}
@Override
public Object nativeHandle() {
return null;
}
}
}
core/src/test/java/art/arcane/iris/engine/object/IrisStaticObjectLayerTest.java
+1 -1
View File
@@ -108,7 +108,7 @@ public class IrisStaticObjectLayerTest {
entry("replacement", 0, 100, 0).setBore(true));
IrisStaticObjectLayer.Block center = block(layer, 0, 164, 0);
assertSame(IrisObject.States.AIR, center.state());
assertSame(IrisObject.States.air(), center.state());
assertNull(center.tile());
assertEquals(1, chest.getStates().size());
}
core/src/test/java/art/arcane/iris/engine/platform/BukkitChunkGeneratorGenerationHistoryContractTest.java
-114
View File
@@ -1,114 +0,0 @@
package art.arcane.iris.engine.platform;
import org.junit.Test;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import static org.junit.Assert.assertTrue;
public final class BukkitChunkGeneratorGenerationHistoryContractTest {
@Test
public void setupPromotesBeforePublicationAndRebuildsFullServicesFromTheNewPack() throws IOException {
String source = source();
String setup = method(source, "private void setupEngine()");
assertBefore(setup, "IrisEngine createdEngine = createEngine(engineTarget);",
"createdEngine.attachGenerationHistory(");
assertBefore(setup, "createdEngine.attachGenerationHistory(",
"generationHistory.activeActivation().activationId() != initialActivationId");
assertBefore(setup, "createdEngine.close();", "createEngine(loadActiveGenerationHistoryTarget())");
assertTrue(count(setup, "createdEngine.attachGenerationHistory(") == 2);
assertBefore(setup, "createEngine(loadActiveGenerationHistoryTarget())", "engine = createdEngine;");
assertBefore(setup, "IrisBoundarySignatureSampler.INSTANCE", "engine = createdEngine;");
assertTrue(setup.contains("getGenerationTransitionWidthBlocks()"));
}
@Test
public void historyEngineStartsWithTheActiveMantleKernelAndTransition() throws IOException {
String createEngine = method(source(), "private IrisEngine createEngine(EngineTarget engineTarget)");
assertTrue(createEngine.contains("generationHistory.paths().activationMantleRoot(active.activationId())"));
assertTrue(createEngine.contains("epoch.kernelVersion()"));
assertTrue(createEngine.contains("generationHistory.transitionPlan(active.activationId())"));
assertTrue(createEngine.contains("if (generationHistory == null)"));
}
@Test
public void studioLoadsItsSnapshotBeforeAnyMutablePackFallback() throws IOException {
String target = method(source(), "public EngineTarget getTarget()");
String historyTarget = method(source(), "private EngineTarget loadActiveGenerationHistoryTarget()");
assertBefore(target, "if (generationHistory != null)", "IrisData.openRuntime(dataLocation)");
assertBefore(target, "return loadActiveGenerationHistoryTarget();", "IrisData.openRuntime(dataLocation)");
assertBefore(historyTarget, "generationHistory.activePackRoot()", "IrisData.openRuntime(packRoot.toFile())");
}
@Test
public void studioWatchAndHotloadReadAuthoringSourceWithoutChangingTheRuntimeSnapshot() throws IOException {
String source = source();
String constructor = method(source, "public BukkitChunkGenerator(");
String createEngine = method(source, "private IrisEngine createEngine(EngineTarget engineTarget)");
assertTrue(constructor.contains("new ReactiveFolder(\n dataLocation,"));
assertTrue(constructor.contains("new KList<>(\".iob\", \".json\", \".png\")"));
assertTrue(createEngine.contains("if (studio)"));
assertBefore(createEngine, "new IrisEngine(", "configureStudioGenerationSource(dataLocation.toPath())");
assertBefore(createEngine, "configureStudioGenerationSource(dataLocation.toPath())", "return createdEngine;");
}
@Test
public void publicBukkitTerrainClaimsSemanticsOnlyAfterSuccessfulApplication() throws IOException {
String generateNoise = method(
source(),
"public void generateNoise(@NotNull WorldInfo world, @NotNull Random random, int x, int z, @NotNull ChunkGenerator.ChunkData d)"
);
assertBefore(generateNoise, "engine.generate(x << 4, z << 4", "blocks.apply()");
assertBefore(generateNoise, "blocks.apply()", "historyScope.claimGeneratedSemantics()");
}
private static String source() throws IOException {
return Files.readString(Path.of(System.getProperty("iris.bukkitChunkGeneratorSource")))
.replace("\r\n", "\n");
}
private static String method(String source, String signature) {
int start = source.indexOf(signature);
assertTrue("Missing source contract token: " + signature, start >= 0);
int openingBrace = source.indexOf('{', start);
assertTrue(openingBrace >= 0);
int depth = 0;
for (int index = openingBrace; index < source.length(); index++) {
char character = source.charAt(index);
if (character == '{') {
depth++;
} else if (character == '}') {
depth--;
if (depth == 0) {
return source.substring(start, index + 1);
}
}
}
throw new AssertionError("Method body did not close: " + signature);
}
private static void assertBefore(String source, String first, String second) {
int firstIndex = source.indexOf(first);
int secondIndex = source.indexOf(second);
assertTrue("Missing source contract token: " + first, firstIndex >= 0);
assertTrue("Missing source contract token: " + second, secondIndex >= 0);
assertTrue(first + " must occur before " + second, firstIndex < secondIndex);
}
private static int count(String source, String token) {
int count = 0;
int index = 0;
while ((index = source.indexOf(token, index)) >= 0) {
count++;
index += token.length();
}
return count;
}
}
core/src/test/java/art/arcane/iris/engine/platform/studio/generators/ObjectStudioGeometryTest.java
+20 -9
View File
@@ -65,14 +65,7 @@ public class ObjectStudioGeometryTest {
RegistryAccess access = mock(RegistryAccess.class, invocation -> {
if (invocation.getMethod().getName().equals("getRegistry")) {
if (registered.get() == null) {
Registry<Biome> biomes = mock(Registry.class, lookup -> {
if (lookup.getMethod().getName().equals("getOrThrow")) {
Key key = lookup.getArgument(0);
return biome(key);
}
return RETURNS_DEFAULTS.answer(lookup);
});
registered.set(biomes);
registered.set(biomeRegistry());
}
return registered.get();
}
@@ -88,10 +81,28 @@ public class ObjectStudioGeometryTest {
MockedStatic<InternalAPIBridge> internals = mockStatic(InternalAPIBridge.class)) {
registries.when(RegistryAccess::registryAccess).thenReturn(access);
internals.when(InternalAPIBridge::get).thenReturn(bridge);
Class.forName(ObjectStudioGenerator.class.getName(), true, ObjectStudioGenerator.class.getClassLoader());
ClassLoader loader = ObjectStudioGenerator.class.getClassLoader();
Class.forName(Registry.class.getName(), true, loader);
Class.forName(Biome.class.getName(), true, loader);
Class.forName(ObjectStudioGenerator.class.getName(), true, loader);
}
}
@SuppressWarnings("unchecked")
private static Registry<Biome> biomeRegistry() {
return (Registry<Biome>) Proxy.newProxyInstance(Registry.class.getClassLoader(),
new Class<?>[]{Registry.class},
(proxy, method, arguments) -> switch (method.getName()) {
case "getOrThrow" -> biome((Key) arguments[0]);
case "hashCode" -> System.identityHashCode(proxy);
case "equals" -> proxy == arguments[0];
case "toString" -> "iris-object-studio-biome-registry";
case "size" -> 0;
case "hasTag" -> false;
default -> null;
});
}
@Test
public void jungleClutterSignedBoundsStayInsideTheEditableCellAboveTheFloor() throws Exception {
IrisObject source = filled(5, 3, 4, new Position(-3, -2, -2), new Position(1, -1, 1));
core/src/test/java/art/arcane/iris/platform/bukkit/BukkitSpiConformanceTest.java
+25 -1
View File
@@ -26,13 +26,16 @@ import art.arcane.iris.spi.PlatformBlockState;
import art.arcane.iris.spi.PlatformRegistries;
import art.arcane.iris.util.common.data.IrisCustomData;
import art.arcane.iris.util.project.matter.slices.PlatformBlockMatter;
import io.papermc.paper.registry.RegistryAccess;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.Server;
import org.bukkit.World;
import org.bukkit.block.data.BlockData;
import org.bukkit.entity.Entity;
import org.junit.After;
import org.junit.Assume;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.mockito.invocation.InvocationOnMock;
@@ -79,6 +82,16 @@ public class BukkitSpiConformanceTest {
doAnswer((InvocationOnMock invocation) -> blockData(invocation.getArgument(0))).when(server).createBlockData(anyString());
}
@Before
public void resetPlatformBinding() {
IrisPlatforms.unbind();
}
@After
public void clearPlatformBinding() {
IrisPlatforms.unbind();
}
private static BlockData blockData(String asString) {
BlockData data = mock(BlockData.class);
doReturn(asString).when(data).getAsString();
@@ -90,7 +103,17 @@ public class BukkitSpiConformanceTest {
return new BukkitRegistries();
}
private static boolean liveRegistriesAvailable() {
try {
RegistryAccess.registryAccess();
return true;
} catch (Throwable unavailable) {
return false;
}
}
private static void assertNamespacedRegistryList(Supplier<List<String>> supplier) {
Assume.assumeTrue("live Bukkit registry unavailable in this environment", liveRegistriesAvailable());
List<String> keys;
try {
keys = supplier.get();
@@ -98,7 +121,7 @@ public class BukkitSpiConformanceTest {
Assume.assumeNoException("live Bukkit registry unavailable in this environment", unavailable);
return;
}
assertFalse(keys.isEmpty());
Assume.assumeFalse("live Bukkit registry is unpopulated in this environment", keys.isEmpty());
for (String key : keys) {
assertTrue("expected namespaced key but was '" + key + "'", key.contains(":"));
}
@@ -239,6 +262,7 @@ public class BukkitSpiConformanceTest {
@Test
public void blockTypeKeysMatchAuthorableBlockTypeSource() {
Assume.assumeTrue("live Bukkit registry unavailable in this environment", liveRegistriesAvailable());
List<String> keys;
List<String> legacy;
try {