0.9.2: gate checks, platform fixes, plainer errors, process-name suggestion #59

Merged
ethan-hann merged 56 commits from integration-092 into main 2026-10-24 02:49:41 -05:00
Owner

Bundles the fixes for the 0.9.2 pre-release. Each issue was built test first on its own branch; the commit messages record the observed reds.

Gate: the App and Core test modules run side by side (#51), and the gate fails on a skipped test its OS's list does not name (#50, tools/SkipCheck, build/expected-skips/). New tests prove the layout, automation and job-pill audits can fail (#49).

Platform: Cmd+C copies job details on macOS (#4). On Linux an exited but unreaped git counts as gone, for both the stamp check and the wait at start (#35).

Snapshots and storage: a folder an update found nothing new in reports Skipped instead of Ok (#22); regression tests for a held file during a first snapshot, which already names the file (#23); the startup screen says when it is finishing an earlier cleanup (#8); a storage move is allowed from the folder "Start with an empty folder" made, marked by a file it writes, while an unmarked empty folder stays refused (#21, BL-004).

Screens: pinned footers, banners and cards lift above the job pill (#9); History scrolls as a whole and keeps three snapshot rows at the smallest windows (#10).

Plain language: storage-move and clear lines and the Settings left-behind cards name game folders, not git's (#11); held-file and disk-space copy names the operation (#12); the error card's Show details explains and offers Copy details for support instead of rendering raw text (#13).

Release: the MSYS2 and MINGW package sources are pinned and downloaded with --sources (#16).

Game editor: suggests a process name for link starts and says why; the link grace is two minutes (#41).

Docs: D48 records the calls; architecture, ui-guide, developer-guide and the notices are updated. Follow-ups are #52 to #58.

Closes #4, closes #8, closes #9, closes #10, closes #11, closes #12, closes #13, closes #16, closes #21, closes #22, closes #23, closes #35, closes #41, closes #49, closes #50, closes #51

Bundles the fixes for the 0.9.2 pre-release. Each issue was built test first on its own branch; the commit messages record the observed reds. Gate: the App and Core test modules run side by side (#51), and the gate fails on a skipped test its OS's list does not name (#50, `tools/SkipCheck`, `build/expected-skips/`). New tests prove the layout, automation and job-pill audits can fail (#49). Platform: Cmd+C copies job details on macOS (#4). On Linux an exited but unreaped git counts as gone, for both the stamp check and the wait at start (#35). Snapshots and storage: a folder an update found nothing new in reports Skipped instead of Ok (#22); regression tests for a held file during a first snapshot, which already names the file (#23); the startup screen says when it is finishing an earlier cleanup (#8); a storage move is allowed from the folder "Start with an empty folder" made, marked by a file it writes, while an unmarked empty folder stays refused (#21, BL-004). Screens: pinned footers, banners and cards lift above the job pill (#9); History scrolls as a whole and keeps three snapshot rows at the smallest windows (#10). Plain language: storage-move and clear lines and the Settings left-behind cards name game folders, not git's (#11); held-file and disk-space copy names the operation (#12); the error card's Show details explains and offers Copy details for support instead of rendering raw text (#13). Release: the MSYS2 and MINGW package sources are pinned and downloaded with `--sources` (#16). Game editor: suggests a process name for link starts and says why; the link grace is two minutes (#41). Docs: D48 records the calls; architecture, ui-guide, developer-guide and the notices are updated. Follow-ups are #52 to #58. Closes #4, closes #8, closes #9, closes #10, closes #11, closes #12, closes #13, closes #16, closes #21, closes #22, closes #23, closes #35, closes #41, closes #49, closes #50, closes #51
The Activity details list copied only on Ctrl+C, which is not the copy shortcut on macOS. A new CopyKey picks Cmd on macOS and Ctrl elsewhere, with the platform injectable for tests. No other shortcut in the app is Ctrl-only (the remaining key handling is Enter, Escape, F1 and Cmd+?).

Observed reds before the fix:
- CopyKeyTests.Cmd_C_copies_on_macOS: Assert.True() Failure, Expected True, Actual False
- CopyKeyTests.Ctrl_C_does_not_copy_on_macOS: Assert.False() Failure, Expected False, Actual True
The other three tests passed on the Ctrl-only code; a mutation (Control replaced by Meta on the non-macOS branch) made Ctrl_C_copies_elsewhere and Cmd_C_does_not_copy_elsewhere fail.
ProcessStamp.IsRunning trusted Process.HasExited, which .NET reports as false for a zombie that is not SavePoint's own child. In a container whose PID 1 never reaps, the next start or game write could then wait on a git that had already finished. On Linux the stamp now also applies the rule the process list uses (states Z, X and x), through a shared LinuxProcessInspector.HasExited. The /proc folder is injectable, so the tests run on Windows too.

Observed red before the fix:
- ProcessStampTests.A_live_process_whose_stat_says_zombie_counts_as_gone: Assert.False() Failure, Expected False, Actual True
The other two tests passed on the old code; inverting the new check made all three fail.
The capture path already maps git's 'unable to index file' report to the held-file error, for a first snapshot as for any save, so this adds regression tests rather than a fix. Engine: a first snapshot of a new folder, with and without progress reporting, stops with the in-use error naming the file. Journey (Windows, real backend): the wizard's first snapshot over a file the stand-in game holds ends on the partial card naming the file with Try again as the primary action, and Try again finishes once the file is released.

Observed: both new tests passed on first run (no red; behavior already present). Mutation check: making the held-file lookup read an empty report fails all six held-file save tests, including the two new ones (expected error.gitOperation.checkoutFailed, actual error.gitOperation.failed); restored.
Each audit helper had callers that only assert an empty list, so an edit that
made a helper report nothing kept hundreds of rows green. AuditsCanFailTests
feeds each a hand-built tree and asserts which control each problem names:
layout (button outside the window, combo box and toggle switch off-screen,
squeezed scroll area; a button in a roomy scroll area is not flagged),
automation (nameless, type-named and glyph-only buttons flagged; a named one
is not) and the job pill (the control under the pill is named, the one clear
of it is not).

The pill's Covered check moves from JobPillPlacementTests into a test helper,
JobPillAudit, beside LayoutAudit so it can be tested; behavior is unchanged.
ToggleSwitch derives from Button, so IsReachable already covers it.

Observed reds (mutation runs, each restored afterwards):
- LayoutAudit.Problems returns []: layout test fails, Assert.Equal() Expected 4, Actual 0.
- ComboBox dropped from IsReachable: layout test fails, Expected 4, Actual 3.
- NeedsName returns false: automation test fails, Expected 3, Actual 0.
- TakesTheClick returns false: pill test fails, Assert.Single() The collection was empty.
Real helpers: AuditsCanFailTests 3 of 3 and JobPillPlacementTests 125 of 125 pass.
The move guard refused any storage folder that held none of the listed games' folders, so after Start with an empty folder, when a listed game's folder could not be confirmed and got no repository, the folder was empty and Settings refused to move it as unreachable. The guard now refuses only when the folder has no game folder and holds other entries (a drive that is not the one with the history); a folder with nothing in it can be moved.

Observed red: StorageMoveAfterEmptyStartTests.A_move_is_allowed_from_an_empty_folder_that_holds_no_repository_for_the_listed_games failed with Assert.Null() Failure: Expected null, Actual error.storage.unreachable.
The refusal test A_move_is_still_refused_from_a_folder_with_other_files_and_none_of_the_listed_games passed on first run; with the new check forced to false it failed (Expected error.storage.unreachable, Actual null), then the code was restored.
An update of the latest snapshot leaves a folder with nothing unsaved exactly as it was, but reported it like any written folder, so the result and the activity line said it was saved. FolderOutcome gains Skipped (still Ok, no longer Saved); the capture runner sets it where it decides to leave the folder alone, logs a new activity step ('Nothing new in the ... so its latest snapshot stays as it is'), and the partial-result card shows such a folder as 'nothing new, snapshot kept as it was' with the info icon, counting it as already in the snapshot in the card's sentence.

Observed reds: LaunchCompleteTests.Updating_the_latest_point_reports_the_folder_with_nothing_unsaved_as_skipped_and_the_other_as_saved failed with 'the install had nothing unsaved and should say it was skipped'; LaunchFlowSessionTests.A_failure_beside_a_folder_the_update_skipped_for_having_nothing_new_says_so_and_does_not_call_it_failed failed on the card body (expected start 'Your game version and mods are in the snapshot...'). Both pass now.
The job pill floats in the content area's bottom-left corner, and a footer or card pinned to the bottom of a screen sat under it while a job ran. Games, History and Activity now end with an empty strip that grows to the pill's room while it shows, so their pinned content lifts above the pill. The strip replaces the 64 px of scroll padding on the Games table and the Activity list.

Observed red: JobPillPlacementTests.No_pinned_text_is_hidden_under_the_job_pill failed 76 of 112 rows, for example 'Sidebar games, 200% on 1080p: Text 'This game's snapshots use 41.2 GB...' is under the pill'. Green after the change, 112 of 112; the whole JobPillPlacementTests class passes (237).
A move reported every copied file as a job line (alpha-1\external.git\HEAD) and its leftover lines named install.git; the catalog lint cannot see message arguments, so nothing caught it. A move now announces each game folder once (game name, game files or saves, file count), the progress carries no path, and a leftover in a move or a clear is named by the game's folder plus which part it was.

Observed reds before the change (JobLinesHideEngineFoldersTests):
- A_move_reports_no_file_path_and_no_engine_folder: Assert.DoesNotContain() Failure: Filter matched in collection (alpha-1\external.git\COMMIT_EDITMSG)
- A_move_reports_each_folder_by_game_and_part: Assert.NotNull() Failure: Value is null
- A_move_that_leaves_an_old_copy_names_the_game_folder_and_not_the_engine_folder and A_clear_reports_no_engine_folder_even_for_what_it_cannot_remove: Assert.Contains() Failure, found path=...\foreign\install.git instead of path=...\foreign, part=install
When SavePoint was killed during a long cleanup of saved history, the next start waited for that leftover git with only 'Checking your files...' on screen. The startup check now reports StartupProgress.FinishingEarlierCleanup through an optional IProgress just before it begins that wait, and the startup screen shows a plain-words note from the catalog (key startup.finishingCleanup) while it lasts. The wait is tested with the fake status Api (steps plus a gate) and, in Core, with a stand-in git process.

Observed reds: InterruptedReclaimTests.The_startup_check_says_it_is_finishing_an_earlier_cleanup_before_it_starts_waiting failed with Assert.Same() Failure: Values are not the same instance (nothing was reported). StartupViewModelTests.While_an_earlier_cleanup_is_finished_the_screen_says_so_and_stays_in_the_checking_phase failed with Assert.Equal() Failure: Expected Tuple (Checking, True, 0), Actual Tuple (Checking, False, 0).
Tests that passed on first run were mutation checked and failed as expected: reporting without a running leftover (Assert.Empty Failure: Collection was not empty), the VM note set at the start of every check (A_check_with_nothing_left_behind_never_shows_the_cleanup_note failed), and the note hidden in the view (While_an_earlier_cleanup_is_finished_the_screen_says_so_in_plain_words failed). Each change was restored.
A broken skip probe (for example TestLinks.TryCreateFolderLink returning false) turned
real tests into skips and the gate still passed. Both gates now always write the xunit
report into artifacts/test-results, then tools/SkipCheck compares the skipped test names
with build/expected-skips/<os>.txt and fails on any skip the list does not name, printing
the names one per line with a count per skip reason. A listed test that now runs is only
a note. Lists are keyed by full test name with theory data; ~ marks timing-dependent
skips and @include lets the WSL list add to the CI list. SkipCheck --write regenerates a
list from a run. gate-linux.sh selects the linux-wsl list; macOS has no list yet. Both
gates also run two test modules at once (--max-parallel-test-modules 2).

Observed reds (SkipCheckTests, stubs returning empty values): A_list_holds_its_names_...
Assert.Equal collections differ; A_skip_the_list_does_not_name_fails_and_is_named
Assert.False failure; The_check_exits_with_1_... Assert.Equal 1 vs 0;
A_list_that_includes_itself_is_refused Assert.Throws no exception; the reports-below-a-
folder and .xunit extension tests failed on Assert.Equal after the real report showed the
platform writes .xunit by default. A_test_that_may_skip_... passed on the stub and failed
when the Intermittent exclusion was removed (mutation check); the list lint test failed
when a duplicate line was added to windows.txt.

Done condition shown by hand: with TryCreateFolderLink forced to return false, a run of
LinkedFolderTests with the report fails the check, naming the 8 tests that started to
skip ("8 x this system cannot make folder links"); restored, it passes.
The one-module rule came from a machine-load problem that is gone. The App
module spends most of its time on one UI thread, so running it beside Core
uses idle threads instead of waiting.
# Conflicts:
#	build/gate.ps1
#	build/gate.sh
At the smallest windows with the explanation and Recently removed both open, the removed section was capped and the snapshot list kept 0 to 45 px. The screen now scrolls as a whole: the header, explanation, snapshots, removed snapshots and footer sit in one scroll area, and the snapshot list fills the rest of the screen but never drops under a 220 px floor (its heading plus three rows). The removed list no longer scrolls on its own, and the code that capped it is gone.

Observed red: HistoryRecentlyRemovedViewTests.At_the_smallest_windows_with_the_explanation_and_the_section_both_open_the_list_keeps_three_rows_and_the_screen_scrolls_to_the_rest failed at 640x420 and 910x432 with 'the snapshot list keeps only 0 px, under the 220 px floor'. Green after the change. The two older tests that asserted the section stayed inside the window now assert the floor, and a new test checks a tall window still fills without scrolling. Also passing: HistoryRecentlyRemovedViewTests, HistoryScreenViewTests, HistoryRenderTests, ScaledWindowTests, ReflowTests, JobPillPlacementTests.
The error card chose its copy by exception id alone, so a locked leftover during Clear all data or a storage move read as a half-finished switch that would pick up where it left off, a held file during a snapshot carried the switch title, and every full-disk error said to take this snapshot. The card and the message lookup now take the operation (switch, snapshot, free up space, move, clear) and pick an operation-specific literal key through a switch, falling back to neutral text when the operation is not known. Job-aware screens (Activity, the job toast and notification, Settings, the profile wizard, the launch flow) pass the operation.

Observed reds before the change (ErrorOperationCopyTests, copy still keyed by id only):
- A_held_file_outside_a_switch_never_talks_about_a_switch_or_picking_up (FreeUpSpace, Unspecified, Snapshot, ClearData, MoveSnapshots): Assert.DoesNotContain() Failure: Sub-string found
- A_full_disk_outside_a_snapshot_never_says_to_take_this_snapshot (Switch, FreeUpSpace, MoveSnapshots, ClearData, Unspecified): Assert.DoesNotContain() Failure: Sub-string found
- A_full_disk_names_the_operation_that_needed_the_room and A_held_leftover_while_clearing_says_the_rest_was_removed: Assert.Contains() Failure: Sub-string not found
Activity wiring tests passed first run; mutation check (JobDetailsViewModel passing Unspecified) failed A_failed_job_words_a_held_file_for_what_the_job_does, A_failed_move_words_a_held_file_for_a_move and two existing Activity tests, then restored.
A game started through a link has no program of its own to watch, so the player must name the game's process. The ranker drops launchers, crash reporters, anti-cheat bootstraps, redistributables, uninstallers and tool suites, then prefers shallow, large, game-named programs and Unreal's shipping program over its small starter. A folder where nothing scores well gets no suggestion.

Fixtures are relative paths and sizes from 208 real installs on one PC; a throwaway run over the whole sample gave a sensible top suggestion for all but Eve Online (a stub that starts exefile.exe) and SteamVR (not a game).

Observed reds: 16 of 21 tests failed with assertion failures against a stub returning null (for example Expected: Subnautica.exe, Actual: null). While tuning, Battleye_and_other_bootstrap_variants_lose_to_the_game_program failed with Expected: TslGame.exe, Actual: ExecPubg.exe. Mutation check: lowering the minimum score to -2500 made the VR-runtime and many-tools tests fail (Actual: vrserver.exe, tool40.exe).
ExecutableScanner.ListProgramsAsync returns every launchable file with its size (the short list cut deep files that ranking needs), and IGamesApi.SuggestProcessNameAsync ranks them with ProcessNameSuggester. A missing folder or one with no game answers an empty string, not an error.

Observed reds: Programs_are_listed_with_their_sizes_and_every_one_found_is_kept failed with Expected: 62, Actual: 0 against a stub; The_process_name_suggested_is_the_game_program_not_the_launcher_beside_it failed with Expected: Alpha-Win64-Shipping.exe, Actual: empty. Mutation check: returning x instead of empty made No_process_name_is_suggested_for_a_folder_that_is_not_there_or_holds_no_game fail (Actual: x).
Show details printed ex.ToString() on the card, git's stderr included, against the rule that Activity's details are never git's own text. The card now keeps that text only as SupportText: Show details explains what it is (technical details for a bug report, which can name files and folders on this computer) and a Copy details for support button puts the full text on the clipboard and says so. Nothing from the exception or the tools is drawn. The wizard's create refusal also names the snapshot operation, which the previous commit's neutral disk text needs.

Observed reds before the view change (ErrorCardViewTests, with the explanation and button added but the raw box still bound):
- No_exception_or_tool_text_is_rendered_anywhere_on_the_card_even_with_the_details_open: Assert.DoesNotContain() Failure: Filter matched in collection
- Copy_details_puts_the_full_technical_text_on_the_clipboard_and_says_so: Assert.Equal() Failure: Expected the full GitOperationException text, Actual: null
The ErrorCardViewModelTests copy test passed first run; mutation check (copying only the first character) failed it, then restored.
The notices promise the sources of the MSYS2 and MINGW packages inside the Windows git bundle, but --sources fetched only the three tag archives. build/msys2-sources.json now lists the 50 source archives behind every package in MinGit 2.56.0.2's etc/package-versions.txt, each with its URL, size and pinned SHA-256. Packages Git for Windows builds itself come from its pacman-repo releases (where build-extra/get-sources.sh looks first); the rest come from repo.msys2.org. package.ps1 and package.sh download them into artifacts/release/source/packages, compare each with its pin, keep an archive only when it matches, and fail after printing every hash when one does not. An archive already in the folder that matches its pin is not downloaded again.

Reds observed: PackageSourcesTests.Both_package_scripts_download_the_package_sources_from_their_manifest_into_one_folder (build/package.ps1 and build/package.sh), both "Assert.Contains() Failure: Sub-string not found ... Not found: msys2-sources.json". The data tests passed on their first run; mutation check: changing one provides entry, uppercasing one hash digit and pointing one URL at example.org made Every_package_the_windows_bundle_lists_has_its_source_in_the_list, Every_archive_has_a_download_address_named_after_its_file_and_a_lowercase_sha256 and Archives_come_from_msys2_or_from_the_git_for_windows_package_releases fail; restored afterwards.
Choosing the link method with an empty process name now explains, in plain words, that SavePoint cannot tell when the game closes without it, and offers a Use <name> button built from the install folder. Nothing is offered for a file start, a filled-in name, or a folder that is not chosen or cannot be read. Loading a saved game fills the name before the method so the offer does not flash for a game that has one.

Observed reds (against stubs): Choosing_a_launch_link_offers_the_games_own_program_as_the_process_name (Expected: SkyrimSE.exe, Actual: empty), Using_the_suggestion_fills_the_process_name_and_clears_the_offer (same), A_folder_with_no_game_program_still_explains_why_the_name_matters_but_offers_no_button (Expected: True, Actual: False), A_new_install_folder_is_asked_again_for_a_link_started_game, The_explanation_is_shown_before_a_folder_is_chosen_and_the_folder_is_not_asked. Mutation checks: dropping the link condition made the file-start and going-back tests fail; dropping the empty-name condition made the already-typed and use-suggestion tests fail; forcing the row visible made the view test fail (Expected: False, Actual: True).
The left-behind cards after a storage move or Clear all data listed raw paths ending in install.git. They now show the game's folder once (via SnapshotFolderNames.Plain, now public), so a game whose game files and saves both stayed appears as one line.

Observed reds before the change:
- ClearAllDataTests.Leftovers_in_a_snapshot_folder_are_listed_by_the_game_folder_once_and_never_by_the_git_folder: Assert.Equal() Failure, Expected D:\SavePoint\skyrim, Actual D:\SavePoint\skyrim\install.git\objects\pack-1.pac...
- StorageSectionViewModelTests.A_move_that_could_not_remove_every_old_copy_still_switches_and_lists_what_stayed: Expected D:\Old\game-1, Actual D:\Old\game-1\install.git
With a process name set, a session settled as never-appeared once the grace ran out, which ends the session and asks to save while a slow launcher or anti-cheat bootstrap is still starting the game, and the real play time is then lost. The wait is two minutes; the player can end it at any time, so a wrong name costs little.

Observed red: With_the_default_timings_a_launcher_that_starts_the_game_after_a_minute_is_still_followed failed at the first check with Expected: False, Actual: True (the session had settled at 30 s). WatcherRig takes optional session options so a test can use the real defaults.
# Conflicts:
#	src/Savepoint.App/Features/Launch/LaunchFlowViewModel.Failures.cs
The earlier fix let a move run from any storage folder with nothing in it, which also lets through a folder whose contents are missing (the wrong drive mounted at that path) while games have snapshots. Start with an empty folder now writes a small .savepoint-empty-start marker into the folder it makes, and the move guard allows a source with no game folders only when that marker is the only entry. An empty folder without the marker, or one with anything else, stays refused. decisions.md (BL-004) states the marker rule.

Observed red: StorageUnreachableTests.A_move_from_a_storage_folder_that_is_there_but_holds_no_game_folders_is_refused failed with Assert.Equal() Failure: Expected error.storage.unreachable, Actual null. After the change that test and the StorageMoveAfterEmptyStartTests allow tests (through the real StartWithEmptyStorageAsync) pass.
The test looked for a page-scroll scroller, but the Games table and Activity list no longer carry that class: their room for the pill is the pill-room strip. The test now checks that the strip is 0 high without the pill and 64 with it, while the page and content regions keep their bounds, which is the shell-layout intent.

Observed red: ShellViewTests.The_job_pill_floats_over_the_shell_and_leaves_its_layout_alone (both layouts) threw InvalidOperationException: Sequence contains no matching element. Green after the change (41 of 41).
The first-snapshot journey test and the two HeldFileSaveTests cases for a first snapshot skip when the OS lets a held file be read, which is every Linux run, but were missing from linux-ci.txt (and so from the WSL list that includes it). The scan of tests added since main found no other skip conditions, so windows.txt needs no change.
ProcessStamp.WaitForExitAsync used Process.WaitForExitAsync on a process this run did not start. .NET waits on a non-child by probing its id, which keeps succeeding for a zombie that nothing reaps (a container), so the wait could never return. On Linux the wait now polls the same IsRunning check, which reads /proc, with a short delay and the cancellation token. The proc folder and delay are injectable so the rule runs on any OS; a Linux-only test checks the no-argument IsRunning reads /proc (listed as a Windows skip).

Mutation check: with the poll loop inverted, A_wait_returns_once_the_stat_of_a_live_process_turns_zombie and A_wait_on_a_running_process_stops_when_cancelled failed; restored, all pass.
The audit test only ran scrolledToEnd: false. The new case builds a scroll area with a button and the page's last words under the pill, plus a pinned button outside it, and expects the scrolled-to-end pass to name the first two and the pinned pass to name only the pinned button.

Passed on its first run; mutation check: with the text rule forced off in JobPillAudit the test failed (Expected 2, Actual 1); restored.
Updating the latest point leaves a folder with nothing unsaved untouched; the job's lines must say it was skipped and must not claim it saved zero files. The new test completes a session with UpdateExisting and checks the capture job's steps for both folders.

Passed on its first run; mutation check: with the skipped branch logging CaptureFolderDone the test failed (Assert.Contains() Failure: Item not found in collection); restored.
Record the calls on the way to 1.0 as D48
Some checks failed
Gate / linux (pull_request) Failing after 11m14s
ad90db4405
An error that named a held file inside install.git (a partial Clear all data, or a move that stopped on a held or failed-to-copy file) put that path on the card, in Activity too. ErrorCardViewModel.PathFor now describes the path with SnapshotFolderNames, so every card covers it.

Red: ErrorCardViewModelTests.A_path_inside_a_snapshot_folder_shows_the_game_folder_instead, Assert.Equal expected C:\SavePoint\skyrim, actual C:\SavePoint\skyrim\install.git\objects\pack\pack-1.pack. The Activity test passed on its first run because it goes through the same card; it covers the wiring.
The job toast passes the Snapshot operation, so a full disk reads 'to take this snapshot' for a failed or partial capture, which is right. The two toast tests compared against the operation-neutral text; they now ask for the Snapshot wording.

Observed red: A_failed_capture_is_an_error_toast_with_the_reason_underneath and A_capture_that_saved_only_one_folder_is_a_warning_never_a_success failed with Assert.Equal() Failure: Strings differ (do that right now vs take this snapshot right). Green after the change (30 of 30).
Start with an empty folder now leaves a .savepoint-empty-start marker beside the game folders, so the test that lists the folder's entries expects it too.

Observed red: StorageUnreachableChoicesTests.Starting_with_an_empty_folder_uses_the_default_folder_and_keeps_the_games_listed_without_history failed with Collections differ at index 0 (Actual ...Storage\.savepoint-empty-start). Green after the change (22 of 22).
A Mac install offered 'Game.app', which the process matcher never matched, so the session ended as never-appeared while the player was still playing. The suggestion now names the bundle's program (CFBundleExecutable, else the bundle name without .app), and the matcher on macOS also treats a trailing .app as the bundle's program. Names such as game_beta.exe are no longer dropped for holding '_be'.

Red: MacAppSuggestionTests (3 of 4), Assert.Equal expected 'Game' / 'PrettyGame', actual 'Game.app'. ProcessNameSuggesterTests.An_anti_cheat_suffix_only_counts_at_the_end_of_the_name, expected 'game_beta.exe', actual null. The new ProcessNameMatcherTests rows passed on their first run; they fail without the .app rule since 'Game.app' never equals 'Game'.
The earlier copy change left unescaped quotes in errors.json; the string now escapes them and points at Copy details for support. The editor clears its Use-name offer and drops an answer in flight as soon as the install folder changes, and passes the scan token to the suggestion call so a folder change cancels it.

Red: GameEditorLaunchTests.Clearing_the_install_folder_takes_the_offer_away_at_once and Choosing_another_folder_takes_the_old_offer_away_before_the_new_look_finishes (HasProcessNameSuggestion expected False, actual True); Choosing_another_folder_cancels_the_look_in_the_old_one (token.IsCancellationRequested expected True, actual False). The out-of-order test passed first run; removing the run check made it fail (expected Other.exe, actual SkyrimSE.exe), then restored.
Two tests used Windows-style paths, which do not split on Linux, so the game folder was never found there. They now build paths with Path.Combine.

Not a new behavior; the failure was seen on Linux CI (expected the game folder, got the full install.git path).
The script test passed on header comments alone. It now checks the lines that run in each script, and runs the bash awk parse against the real msys2-sources.json and compares every file, url and hash with the JSON. The bundle-coverage test skips with a reason where there is no package list, and is named in the Linux CI expected skips (and as may-skip on Windows for the awk test). package.ps1 retries downloads three times like curl does, and package.sh lower-cases pins like package.ps1.

Red: none observed; these tests passed on their first run because they check scripts that were already right. Not mutation-checked beyond reading the asserted strings against the script lines.
A clipboard that throws, or no clipboard at all, now shows a short catalog note instead of reaching the crash handler, and the card view stops listening when it leaves the tree. The copy test waits for the note instead of a fixed 50 ms.

Red: ErrorCardViewModelTests.A_copy_that_could_not_reach_the_clipboard_says_so, Assert.Equal expected the clipboard note, actual empty. The view's catch has no automated test because the headless clipboard does not fail on demand.
The Games screen's Free up space footer and toast, and the refusal of the end-of-play snapshot, now pass their operation so they get the matching wording. The profile form dialogs serve duplicate, edit and bring back, none of which is a snapshot, so they stay neutral.

Red: FreeUpSpaceViewModelTests (3), operation expected FreeUpSpace, actual Unspecified, and the footer text expected the free-up wording; LaunchFlowSessionTests.A_post_play_choice_refused_over_a_held_file_is_worded_for_a_snapshot, title expected 'A file is in use, so the snapshot didn't finish', actual 'A file is in use'.
The move no longer reports the file it is on, so the Settings row and property were always empty. The ErrorInfo.Detail comment now says the text is copied for support and never shown.

No behavior change; no new test.
Say that error details are copied for support, never shown
Some checks failed
Gate / linux (pull_request) Failing after 11m15s
97e7851953
The full Windows gate showed this skip; on NTFS both spellings cannot exist,
so the skip is right there.
Correct the Linux CI skip list from the first CI run
Some checks failed
Gate / linux (pull_request) Has been cancelled
66ded9947a
The held-file delete test only fails as in use on Windows, so it skips in CI.
The D-Bus tests run where the container has a session bus and skip where it
does not, so they may skip instead of having to.
Version 0.9.2
All checks were successful
Gate / linux (pull_request) Successful in 12m12s
Gate / linux (push) Successful in 12m3s
9494fa3fed
Sign in to join this conversation.
No reviewers
No milestone
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
ethan-hann/SavePoint!59
No description provided.