Launch the JavaFX 2 project shell on Java 25 with an interactive viewport, managed Play lifecycle and project mutation guards. Preserve headless/MCP and save compatibility, and qualify exact runtime executable bundles. Separate unit JaCoCo gates from opt-in integration suites and use the internal Pong fixture for the headless visual pilot. Move maintenance and native conformance tools into tooling; retain the VS Code extension and update current navigation links. Validation: tooling make verify passed, including 1064 Studio unit tests, JaCoCo thresholds and 22 headless integration tests.
252 lines
18 KiB
Java
252 lines
18 KiB
Java
package p.studio.app.runtime;
|
|
|
|
import com.fasterxml.jackson.databind.*;
|
|
import org.junit.jupiter.api.*;
|
|
import org.junit.jupiter.api.io.TempDir;
|
|
import p.studio.api.automation.*;
|
|
import p.studio.api.project.*;
|
|
import p.studio.api.shipper.ShipperPrepareResult;
|
|
import p.studio.app.operation.ExecutorOperationExecutor;
|
|
import p.studio.core.project.*;
|
|
import p.studio.core.shipper.*;
|
|
import p.studio.compiler.messages.BuilderPipelineConfig;
|
|
import p.studio.compiler.models.BuilderPipelineContext;
|
|
import p.studio.compiler.workspaces.BuilderPipelineService;
|
|
import p.studio.utilities.logs.LogAggregator;
|
|
import java.nio.file.*;
|
|
import java.util.*;
|
|
import java.util.concurrent.*;
|
|
import static org.junit.jupiter.api.Assertions.*;
|
|
|
|
/** PBS/shipper -> configured dispatcher -> distinct OS processes; no native injection. */
|
|
@org.junit.jupiter.api.Tag("integration")
|
|
class MemcardInstalledRuntimeTest {
|
|
@TempDir Path root;
|
|
final ObjectMapper mapper = new ObjectMapper();
|
|
static final String PREFIX = """
|
|
import {Mem, MemcardBuffer} from @sdk:mem;
|
|
import {Color} from @core:color;
|
|
import {Gfx} from @sdk:gfx;
|
|
declare global context: long = 0;
|
|
""";
|
|
static final String WRITER = PREFIX + """
|
|
declare global request: long = 0;
|
|
declare global saved: bool = false;
|
|
[MemcardBoot] fn restore(c: long) -> int {
|
|
context = c;
|
|
let icon = new MemcardBuffer(560);
|
|
if Mem.presentation(c, "Process persistence", 1 as long, 1, 1, icon, 0, 560) != 0 as long { return 1; }
|
|
return 0;
|
|
}
|
|
[Frame] fn frame() -> void {
|
|
if saved { Gfx.clear(Color.rgb(0, 255, 0)); return; }
|
|
Gfx.clear(Color.rgb(255, 0, 0));
|
|
if request == 0 as long {
|
|
let bytes = new MemcardBuffer(4);
|
|
bytes.write(0, 0); bytes.write(1, 127); bytes.write(2, 128); bytes.write(3, 255);
|
|
let written = Mem.slot_write(context, 0, 0, bytes, 0, 4);
|
|
if written.status != 0 as long or written.bytes_written != 4 as long { let fail = 1 / 0; }
|
|
let commit = Mem.slot_commit(context, 0);
|
|
if commit.status != 0 as long { let fail = 1 / 0; }
|
|
request = commit.request;
|
|
return;
|
|
}
|
|
let observation = Mem.query(context, request);
|
|
if observation.status != 0 as long { let fail = 1 / 0; }
|
|
if observation.state == 0 as long { return; }
|
|
if observation.state != 1 as long { let fail = 1 / 0; }
|
|
saved = true;
|
|
}
|
|
""";
|
|
static final String READER = PREFIX + """
|
|
[MemcardBoot] fn restore(c: long) -> int {
|
|
context = c;
|
|
let stat = Mem.slot_stat(c, 0);
|
|
if stat.status != 0 as long { return 1; }
|
|
if stat.used_bytes != 4 as long { return 1; }
|
|
let bytes = new MemcardBuffer(4);
|
|
let read = Mem.slot_read(c, 0, 0, bytes, 0, 4);
|
|
if read.status != 0 as long { return 1; }
|
|
if read.bytes_read != 4 as long { return 1; }
|
|
if bytes.read(0) != 0 or bytes.read(1) != 127 or bytes.read(2) != 128 or bytes.read(3) != 255 { return 1; }
|
|
return 0;
|
|
}
|
|
[Frame] fn frame() -> void { Gfx.clear(Color.rgb(0, 127, 255)); }
|
|
""";
|
|
private ShipperPrepareResult build(Path projectRoot, String source, String version, boolean optimized, p.packer.Packer packer) throws Exception {
|
|
Files.createDirectories(projectRoot.resolve("src"));
|
|
Files.writeString(projectRoot.resolve("prometeu.json"), """
|
|
{"name":"process-memcard","version":"%s","language":"pbs","stdlib":"1","target":"Game",
|
|
"dependencies":[],"app_id":4294967295,"memcard_slots":1}
|
|
""".formatted(version));
|
|
Files.writeString(projectRoot.resolve("src/mod.barrel"), "pub fn frame() -> void;");
|
|
Files.writeString(projectRoot.resolve("src/main.pbs"), source);
|
|
CompilerBuildGateway compiler = new CompilerBuildGateway(){
|
|
public CompilerBuildOutput compile(ProjectReference project,java.util.function.Consumer<String> log){return compile(project,BuildSelection.productionBuild(),project.rootPath().resolve("build"),log);}
|
|
public CompilerBuildOutput compile(ProjectReference project,BuildSelection selection,Path output,java.util.function.Consumer<String> log){
|
|
var admitted=new p.studio.app.compiler.CompilerBuildGatewayAdapter().compile(project,selection,output,log);
|
|
var result = BuilderPipelineService.INSTANCE.build(BuilderPipelineContext.fromConfig(
|
|
new BuilderPipelineConfig(false, project.rootPath().toString(),"core-v1",p.studio.compiler.utilities.SourceProviderFactory.filesystem(),selection.targetId(),output)), LogAggregator.with(log));
|
|
var compiled = result.compileResult();
|
|
var program = optimized ? compiled.optimizedIrvm() : compiled.irvm();
|
|
var module = new p.studio.compiler.backend.bytecode.BytecodeEmitter().emit(program.coherentEmissionPlan());
|
|
new p.studio.compiler.backend.bytecode.BytecodePreloadVerifierService().verify(module);
|
|
if (source.equals(READER)) verifyReadOnlyOracle(program.coherentEmissionPlan());
|
|
try { Files.write(result.bytecodeArtifactPath(), module.serialize()); }
|
|
catch (java.io.IOException failure) { throw new java.io.UncheckedIOException(failure); }
|
|
return new CompilerBuildGateway.CompilerBuildOutput(result.bytecodeArtifactPath(),
|
|
compiled.analysisSnapshot().irBackend().getReservedMetadata().requiredCapabilities().asList(),admitted.issues(),admitted.context());
|
|
}};
|
|
var setup = new ProjectLocalStudioSetupStore(mapper);
|
|
var project = new ProjectCatalogService(projectRoot, mapper, setup).openProject(projectRoot);
|
|
try (var workers = Executors.newSingleThreadExecutor()) {
|
|
var build = new StudioShipperService(compiler, packer.workspaceService(), mapper, new ExecutorOperationExecutor(workers))
|
|
.withAssetPreflight(new p.studio.app.assets.AssetBudgetInspection(mapper,packer.workspaceService(),ignored->new ProjectLocalStudioSetup(System.getProperty("studio.test.runtimeInstall"),null)))
|
|
.prepare(project, ignored -> {}).completion().toCompletableFuture().get(30, TimeUnit.SECONDS);
|
|
assertTrue(build.success(), build.diagnostics().toString());
|
|
var manifest = mapper.readTree(build.manifestPath().toFile());
|
|
assertEquals(4294967295L, manifest.path("app_id").longValue()); assertEquals(version, manifest.path("app_version").asText());
|
|
System.out.println("MEMCARD ARTIFACT " + mapper.writeValueAsString(Map.of(
|
|
"optimized", optimized, "version", version, "producer", source.equals(WRITER) ? "writer" : source.equals(READER) ? "reader" : "dirty",
|
|
"pbxSha256", sha(Files.readAllBytes(build.manifestPath().getParent().resolve("program.pbx"))),
|
|
"manifestSha256", sha(Files.readAllBytes(build.manifestPath())),
|
|
"sourceSha256", sha(source.getBytes(java.nio.charset.StandardCharsets.UTF_8)))));
|
|
return build;
|
|
}
|
|
}
|
|
private static String sha(byte[] bytes) throws Exception {
|
|
return java.util.HexFormat.of().formatHex(java.security.MessageDigest.getInstance("SHA-256").digest(bytes));
|
|
}
|
|
private void verifyReadOnlyOracle(p.studio.compiler.backend.bytecode.BytecodeEmitter.EmissionPlan plan) {
|
|
// SDK definitions may retain unused imports. Follow executable entry/roles,
|
|
// including closure construction, rather than treating imports as calls.
|
|
var pending = new ArrayDeque<Integer>(); pending.add(0);
|
|
for (int i = 0; i < plan.functions().size(); i++)
|
|
if (plan.functions().get(i).metadata().role() != p.studio.compiler.models.registry.IRRegistry.Role.NONE) pending.add(i);
|
|
var visited = new HashSet<Integer>();
|
|
while (!pending.isEmpty()) {
|
|
int index = pending.remove(); if (!visited.add(index)) continue;
|
|
for (var operation : plan.functions().get(index).operations()) {
|
|
if (operation.kind() == p.studio.compiler.backend.bytecode.BytecodeEmitter.OperationKind.CALL_FUNC) pending.add(operation.immediate());
|
|
if (operation.kind() == p.studio.compiler.backend.bytecode.BytecodeEmitter.OperationKind.REGISTRY) {
|
|
var instruction = operation.registryInstruction();
|
|
if (instruction.op().opcode() == 0x52) pending.add(instruction.immediate());
|
|
assertNotEquals(0x53, instruction.op().opcode(), "Reader oracle must have a statically inspectable call graph");
|
|
assertNotEquals(0x58, instruction.op().opcode(), "Reader oracle must have no dynamic contract call");
|
|
}
|
|
if (operation.syscallDecl() != null) assertFalse(Set.of("slot_write", "slot_commit", "slot_clear", "presentation", "publish_presentation")
|
|
.contains(operation.syscallDecl().name()), "Reader must not reach a saving or presentation call");
|
|
}
|
|
}
|
|
}
|
|
private HeadlessProcessSession boot(Path projectRoot, ShipperPrepareResult build, Path image, String action, String choice, String access) throws Exception {
|
|
String installation = System.getProperty("studio.test.runtimeInstall", "");
|
|
assertFalse(installation.isBlank(), "Supply -PstudioRuntimeInstall=<configured runtime installation>");
|
|
var store = new ProjectLocalStudioSetupStore(mapper);
|
|
var project = new ProjectCatalogService(projectRoot, mapper, store).openProject(projectRoot);
|
|
store.save(project, new ProjectLocalStudioSetup(installation, null));
|
|
var session = (HeadlessProcessSession) new HeadlessProcessGateway(mapper, store::load).boot(project, "process-build", build,
|
|
Map.of("memcard", Map.of("path", image.toString(), "action", action, "access", access), "memcardChoice", choice));
|
|
System.out.println("MEMCARD process=" + session.pid() + " installation=" + installation + " choice=" + choice);
|
|
return session;
|
|
}
|
|
private JsonNode memcard(HeadlessProcessSession session) throws Exception {
|
|
return mapper.valueToTree(session.call(TaskTools.HeadlessAction.MEMCARD_STATE, Map.of()).values().get("memcard"));
|
|
}
|
|
private void close(HeadlessProcessSession session) throws Exception {
|
|
try { session.shutdown().toCompletableFuture().get(7, TimeUnit.SECONDS); assertFalse(session.alive()); }
|
|
finally { session.abort("test cleanup"); }
|
|
}
|
|
@Test void savesThenDifferentProcessesReadExactBytesAcrossVersionUpgradeWithoutResaving() throws Exception {
|
|
try (var packer = p.packer.Packer.bootstrap(mapper, ignored -> {})) {
|
|
for (boolean optimized : new boolean[]{false, true}) {
|
|
Path project = root.resolve(optimized ? "optimized" : "ordinary");
|
|
Path image = root.resolve(optimized ? "optimized.pmc" : "ordinary.pmc");
|
|
var writer = boot(project, build(project, WRITER, "1", optimized, packer), image, "create", "persistent", "read_write");
|
|
long writerPid = writer.pid();
|
|
try {
|
|
long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(15);
|
|
JsonNode state;
|
|
do {
|
|
var outcome = writer.advance(1, ignored -> {});
|
|
assertEquals(AutomationOutcome.Kind.SUCCEEDED, outcome.kind(), outcome.diagnostics().toString());
|
|
state = memcard(writer);
|
|
assertTrue(System.nanoTime() < deadline, state.toString());
|
|
} while (!state.path("request").path("operation").asText().equals("commit") || !state.path("request").path("state").asText().equals("success"));
|
|
assertFalse(state.path("dirty").booleanValue()); assertFalse(state.path("io").path("active").booleanValue());
|
|
} finally { close(writer); }
|
|
byte[] durable = Files.readAllBytes(image);
|
|
for (String version : List.of("1", "2")) {
|
|
var reader = boot(project, build(project, READER, version, optimized, packer), image, "open", "persistent", "read_write");
|
|
assertNotEquals(writerPid, reader.pid());
|
|
try {
|
|
var outcome = reader.advance(2, ignored -> {});
|
|
assertEquals(AutomationOutcome.Kind.SUCCEEDED, outcome.kind(), outcome.diagnostics().toString());
|
|
assertNotNull(outcome.capture());
|
|
var pixels = javax.imageio.ImageIO.read(new java.io.ByteArrayInputStream(outcome.capture().png()));
|
|
assertEquals(0xff007fff, pixels.getRGB(0, 0), "Reader renders oracle only after exact bootstrap validation");
|
|
var state = memcard(reader);
|
|
assertTrue(state.path("request").isNull(), state.toString());
|
|
assertEquals(4294967295L, state.path("session").path("appId").longValue());
|
|
} finally { close(reader); }
|
|
assertArrayEquals(durable, Files.readAllBytes(image), "Readback must not rewrite media");
|
|
System.out.println("PASS PBS process save/reopen optimizer=" + optimized + " version=" + version + " unchangedImageSha256=" + sha(durable));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
@Test void memoryOnlyShutdownRefusalKeepsSessionUntilExplicitDiscardAndOpenNeverCreates() throws Exception {
|
|
try (var packer = p.packer.Packer.bootstrap(mapper, ignored -> {})) {
|
|
Path project = root.resolve("memory");
|
|
String dirty = PREFIX + """
|
|
[MemcardBoot] fn restore(c: long) -> int {
|
|
context = c;
|
|
if Mem.presentation(c, "Dirty", 1 as long, 1, 1, new MemcardBuffer(560), 0, 560) != 0 as long { return 1; }
|
|
return 0;
|
|
}
|
|
[Frame] fn frame() -> void {
|
|
Mem.slot_write(context, 0, 0, new MemcardBuffer(1), 0, 1);
|
|
Gfx.clear(Color.rgb(1, 2, 3));
|
|
}
|
|
""";
|
|
var build = build(project, dirty, "1", true, packer);
|
|
var store = new ProjectLocalStudioSetupStore(mapper);
|
|
var reference = new ProjectCatalogService(project, mapper, store).openProject(project);
|
|
store.save(reference, new ProjectLocalStudioSetup(System.getProperty("studio.test.runtimeInstall"), null));
|
|
var gateway = new HeadlessProcessGateway(mapper, store::load);
|
|
Path absent = root.resolve("absent.pmc");
|
|
var failure = assertThrows(AutomationException.class, () -> gateway.boot(reference, "missing", build,
|
|
Map.of("memcard", Map.of("path", absent.toString(), "action", "open", "access", "read_write"), "memcardChoice", "persistent")));
|
|
assertEquals(AutomationFailure.Code.MEMCARD_ERROR, failure.failure().code()); assertFalse(Files.exists(absent));
|
|
var memory = (HeadlessProcessSession) gateway.boot(reference, "memory", build, Map.of("memcardChoice", "memory_fresh"));
|
|
try {
|
|
assertEquals(AutomationOutcome.Kind.SUCCEEDED, memory.advance(1, ignored -> {}).kind());
|
|
var refusal = assertThrows(ExecutionException.class, () -> memory.shutdown().toCompletableFuture().get(7, TimeUnit.SECONDS));
|
|
assertEquals(AutomationFailure.Code.MEMCARD_ERROR, ((AutomationException) refusal.getCause()).failure().code());
|
|
assertTrue(memory.alive()); assertTrue(memcard(memory).path("dirty").booleanValue());
|
|
assertNotNull(memory.observation().nativeDetails().get("memcard"));
|
|
assertTrue(memory.observation().recovery().stream().anyMatch(action -> action.action().equals("inspect_memcard")));
|
|
var resetRefusal = assertThrows(AutomationException.class, () -> memory.call(TaskTools.HeadlessAction.RESET, Map.of()));
|
|
assertEquals(AutomationFailure.Code.MEMCARD_ERROR, resetRefusal.failure().code());
|
|
assertTrue(memory.alive()); assertTrue(memcard(memory).path("dirty").booleanValue());
|
|
memory.call(TaskTools.HeadlessAction.RESET, Map.of("discardUnsaved", true, "pendingWrites", "cancel"));
|
|
assertFalse(memcard(memory).path("dirty").booleanValue());
|
|
assertFalse(Files.exists(project.resolve(".studio/memcard.pmc")));
|
|
memory.call(TaskTools.HeadlessAction.MEMCARD_MOUNT, Map.of("action", "create", "access", "read_write"));
|
|
assertTrue(Files.isRegularFile(project.resolve(".studio/memcard.pmc")));
|
|
memory.call(TaskTools.HeadlessAction.MEMCARD_UNMOUNT, Map.of());
|
|
for (var recovery : List.of(TaskTools.HeadlessAction.MEMCARD_RECONCILE, TaskTools.HeadlessAction.MEMCARD_CONTINUE_IN_MEMORY)) {
|
|
var rejected = assertThrows(AutomationException.class, () -> memory.call(recovery, Map.of()));
|
|
assertEquals(AutomationFailure.Code.MEMCARD_ERROR, rejected.failure().code());
|
|
var details = mapper.valueToTree(rejected.failure().runtimeError()).path("details");
|
|
assertEquals("invalid_state", details.path("reason").asText());
|
|
assertTrue(memory.alive());
|
|
}
|
|
memory.stop(Map.of("discardUnsaved", true, "pendingWrites", "cancel")).toCompletableFuture().get(7, TimeUnit.SECONDS);
|
|
assertFalse(memory.alive());
|
|
System.out.println("PASS protected reset/shutdown, explicit default-path create/unmount and native recovery refusal");
|
|
} finally { memory.abort("test cleanup"); }
|
|
}
|
|
}
|
|
}
|