c51b07ef95
Imported from the codex worktree's uncommitted work
(C:/Users/erikn/.codex/worktrees/bd98/acdream on
codex/atmospheric-rendering-campaign), on top of its 8b7b601b.
The remote-player shadow gate ran two clients on fixed sleeps, so the
observer could move before the primary had taken its 'before' screenshot,
or the primary could take its 'after' shot before the observer had moved.
Now the harness publishes named signal files into each client's artifact
directory and the routes block on them:
- IRetailUiAutomationRuntime.TryIsAutomationSignalPublished, implemented
by WorldLifecycleAutomationController over <artifactDir>/signals/
<name>.signal (names validated by AutomationArtifactName, so no path
escape).
- 'wait signal <name> [timeoutMs]' in RetailUiAutomationScriptRunner.
- run-connected-render-pack-remote-player-gate.ps1 publishes
'primary-before' to the observer after the primary's before-shot
completes, then 'observer-moved' to the primary after the observer's
remote-observer-moved checkpoint.
- Both routes teleport with an explicit heading and wait 12 s to settle.
Build green; the three touched App test classes pass 58/58 including the
two new signal tests.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
1069 lines
35 KiB
C#
1069 lines
35 KiB
C#
using System.Collections.Generic;
|
|
using System.IO;
|
|
using AcDream.App.UI;
|
|
using AcDream.App.UI.Testing;
|
|
using AcDream.Core.Items;
|
|
using AcDream.UI.Abstractions.Input;
|
|
|
|
namespace AcDream.App.Tests.UI;
|
|
|
|
public sealed class RetailUiAutomationProbeTests
|
|
{
|
|
private sealed class SpyHandler : IItemListDragHandler
|
|
{
|
|
public (UiItemList list, UiItemSlot cell, ItemDragPayload payload)? LastDrop;
|
|
public (UiItemList list, UiItemSlot cell, ItemDragPayload payload)? LastLift;
|
|
|
|
public void OnDragLift(UiItemList sourceList, UiItemSlot sourceCell, ItemDragPayload payload)
|
|
=> LastLift = (sourceList, sourceCell, payload);
|
|
|
|
public ItemDragAcceptance OnDragOver(UiItemList targetList, UiItemSlot targetCell, ItemDragPayload payload)
|
|
=> ItemDragAcceptance.Accept;
|
|
|
|
public void HandleDropRelease(UiItemList targetList, UiItemSlot targetCell, ItemDragPayload payload)
|
|
=> LastDrop = (targetList, targetCell, payload);
|
|
}
|
|
|
|
private sealed class FakeRuntime : IRetailUiAutomationRuntime
|
|
{
|
|
private sealed class FakeCheckpoint(int sequence, string name) :
|
|
IRetailUiAutomationCheckpoint
|
|
{
|
|
public int Sequence { get; } = sequence;
|
|
public string Name { get; } = name;
|
|
public RetailUiAutomationCheckpointStatus Status { get; set; } =
|
|
RetailUiAutomationCheckpointStatus.Pending;
|
|
public string? Error { get; set; }
|
|
}
|
|
|
|
private readonly List<FakeCheckpoint> _checkpointTokens = [];
|
|
|
|
public bool IsWorldReady { get; set; }
|
|
public bool IsWorldViewportVisible { get; set; }
|
|
public int PortalMaterializationCount { get; set; }
|
|
public int RenderPackPerformanceSampleCount { get; set; }
|
|
public bool RenderPackFailedToRetail { get; set; }
|
|
public RetailUiAutomationRenderPackStatus RenderPackStatus { get; set; } =
|
|
RetailUiAutomationRenderPackStatus.Retail;
|
|
public int FramebufferWidth { get; set; } = 1280;
|
|
public int FramebufferHeight { get; set; } = 720;
|
|
public int RenderPackPerformanceResetCount { get; private set; }
|
|
public List<string> RenderPackSelections { get; } = [];
|
|
public int RenderPackDisableCount { get; private set; }
|
|
public int RenderPackReenableCount { get; private set; }
|
|
public List<(int Width, int Height)> FramebufferResizes { get; } = [];
|
|
public int ClientCloseRequestCount { get; private set; }
|
|
public List<string> Checkpoints { get; } = new();
|
|
public HashSet<string> ScreenshotRequests { get; } = new();
|
|
public HashSet<string> CompletedScreenshots { get; } = new();
|
|
public HashSet<string> PublishedSignals { get; } = new();
|
|
|
|
public bool TryResetRenderPackPerformance(out string error)
|
|
{
|
|
RenderPackPerformanceResetCount++;
|
|
RenderPackPerformanceSampleCount = 0;
|
|
error = string.Empty;
|
|
return true;
|
|
}
|
|
|
|
public bool TrySelectRenderPack(string presetId, out string error)
|
|
{
|
|
RenderPackSelections.Add(presetId);
|
|
error = string.Empty;
|
|
return true;
|
|
}
|
|
|
|
public bool TryDisableRenderPack(out string error)
|
|
{
|
|
RenderPackDisableCount++;
|
|
error = string.Empty;
|
|
return true;
|
|
}
|
|
|
|
public bool TryReenableRenderPack(out string error)
|
|
{
|
|
RenderPackReenableCount++;
|
|
error = string.Empty;
|
|
return true;
|
|
}
|
|
|
|
public bool TryResizeFramebuffer(int width, int height, out string error)
|
|
{
|
|
FramebufferResizes.Add((width, height));
|
|
error = string.Empty;
|
|
return true;
|
|
}
|
|
|
|
public bool TryRequestClientClose(out string error)
|
|
{
|
|
ClientCloseRequestCount++;
|
|
error = string.Empty;
|
|
return true;
|
|
}
|
|
|
|
public bool TryRequestCheckpoint(
|
|
string name,
|
|
out IRetailUiAutomationCheckpoint? checkpoint,
|
|
out string error)
|
|
{
|
|
Checkpoints.Add(name);
|
|
var token = new FakeCheckpoint(_checkpointTokens.Count + 1, name);
|
|
_checkpointTokens.Add(token);
|
|
checkpoint = token;
|
|
error = string.Empty;
|
|
return true;
|
|
}
|
|
|
|
public void CancelCheckpoint(IRetailUiAutomationCheckpoint checkpoint)
|
|
{
|
|
var token = Assert.IsType<FakeCheckpoint>(checkpoint);
|
|
token.Status = RetailUiAutomationCheckpointStatus.Cancelled;
|
|
token.Error = $"checkpoint '{token.Name}' cancelled";
|
|
}
|
|
|
|
public void CompleteCheckpoint(
|
|
string name,
|
|
RetailUiAutomationCheckpointStatus status =
|
|
RetailUiAutomationCheckpointStatus.Succeeded,
|
|
string? error = null)
|
|
{
|
|
FakeCheckpoint token = Assert.Single(
|
|
_checkpointTokens,
|
|
value => value.Name == name);
|
|
if (token.Status != RetailUiAutomationCheckpointStatus.Pending)
|
|
throw new InvalidOperationException("checkpoint is already terminal");
|
|
token.Status = status;
|
|
token.Error = error;
|
|
}
|
|
|
|
public bool TryRequestScreenshot(string name, out string error)
|
|
{
|
|
ScreenshotRequests.Add(name);
|
|
error = string.Empty;
|
|
return true;
|
|
}
|
|
|
|
public bool IsScreenshotComplete(string name) => CompletedScreenshots.Contains(name);
|
|
|
|
public bool TryIsAutomationSignalPublished(
|
|
string name,
|
|
out bool published,
|
|
out string error)
|
|
{
|
|
published = PublishedSignals.Contains(name);
|
|
error = string.Empty;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
private static (UiRoot root, UiItemList source, UiItemList target, SpyHandler handler, ClientObjectTable objects)
|
|
RootWithTwoItemLists()
|
|
{
|
|
var root = new UiRoot { Width = 240, Height = 120 };
|
|
var objects = new ClientObjectTable();
|
|
|
|
var source = new UiItemList(_ => (1u, 1, 1))
|
|
{
|
|
DatElementId = 0x10000010u,
|
|
Left = 10,
|
|
Top = 10,
|
|
Width = 32,
|
|
Height = 32,
|
|
};
|
|
source.Cell.SlotIndex = 0;
|
|
source.Cell.SourceKind = ItemDragSource.Inventory;
|
|
source.Cell.SetItem(0x5001u, 0x99u);
|
|
|
|
var target = new UiItemList(_ => (1u, 1, 1))
|
|
{
|
|
DatElementId = 0x10000020u,
|
|
Left = 70,
|
|
Top = 10,
|
|
Width = 32,
|
|
Height = 32,
|
|
};
|
|
target.Cell.SlotIndex = 1;
|
|
|
|
var handler = new SpyHandler();
|
|
target.RegisterDragHandler(handler);
|
|
|
|
root.AddChild(source);
|
|
root.AddChild(target);
|
|
return (root, source, target, handler, objects);
|
|
}
|
|
|
|
[Fact]
|
|
public void Snapshot_listsDatElementsAndItemSlots()
|
|
{
|
|
var (root, _, _, _, objects) = RootWithTwoItemLists();
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
|
|
var rows = probe.Snapshot();
|
|
|
|
Assert.Contains(rows, r => r.DatElementId == 0x10000010u && r.TypeName == nameof(UiItemList));
|
|
var itemRow = Assert.Single(rows, r => r.ItemId == 0x5001u);
|
|
Assert.Equal(ItemDragSource.Inventory, itemRow.SourceKind);
|
|
Assert.Equal(0, itemRow.SlotIndex);
|
|
Assert.True(itemRow.Width > 0f);
|
|
Assert.True(itemRow.Height > 0f);
|
|
}
|
|
|
|
[Fact]
|
|
public void DoubleClickItem_routesThroughUiRootDoubleClick()
|
|
{
|
|
var (root, source, _, _, objects) = RootWithTwoItemLists();
|
|
bool doubleClicked = false;
|
|
source.Cell.DoubleClicked = () => doubleClicked = true;
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
|
|
Assert.True(probe.DoubleClickItem(0x5001u, ItemDragSource.Inventory));
|
|
|
|
Assert.True(doubleClicked);
|
|
}
|
|
|
|
[Fact]
|
|
public void DragItemToElement_deliversDropReleaseToTargetCell()
|
|
{
|
|
var (root, _, target, handler, objects) = RootWithTwoItemLists();
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
|
|
Assert.True(probe.DragItemToElement(0x5001u, 0x10000020u, ItemDragSource.Inventory));
|
|
|
|
Assert.NotNull(handler.LastDrop);
|
|
Assert.Same(target, handler.LastDrop!.Value.list);
|
|
Assert.Same(target.Cell, handler.LastDrop.Value.cell);
|
|
Assert.Equal(0x5001u, handler.LastDrop.Value.payload.ObjId);
|
|
}
|
|
|
|
[Fact]
|
|
public void DragItemOutside_raisesRootOutsideUiEvent()
|
|
{
|
|
var (root, _, _, _, objects) = RootWithTwoItemLists();
|
|
object? payload = null;
|
|
(int x, int y) release = default;
|
|
root.DragReleasedOutsideUi += (p, x, y) =>
|
|
{
|
|
payload = p;
|
|
release = (x, y);
|
|
};
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
|
|
Assert.True(probe.DragItemOutside(0x5001u, 220, 100, ItemDragSource.Inventory));
|
|
|
|
var itemPayload = Assert.IsType<ItemDragPayload>(payload);
|
|
Assert.Equal(0x5001u, itemPayload.ObjId);
|
|
Assert.Equal((220, 100), release);
|
|
}
|
|
|
|
[Fact]
|
|
public void AssertItem_checksObjectTableState()
|
|
{
|
|
var objects = new ClientObjectTable();
|
|
objects.AddOrUpdate(new ClientObject
|
|
{
|
|
ObjectId = 0x5001u,
|
|
ContainerId = 0x7001u,
|
|
ContainerSlot = 3,
|
|
CurrentlyEquippedLocation = EquipMask.ChestArmor | EquipMask.UpperArmArmor,
|
|
});
|
|
var probe = new RetailUiAutomationProbe(new UiRoot(), objects);
|
|
|
|
var ok = probe.AssertItem(
|
|
0x5001u,
|
|
equippedLocation: EquipMask.ChestArmor | EquipMask.UpperArmArmor,
|
|
containerId: 0x7001u,
|
|
slot: 3);
|
|
var bad = probe.AssertItem(0x5001u, slot: 4);
|
|
|
|
Assert.True(ok.Success);
|
|
Assert.False(bad.Success);
|
|
}
|
|
|
|
[Fact]
|
|
public void ScriptRunner_waitItemThenDoubleClick_executesThroughProbe()
|
|
{
|
|
var (root, source, _, _, objects) = RootWithTwoItemLists();
|
|
bool doubleClicked = false;
|
|
source.Cell.DoubleClicked = () => doubleClicked = true;
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
var logs = new List<string>();
|
|
string path = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName() + ".ui-probe.txt");
|
|
File.WriteAllLines(path, new[]
|
|
{
|
|
"wait item 0x5001 inventory 100",
|
|
"doubleclick item 0x5001 inventory",
|
|
});
|
|
|
|
try
|
|
{
|
|
var runner = new RetailUiAutomationScriptRunner(probe, path, dumpOnStart: false, logs.Add);
|
|
|
|
runner.Tick(0.016);
|
|
|
|
Assert.True(doubleClicked);
|
|
Assert.True(runner.Completed);
|
|
Assert.Contains(logs, line => line.Contains("UI probe script complete"));
|
|
}
|
|
finally
|
|
{
|
|
File.Delete(path);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void ScriptRunner_command_routesThroughInjectedClientSubmitPath()
|
|
{
|
|
var (root, _, _, _, objects) = RootWithTwoItemLists();
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
var submitted = new List<string>();
|
|
string path = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName() + ".ui-probe.txt");
|
|
File.WriteAllText(path, "command /ls");
|
|
|
|
try
|
|
{
|
|
var runner = new RetailUiAutomationScriptRunner(
|
|
probe,
|
|
path,
|
|
dumpOnStart: false,
|
|
submitCommand: submitted.Add);
|
|
|
|
runner.Tick(0.016);
|
|
|
|
Assert.Equal(["/ls"], submitted);
|
|
Assert.True(runner.Completed);
|
|
}
|
|
finally
|
|
{
|
|
File.Delete(path);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void ScriptRunner_sleep_preserves_fractional_uncapped_frame_time()
|
|
{
|
|
var (root, _, _, _, objects) = RootWithTwoItemLists();
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
var submitted = new List<string>();
|
|
string path = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName() + ".ui-probe.txt");
|
|
File.WriteAllLines(path, ["sleep 10", "command /ls"]);
|
|
|
|
try
|
|
{
|
|
var runner = new RetailUiAutomationScriptRunner(
|
|
probe,
|
|
path,
|
|
dumpOnStart: false,
|
|
submitCommand: submitted.Add);
|
|
|
|
runner.Tick(0d); // Arm the sleep at script time zero.
|
|
for (int i = 0; i < 1_000; i++)
|
|
runner.Tick(0.000001); // 1 ms total, not the old artificial 1,000 ms.
|
|
|
|
Assert.Empty(submitted);
|
|
Assert.False(runner.Completed);
|
|
|
|
runner.Tick(0.009); // Exact 10 ms deadline, including the 1 ms above.
|
|
|
|
Assert.Equal(["/ls"], submitted);
|
|
Assert.True(runner.Completed);
|
|
}
|
|
finally
|
|
{
|
|
File.Delete(path);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void ScriptRunner_sleep_releases_on_exact_fractional_frame_deadline()
|
|
{
|
|
var (root, _, _, _, objects) = RootWithTwoItemLists();
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
var submitted = new List<string>();
|
|
string path = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName() + ".ui-probe.txt");
|
|
File.WriteAllLines(path, ["sleep 1000", "command /ls"]);
|
|
|
|
try
|
|
{
|
|
var runner = new RetailUiAutomationScriptRunner(
|
|
probe,
|
|
path,
|
|
dumpOnStart: false,
|
|
submitCommand: submitted.Add);
|
|
|
|
runner.Tick(0d); // Arm the sleep at script time zero.
|
|
for (int i = 0; i < 60; i++)
|
|
runner.Tick(1d / 60d);
|
|
|
|
Assert.Equal(["/ls"], submitted);
|
|
Assert.True(runner.Completed);
|
|
}
|
|
finally
|
|
{
|
|
File.Delete(path);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void ScriptRunner_sleep_rebases_fractional_clock_after_long_prior_command()
|
|
{
|
|
var (root, _, _, _, objects) = RootWithTwoItemLists();
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
var submitted = new List<string>();
|
|
string path = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName() + ".ui-probe.txt");
|
|
File.WriteAllLines(path, ["sleep 1000000", "sleep 1000", "command /ls"]);
|
|
|
|
try
|
|
{
|
|
var runner = new RetailUiAutomationScriptRunner(
|
|
probe,
|
|
path,
|
|
dumpOnStart: false,
|
|
submitCommand: submitted.Add);
|
|
|
|
runner.Tick(0d);
|
|
runner.Tick(1000d); // Complete the 1,000,000 ms precursor and arm the next sleep.
|
|
for (int i = 0; i < 60; i++)
|
|
runner.Tick(1d / 60d);
|
|
|
|
Assert.Equal(["/ls"], submitted);
|
|
Assert.True(runner.Completed);
|
|
}
|
|
finally
|
|
{
|
|
File.Delete(path);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void ScriptRunner_sleep_ignores_invalid_or_overflowing_frame_deltas()
|
|
{
|
|
var (root, _, _, _, objects) = RootWithTwoItemLists();
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
var submitted = new List<string>();
|
|
string path = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName() + ".ui-probe.txt");
|
|
File.WriteAllLines(path, ["sleep 1", "command /ls"]);
|
|
|
|
try
|
|
{
|
|
var runner = new RetailUiAutomationScriptRunner(
|
|
probe,
|
|
path,
|
|
dumpOnStart: false,
|
|
submitCommand: submitted.Add);
|
|
|
|
runner.Tick(0d);
|
|
runner.Tick(double.NaN);
|
|
runner.Tick(double.PositiveInfinity);
|
|
runner.Tick(double.NegativeInfinity);
|
|
runner.Tick(double.MaxValue); // Finite input whose millisecond conversion overflows.
|
|
runner.Tick(-1d);
|
|
|
|
Assert.Empty(submitted);
|
|
Assert.False(runner.Completed);
|
|
|
|
runner.Tick(0.001d);
|
|
|
|
Assert.Equal(["/ls"], submitted);
|
|
Assert.True(runner.Completed);
|
|
}
|
|
finally
|
|
{
|
|
File.Delete(path);
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(30)]
|
|
[InlineData(120)]
|
|
public void ScriptRunner_wait_timeout_does_not_fire_on_exact_fractional_deadline(int framesPerSecond)
|
|
{
|
|
var (root, _, _, _, objects) = RootWithTwoItemLists();
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
var logs = new List<string>();
|
|
string path = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName() + ".ui-probe.txt");
|
|
File.WriteAllLines(path, ["sleep 1000000", "wait item 0xDEAD inventory 1000"]);
|
|
|
|
try
|
|
{
|
|
var runner = new RetailUiAutomationScriptRunner(
|
|
probe,
|
|
path,
|
|
dumpOnStart: false,
|
|
log: logs.Add);
|
|
|
|
runner.Tick(0d);
|
|
runner.Tick(1000d); // Complete the precursor and arm the wait at a rebased zero.
|
|
for (int i = 0; i < framesPerSecond; i++)
|
|
runner.Tick(1d / framesPerSecond);
|
|
|
|
Assert.False(runner.Completed);
|
|
Assert.DoesNotContain(logs, line => line.Contains("timed out", StringComparison.Ordinal));
|
|
|
|
runner.Tick(1d / framesPerSecond);
|
|
|
|
Assert.True(runner.Completed);
|
|
Assert.Contains(logs, line => line.Contains("timed out", StringComparison.Ordinal));
|
|
}
|
|
finally
|
|
{
|
|
File.Delete(path);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void ScriptRunner_one_hour_sleep_releases_on_exact_60Hz_deadline()
|
|
{
|
|
var (root, _, _, _, objects) = RootWithTwoItemLists();
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
var submitted = new List<string>();
|
|
string path = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName() + ".ui-probe.txt");
|
|
File.WriteAllLines(path, ["sleep 3600000", "command /ls"]);
|
|
|
|
try
|
|
{
|
|
var runner = new RetailUiAutomationScriptRunner(
|
|
probe,
|
|
path,
|
|
dumpOnStart: false,
|
|
submitCommand: submitted.Add);
|
|
|
|
runner.Tick(0d);
|
|
for (int i = 0; i < 60 * 60 * 60; i++)
|
|
runner.Tick(1d / 60d);
|
|
|
|
Assert.Equal(["/ls"], submitted);
|
|
Assert.True(runner.Completed);
|
|
}
|
|
finally
|
|
{
|
|
File.Delete(path);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void ScriptRunner_one_hour_wait_does_not_timeout_on_exact_30Hz_deadline()
|
|
{
|
|
var (root, _, _, _, objects) = RootWithTwoItemLists();
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
var logs = new List<string>();
|
|
string path = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName() + ".ui-probe.txt");
|
|
File.WriteAllText(path, "wait item 0xDEAD inventory 3600000");
|
|
|
|
try
|
|
{
|
|
var runner = new RetailUiAutomationScriptRunner(
|
|
probe,
|
|
path,
|
|
dumpOnStart: false,
|
|
log: logs.Add);
|
|
|
|
runner.Tick(0d);
|
|
for (int i = 0; i < 30 * 60 * 60; i++)
|
|
runner.Tick(1d / 30d);
|
|
|
|
Assert.False(runner.Completed);
|
|
Assert.DoesNotContain(logs, line => line.Contains("timed out", StringComparison.Ordinal));
|
|
|
|
runner.Tick(1d / 30d);
|
|
|
|
Assert.True(runner.Completed);
|
|
Assert.Contains(logs, line => line.Contains("timed out", StringComparison.Ordinal));
|
|
}
|
|
finally
|
|
{
|
|
File.Delete(path);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void ScriptRunner_input_drivesSemanticPressAndHeldEdges()
|
|
{
|
|
var (root, _, _, _, objects) = RootWithTwoItemLists();
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
var presses = new List<InputAction>();
|
|
var held = new List<(InputAction Action, bool Held)>();
|
|
string path = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName() + ".ui-probe.txt");
|
|
File.WriteAllLines(path,
|
|
[
|
|
"input down MovementForward",
|
|
"sleep 10",
|
|
"input up MovementForward",
|
|
"input press CombatToggleCombat",
|
|
]);
|
|
|
|
try
|
|
{
|
|
using var runner = new RetailUiAutomationScriptRunner(
|
|
probe,
|
|
path,
|
|
dumpOnStart: false,
|
|
pressInput: action =>
|
|
{
|
|
presses.Add(action);
|
|
return true;
|
|
},
|
|
setInputHeld: (action, isHeld) =>
|
|
{
|
|
held.Add((action, isHeld));
|
|
return true;
|
|
});
|
|
|
|
runner.Tick(0d);
|
|
Assert.Equal([(InputAction.MovementForward, true)], held);
|
|
Assert.False(runner.Completed);
|
|
|
|
runner.Tick(0.010d);
|
|
|
|
Assert.True(runner.Completed);
|
|
Assert.Equal(
|
|
[(InputAction.MovementForward, true), (InputAction.MovementForward, false)],
|
|
held);
|
|
Assert.Equal([InputAction.CombatToggleCombat], presses);
|
|
}
|
|
finally
|
|
{
|
|
File.Delete(path);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void ScriptRunner_dispose_releasesInjectedHeldActions()
|
|
{
|
|
var (root, _, _, _, objects) = RootWithTwoItemLists();
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
var held = new List<(InputAction Action, bool Held)>();
|
|
string path = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName() + ".ui-probe.txt");
|
|
File.WriteAllLines(path, ["input down MovementForward", "sleep 10000"]);
|
|
|
|
try
|
|
{
|
|
var runner = new RetailUiAutomationScriptRunner(
|
|
probe,
|
|
path,
|
|
dumpOnStart: false,
|
|
setInputHeld: (action, isHeld) =>
|
|
{
|
|
held.Add((action, isHeld));
|
|
return true;
|
|
});
|
|
|
|
runner.Tick(0d);
|
|
runner.Dispose();
|
|
|
|
Assert.Equal(
|
|
[(InputAction.MovementForward, true), (InputAction.MovementForward, false)],
|
|
held);
|
|
}
|
|
finally
|
|
{
|
|
File.Delete(path);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void ScriptRunner_worldLifecycleCommands_waitForCanonicalRuntimeState()
|
|
{
|
|
var (root, _, _, _, objects) = RootWithTwoItemLists();
|
|
var runtime = new FakeRuntime();
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
string path = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName() + ".ui-probe.txt");
|
|
File.WriteAllLines(path,
|
|
[
|
|
"wait world-ready 1000",
|
|
"wait world-visible 1000",
|
|
"wait materialized 2 1000",
|
|
"checkpoint stable",
|
|
"screenshot stable 1000",
|
|
]);
|
|
|
|
try
|
|
{
|
|
using var runner = new RetailUiAutomationScriptRunner(
|
|
probe,
|
|
path,
|
|
dumpOnStart: false,
|
|
runtime: runtime);
|
|
|
|
runner.Tick(0d);
|
|
Assert.False(runner.Completed);
|
|
|
|
runtime.IsWorldReady = true;
|
|
runner.Tick(0.001d);
|
|
Assert.False(runner.Completed);
|
|
|
|
runtime.IsWorldViewportVisible = true;
|
|
runtime.PortalMaterializationCount = 2;
|
|
runner.Tick(0.001d);
|
|
|
|
Assert.Equal(["stable"], runtime.Checkpoints);
|
|
Assert.DoesNotContain("stable", runtime.ScreenshotRequests);
|
|
Assert.False(runner.Completed);
|
|
|
|
runner.Tick(0.001d);
|
|
Assert.Equal(["stable"], runtime.Checkpoints);
|
|
Assert.DoesNotContain("stable", runtime.ScreenshotRequests);
|
|
|
|
runtime.CompleteCheckpoint("stable");
|
|
runner.Tick(0.001d);
|
|
|
|
Assert.Contains("stable", runtime.ScreenshotRequests);
|
|
Assert.False(runner.Completed);
|
|
|
|
runtime.CompletedScreenshots.Add("stable");
|
|
runner.Tick(0.001d);
|
|
|
|
Assert.True(runner.Completed);
|
|
}
|
|
finally
|
|
{
|
|
File.Delete(path);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void ScriptRunner_signalWaitBlocksUntilHarnessPublishesExactName()
|
|
{
|
|
var (root, _, _, _, objects) = RootWithTwoItemLists();
|
|
var runtime = new FakeRuntime();
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
string path = Path.Combine(
|
|
Path.GetTempPath(),
|
|
Path.GetRandomFileName() + ".ui-probe.txt");
|
|
File.WriteAllLines(path,
|
|
[
|
|
"wait signal observer-moved 1000",
|
|
"input press CombatToggleCombat",
|
|
]);
|
|
var presses = new List<InputAction>();
|
|
|
|
try
|
|
{
|
|
using var runner = new RetailUiAutomationScriptRunner(
|
|
probe,
|
|
path,
|
|
dumpOnStart: false,
|
|
pressInput: action =>
|
|
{
|
|
presses.Add(action);
|
|
return true;
|
|
},
|
|
runtime: runtime);
|
|
|
|
runner.Tick(0d);
|
|
Assert.False(runner.Completed);
|
|
Assert.Empty(presses);
|
|
|
|
runtime.PublishedSignals.Add("another-signal");
|
|
runner.Tick(0.5d);
|
|
Assert.False(runner.Completed);
|
|
Assert.Empty(presses);
|
|
|
|
runtime.PublishedSignals.Add("observer-moved");
|
|
runner.Tick(0.001d);
|
|
Assert.True(runner.Completed);
|
|
Assert.Equal([InputAction.CombatToggleCombat], presses);
|
|
}
|
|
finally
|
|
{
|
|
File.Delete(path);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void ScriptRunner_resetsThenWaitsForCompleteRenderPackEvidenceWindow()
|
|
{
|
|
var (root, _, _, _, objects) = RootWithTwoItemLists();
|
|
var runtime = new FakeRuntime
|
|
{
|
|
RenderPackPerformanceSampleCount = 1200,
|
|
};
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
string path = Path.Combine(
|
|
Path.GetTempPath(),
|
|
Path.GetRandomFileName() + ".ui-probe.txt");
|
|
File.WriteAllLines(path,
|
|
[
|
|
"renderpack reset-performance",
|
|
"wait render-pack-samples 2048 1000",
|
|
"screenshot complete-window 1000",
|
|
]);
|
|
|
|
try
|
|
{
|
|
using var runner = new RetailUiAutomationScriptRunner(
|
|
probe,
|
|
path,
|
|
dumpOnStart: false,
|
|
runtime: runtime);
|
|
|
|
runner.Tick(0d);
|
|
Assert.Equal(1, runtime.RenderPackPerformanceResetCount);
|
|
Assert.Equal(0, runtime.RenderPackPerformanceSampleCount);
|
|
Assert.Empty(runtime.ScreenshotRequests);
|
|
|
|
runtime.RenderPackPerformanceSampleCount = 2047;
|
|
runner.Tick(0.5d);
|
|
Assert.Empty(runtime.ScreenshotRequests);
|
|
|
|
runtime.RenderPackPerformanceSampleCount = 2048;
|
|
runner.Tick(0.001d);
|
|
Assert.Contains("complete-window", runtime.ScreenshotRequests);
|
|
Assert.False(runner.Completed);
|
|
|
|
runtime.CompletedScreenshots.Add("complete-window");
|
|
runner.Tick(0.001d);
|
|
Assert.True(runner.Completed);
|
|
}
|
|
finally
|
|
{
|
|
File.Delete(path);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void ScriptRunner_renderPackWaitTerminatesEarlyForFailedToRetailFallback()
|
|
{
|
|
var (root, _, _, _, objects) = RootWithTwoItemLists();
|
|
var runtime = new FakeRuntime
|
|
{
|
|
RenderPackFailedToRetail = true,
|
|
};
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
string path = Path.Combine(
|
|
Path.GetTempPath(),
|
|
Path.GetRandomFileName() + ".ui-probe.txt");
|
|
File.WriteAllLines(path,
|
|
[
|
|
"renderpack reset-performance",
|
|
"wait render-pack-samples 2048 300000",
|
|
"screenshot safe-fallback 1000",
|
|
]);
|
|
|
|
try
|
|
{
|
|
using var runner = new RetailUiAutomationScriptRunner(
|
|
probe,
|
|
path,
|
|
dumpOnStart: false,
|
|
runtime: runtime);
|
|
|
|
runner.Tick(0d);
|
|
|
|
Assert.Equal(1, runtime.RenderPackPerformanceResetCount);
|
|
Assert.Equal(0, runtime.RenderPackPerformanceSampleCount);
|
|
Assert.Contains("safe-fallback", runtime.ScreenshotRequests);
|
|
Assert.False(runner.Completed);
|
|
|
|
runtime.CompletedScreenshots.Add("safe-fallback");
|
|
runner.Tick(0.001d);
|
|
Assert.True(runner.Completed);
|
|
}
|
|
finally
|
|
{
|
|
File.Delete(path);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void ScriptRunner_renderPackTransitionsAndResizeWaitForPublishedRuntimeState()
|
|
{
|
|
var (root, _, _, _, objects) = RootWithTwoItemLists();
|
|
var runtime = new FakeRuntime();
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
string path = Path.Combine(
|
|
Path.GetTempPath(),
|
|
Path.GetRandomFileName() + ".ui-probe.txt");
|
|
File.WriteAllLines(path,
|
|
[
|
|
"renderpack select high",
|
|
"wait render-pack high 1000",
|
|
"renderpack disable",
|
|
"wait render-pack retail 1000",
|
|
"renderpack reenable",
|
|
"wait render-pack high 1000",
|
|
"resize 1024 768",
|
|
"wait framebuffer 1024 768 1000",
|
|
]);
|
|
|
|
try
|
|
{
|
|
using var runner = new RetailUiAutomationScriptRunner(
|
|
probe,
|
|
path,
|
|
dumpOnStart: false,
|
|
runtime: runtime);
|
|
|
|
runner.Tick(0d);
|
|
Assert.Equal(["high"], runtime.RenderPackSelections);
|
|
Assert.False(runner.Completed);
|
|
|
|
runtime.RenderPackStatus = new RetailUiAutomationRenderPackStatus(
|
|
RetailUiAutomationRenderPackState.Active,
|
|
"acdream.atmospheric",
|
|
"high",
|
|
ActivationGeneration: 1,
|
|
FailureReason: null);
|
|
runner.Tick(0.001d);
|
|
Assert.Equal(1, runtime.RenderPackDisableCount);
|
|
|
|
runtime.RenderPackStatus = RetailUiAutomationRenderPackStatus.Retail;
|
|
runner.Tick(0.001d);
|
|
Assert.Equal(1, runtime.RenderPackReenableCount);
|
|
|
|
runtime.RenderPackStatus = new RetailUiAutomationRenderPackStatus(
|
|
RetailUiAutomationRenderPackState.Active,
|
|
"acdream.atmospheric",
|
|
"high",
|
|
ActivationGeneration: 3,
|
|
FailureReason: null);
|
|
runner.Tick(0.001d);
|
|
Assert.Equal([(1024, 768)], runtime.FramebufferResizes);
|
|
Assert.False(runner.Completed);
|
|
|
|
runtime.FramebufferWidth = 1024;
|
|
runtime.FramebufferHeight = 768;
|
|
runner.Tick(0.001d);
|
|
Assert.True(runner.Completed);
|
|
}
|
|
finally
|
|
{
|
|
File.Delete(path);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void ScriptRunner_closeClientRequestsNormalRuntimeShutdownExactlyOnce()
|
|
{
|
|
var (root, _, _, _, objects) = RootWithTwoItemLists();
|
|
var runtime = new FakeRuntime();
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
string path = Path.Combine(
|
|
Path.GetTempPath(),
|
|
Path.GetRandomFileName() + ".ui-probe.txt");
|
|
File.WriteAllText(path, "close-client");
|
|
|
|
try
|
|
{
|
|
using var runner = new RetailUiAutomationScriptRunner(
|
|
probe,
|
|
path,
|
|
dumpOnStart: false,
|
|
runtime: runtime);
|
|
|
|
runner.Tick(0d);
|
|
runner.Tick(0d);
|
|
|
|
Assert.True(runner.Completed);
|
|
Assert.Equal(1, runtime.ClientCloseRequestCount);
|
|
}
|
|
finally
|
|
{
|
|
File.Delete(path);
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(RetailUiAutomationCheckpointStatus.Failed, "deferred write failed")]
|
|
[InlineData(RetailUiAutomationCheckpointStatus.Cancelled, "shutdown cancelled")]
|
|
public void ScriptRunner_checkpointTerminalFailure_StopsWithExactError(
|
|
RetailUiAutomationCheckpointStatus status,
|
|
string expectedError)
|
|
{
|
|
var (root, _, _, _, objects) = RootWithTwoItemLists();
|
|
var runtime = new FakeRuntime();
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
var logs = new List<string>();
|
|
string path = Path.Combine(
|
|
Path.GetTempPath(),
|
|
Path.GetRandomFileName() + ".ui-probe.txt");
|
|
File.WriteAllLines(path, ["checkpoint stable", "input press CombatToggleCombat"]);
|
|
|
|
try
|
|
{
|
|
using var runner = new RetailUiAutomationScriptRunner(
|
|
probe,
|
|
path,
|
|
dumpOnStart: false,
|
|
log: logs.Add,
|
|
runtime: runtime);
|
|
|
|
runner.Tick(0d);
|
|
runtime.CompleteCheckpoint("stable", status, expectedError);
|
|
runner.Tick(0d);
|
|
|
|
Assert.True(runner.Completed);
|
|
Assert.Equal(["stable"], runtime.Checkpoints);
|
|
Assert.Contains(logs, line => line.Contains(
|
|
expectedError,
|
|
StringComparison.Ordinal));
|
|
}
|
|
finally
|
|
{
|
|
File.Delete(path);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void ScriptRunner_disposeCancelsPendingCheckpoint()
|
|
{
|
|
var (root, _, _, _, objects) = RootWithTwoItemLists();
|
|
var runtime = new FakeRuntime();
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
string path = Path.Combine(
|
|
Path.GetTempPath(),
|
|
Path.GetRandomFileName() + ".ui-probe.txt");
|
|
File.WriteAllText(path, "checkpoint stable");
|
|
|
|
try
|
|
{
|
|
var runner = new RetailUiAutomationScriptRunner(
|
|
probe,
|
|
path,
|
|
dumpOnStart: false,
|
|
runtime: runtime);
|
|
runner.Tick(0d);
|
|
|
|
runner.Dispose();
|
|
|
|
Assert.Equal(["stable"], runtime.Checkpoints);
|
|
Assert.Throws<InvalidOperationException>(() =>
|
|
runtime.CompleteCheckpoint("stable"));
|
|
}
|
|
finally
|
|
{
|
|
File.Delete(path);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void ScriptRunner_worldReadyTimeout_stopsWithActionableLine()
|
|
{
|
|
var (root, _, _, _, objects) = RootWithTwoItemLists();
|
|
var runtime = new FakeRuntime();
|
|
var probe = new RetailUiAutomationProbe(root, objects);
|
|
var logs = new List<string>();
|
|
string path = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName() + ".ui-probe.txt");
|
|
File.WriteAllText(path, "wait world-ready 10");
|
|
|
|
try
|
|
{
|
|
using var runner = new RetailUiAutomationScriptRunner(
|
|
probe,
|
|
path,
|
|
dumpOnStart: false,
|
|
log: logs.Add,
|
|
runtime: runtime);
|
|
|
|
runner.Tick(0d);
|
|
runner.Tick(0.011d);
|
|
|
|
Assert.True(runner.Completed);
|
|
Assert.Contains(logs, line =>
|
|
line.Contains("timed out waiting for world readiness", StringComparison.Ordinal));
|
|
}
|
|
finally
|
|
{
|
|
File.Delete(path);
|
|
}
|
|
}
|
|
}
|