From d0c27dd51230cbcbc9f1d3676e5bbfac42fc4d13 Mon Sep 17 00:00:00 2001 From: Gleb Khmyznikov Date: Mon, 10 Aug 2026 10:55:03 -0700 Subject: [PATCH] =?UTF-8?q?[UITests]=20Add=20UITest.Next=20suites=20(Image?= =?UTF-8?q?=20Resizer,=20Peek,=20File=20Explorer=20add=E2=80=91ons,=20File?= =?UTF-8?q?=20Locksmith)=20+=20local=E2=80=91VM=20tooling=20and=20CI=20tes?= =?UTF-8?q?t=E2=80=91signing=20(#49671)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## Summary Adds end‑to‑end UI tests on the `Microsoft.PowerToys.UITest.Next` (winappcli) framework for three modules, grows the shared `.Next` test framework with the helpers those suites needed, and adds the CI plumbing that lets shell‑extension tests exercise the **real** Windows 11 modern context menu. Also ships two agent skills that document how to write and run these tests. Product runtime behavior is **unchanged** — the only product edits are test‑observability hooks in Peek and a unit‑test project exclude. Closes: https://github.com/microsoft/PowerToys/issues/40660 https://github.com/microsoft/PowerToys/issues/49424 https://github.com/microsoft/PowerToys/issues/40661 ## What's added ### New UI test suites - **Image Resizer** — `src/modules/imageresizer/tests/ImageResizer.UITests`: context‑menu enable/disable tracking, the resize dialog, custom presets, every fit mode, every unit, filename format, keep‑date, shrink‑only, replace‑in‑place, and orientation. - **Peek** — `src/modules/peek/Peek.UITests.Next`: file‑preview coverage across image/text/archive/ markdown types with per‑arch visual baselines. - **File Explorer add‑ons** — `src/modules/previewpane/PreviewPane.UITests`: Preview Pane handlers and thumbnail providers. ### `UITestAutomation.Next` framework - New helpers: `ExplorerShell` (Shell selection/view‑mode interop), `WaitHelper` (structured stable waits), `WindowControl` (foreground/context‑menu/process control), `VisualAssert` (image compare), `WindowHelper`. - Updates to `Session`, `UITestBase`, `SettingsConfigHelper`, `WinappCli`. - New `UITestAutomation.Next.UnitTests` project covering the new wait/settings/CLI helpers. ### CI — sign sparse MSIX so the modern menu registers - **`.pipelines/signSparsePackages.ps1`** — self‑signs each sparse context‑menu MSIX with a publisher‑matching test certificate and force‑trusts it (machine stores), so `AddPackageByUriAsync` succeeds on otherwise‑unsigned PR builds. Robust `signtool` discovery with a NuGet fallback; test‑only trust that asserts no security. - Wired into **`.pipelines/v2/templates/job-test-project.yml`** as a best‑effort step covering the run‑in‑place, machine‑install, and per‑user‑install locations. Signs nothing it can't (skips already‑signed packages) and never fails the job. ### Product changes (test observability only) - **Peek `FilePreview.xaml` / `.xaml.cs`** — a named `LoadingIndicator` and a hidden automation peer that exposes the current preview state as text, so tests can read load state deterministically. No runtime behavior change. - **`ImageResizer.UnitTests.csproj`** — exclude the sibling `ImageResizer.UITests\**` folder from the unit‑test compilation. ### Agent skills & docs - **New `ui-tests-local-vm` skill** — run `.Next` suites in persistent dockur/windows VMs: setup, agentic loop, image customization, troubleshooting, the shell‑extension **signing** reference, plus controller/guest scripts and VM templates. - **Updated `ui-tests-migration` skill** — WinAppDriver/Selenium → `.Next` porting guidance (CI stability, Explorer/shell‑extension test design, patterns & pitfalls). - **`doc/devdocs/development/ui-tests.md`** — updated for the `.Next` workflow. ## Testing - All three suites pass locally and in CI across **x64 Win10**, **x64 Win11**, and **arm64** (machine and per‑user install legs). ## Reviewer notes - No product runtime behavior changes; product edits are limited to the Peek test hooks above. - The CI signing step is a **test‑only** trust anchor (self‑signed, scoped to the agent) and is best‑effort, so it can only add modern‑menu coverage and never regress the job. --- .github/skills/ui-tests-local-vm/SKILL.md | 239 ++++ .../references/agentic-loop.md | 241 ++++ .../references/customization.md | 145 ++ .../ui-tests-local-vm/references/setup.md | 409 ++++++ .../shell-extensions-and-signing.md | 164 +++ .../references/troubleshooting.md | 104 ++ .../scripts/Get-VmConsoleImage.ps1 | 95 ++ .../scripts/Get-WindowsMedia.ps1 | 186 +++ .../scripts/Initialize-LocalVm.ps1 | 66 + .../scripts/Initialize-LocalVmHost.ps1 | 418 ++++++ .../scripts/Invoke-GuestScript.ps1 | 64 + .../scripts/Invoke-LocalVmUiTest.ps1 | 695 ++++++++++ .../scripts/LocalVmGuest.psm1 | 443 ++++++ .../scripts/Update-LocalVmGuest.ps1 | 147 ++ .../templates/oem/Provision-UiTestVm.ps1 | 168 +++ .../templates/oem/Set-GuestResolution.ps1 | 90 ++ .../templates/oem/Set-UiTestAutoLogon.ps1 | 209 +++ .../templates/run-ui-tests.ps1 | 510 +++++++ .../ui-tests-local-vm/templates/vm/.gitignore | 5 + .../templates/vm/New-UiTestVm.ps1 | 585 ++++++++ .../templates/vm/Reset-LocalVm.ps1 | 106 ++ .../templates/vm/Start-LocalVm.ps1 | 170 +++ .../templates/vm/Stop-LocalVm.ps1 | 84 ++ .../vm/unattend/autounattend.xml.template | 184 +++ .../templates/vm/vm.config.example.psd1 | 37 + .github/skills/ui-tests-migration/SKILL.md | 103 +- .../references/api-mapping.md | 9 + .../references/ci-stability.md | 156 ++- .../references/explorer-shell-tests.md | 211 +++ .../references/framework-differences.md | 9 +- .../references/patterns-and-pitfalls.md | 157 +++ .../references/porting-workflow.md | 9 +- .../references/project-setup.md | 27 + .pipelines/signSparsePackages.ps1 | 334 +++++ .pipelines/v2/templates/job-test-project.yml | 38 +- PowerToys.slnx | 20 + doc/devdocs/development/ui-tests.md | 131 +- .../SettingsConfigHelperTests.cs | 138 ++ .../UITestAutomation.Next.UnitTests.csproj | 25 + .../WaitHelperTests.cs | 96 ++ .../WinappCliTests.cs | 56 + .../UITestAutomation.Next/ExplorerShell.cs | 471 +++++++ .../UITestAutomation.Next/ScreenRecording.cs | 31 +- src/common/UITestAutomation.Next/Session.cs | 29 +- .../SettingsConfigHelper.cs | 112 +- .../UITestAutomation.Next.csproj | 29 +- .../UITestAutomation.Next/UITestBase.cs | 57 +- .../UITestAutomation.Next/VisualAssert.cs | 119 ++ .../UITestAutomation.Next/WaitHelper.cs | 71 + src/common/UITestAutomation.Next/WinappCli.cs | 14 +- .../UITestAutomation.Next/WindowControl.cs | 172 +++ .../UITestAutomation.Next/WindowHelper.cs | 64 + .../FileLocksmithXAML/Views/MainPage.xaml | 1 + .../FileLocksmith.UITests/ExplorerHelper.cs | 398 ++++++ .../FileLocksmith.UITests.csproj | 33 + .../FileLocksmithContextMenuTests.cs | 384 ++++++ .../FileLocksmithProcessListTests.cs | 280 ++++ .../FileLocksmithTestHelper.cs | 640 +++++++++ .../Tests/FileLocksmith.UITests/app.manifest | 19 + .../ImageResizer.UITests.csproj | 33 + .../ImageResizerEndToEndTests.cs | 1221 +++++++++++++++++ .../tests/ImageResizer.UITests/app.manifest | 16 + .../tests/ImageResizer.UnitTests.csproj | 1 + .../peek/Peek.FilePreviewer/FilePreview.xaml | 16 +- .../Peek.FilePreviewer/FilePreview.xaml.cs | 10 + ...iewTests_TestSingleFilePreview_2_arm64.png | Bin 0 -> 98192 bytes ...Tests_TestSingleFilePreview_2_x64Win10.png | Bin 0 -> 101012 bytes ...Tests_TestSingleFilePreview_2_x64Win11.png | Bin 0 -> 102410 bytes ...iewTests_TestSingleFilePreview_4_arm64.png | Bin 0 -> 21586 bytes ...Tests_TestSingleFilePreview_4_x64Win10.png | Bin 0 -> 19469 bytes ...Tests_TestSingleFilePreview_4_x64Win11.png | Bin 0 -> 20826 bytes ...iewTests_TestSingleFilePreview_5_arm64.png | Bin 0 -> 18727 bytes ...Tests_TestSingleFilePreview_5_x64Win10.png | Bin 0 -> 15641 bytes ...Tests_TestSingleFilePreview_5_x64Win11.png | Bin 0 -> 19150 bytes ...iewTests_TestSingleFilePreview_6_arm64.png | Bin 0 -> 24884 bytes ...Tests_TestSingleFilePreview_6_x64Win10.png | Bin 0 -> 20573 bytes ...Tests_TestSingleFilePreview_6_x64Win11.png | Bin 0 -> 24017 bytes ...iewTests_TestSingleFilePreview_7_arm64.png | Bin 0 -> 33297 bytes ...Tests_TestSingleFilePreview_7_x64Win10.png | Bin 0 -> 24946 bytes ...Tests_TestSingleFilePreview_7_x64Win11.png | Bin 0 -> 31424 bytes ...iewTests_TestSingleFilePreview_8_arm64.png | Bin 0 -> 14077 bytes ...Tests_TestSingleFilePreview_8_x64Win10.png | Bin 0 -> 12274 bytes ...Tests_TestSingleFilePreview_8_x64Win11.png | Bin 0 -> 13364 bytes .../Peek.UITests.Next.csproj | 40 + .../Peek.UITests.Next/PeekFilePreviewTests.cs | 998 ++++++++++++++ .../peek/Peek.UITests.Next/TestAssets/2.jpg | Bin 0 -> 30597 bytes .../peek/Peek.UITests.Next/TestAssets/4.qoi | Bin 0 -> 16488 bytes .../peek/Peek.UITests.Next/TestAssets/5.cpp | 6 + .../peek/Peek.UITests.Next/TestAssets/6.md | 11 + .../peek/Peek.UITests.Next/TestAssets/7.zip | Bin 0 -> 122920 bytes .../peek/Peek.UITests.Next/TestAssets/8.png | Bin 0 -> 10166 bytes .../peek/Peek.UITests.Next/app.manifest | 16 + .../FileExplorerAddonsTests.cs | 1193 ++++++++++++++++ .../PreviewPane.UITests.csproj | 52 + .../PreviewPane.UITests/app.manifest | 10 + 95 files changed, 13565 insertions(+), 65 deletions(-) create mode 100644 .github/skills/ui-tests-local-vm/SKILL.md create mode 100644 .github/skills/ui-tests-local-vm/references/agentic-loop.md create mode 100644 .github/skills/ui-tests-local-vm/references/customization.md create mode 100644 .github/skills/ui-tests-local-vm/references/setup.md create mode 100644 .github/skills/ui-tests-local-vm/references/shell-extensions-and-signing.md create mode 100644 .github/skills/ui-tests-local-vm/references/troubleshooting.md create mode 100644 .github/skills/ui-tests-local-vm/scripts/Get-VmConsoleImage.ps1 create mode 100644 .github/skills/ui-tests-local-vm/scripts/Get-WindowsMedia.ps1 create mode 100644 .github/skills/ui-tests-local-vm/scripts/Initialize-LocalVm.ps1 create mode 100644 .github/skills/ui-tests-local-vm/scripts/Initialize-LocalVmHost.ps1 create mode 100644 .github/skills/ui-tests-local-vm/scripts/Invoke-GuestScript.ps1 create mode 100644 .github/skills/ui-tests-local-vm/scripts/Invoke-LocalVmUiTest.ps1 create mode 100644 .github/skills/ui-tests-local-vm/scripts/LocalVmGuest.psm1 create mode 100644 .github/skills/ui-tests-local-vm/scripts/Update-LocalVmGuest.ps1 create mode 100644 .github/skills/ui-tests-local-vm/templates/oem/Provision-UiTestVm.ps1 create mode 100644 .github/skills/ui-tests-local-vm/templates/oem/Set-GuestResolution.ps1 create mode 100644 .github/skills/ui-tests-local-vm/templates/oem/Set-UiTestAutoLogon.ps1 create mode 100644 .github/skills/ui-tests-local-vm/templates/run-ui-tests.ps1 create mode 100644 .github/skills/ui-tests-local-vm/templates/vm/.gitignore create mode 100644 .github/skills/ui-tests-local-vm/templates/vm/New-UiTestVm.ps1 create mode 100644 .github/skills/ui-tests-local-vm/templates/vm/Reset-LocalVm.ps1 create mode 100644 .github/skills/ui-tests-local-vm/templates/vm/Start-LocalVm.ps1 create mode 100644 .github/skills/ui-tests-local-vm/templates/vm/Stop-LocalVm.ps1 create mode 100644 .github/skills/ui-tests-local-vm/templates/vm/unattend/autounattend.xml.template create mode 100644 .github/skills/ui-tests-local-vm/templates/vm/vm.config.example.psd1 create mode 100644 .github/skills/ui-tests-migration/references/explorer-shell-tests.md create mode 100644 .pipelines/signSparsePackages.ps1 create mode 100644 src/common/UITestAutomation.Next.UnitTests/SettingsConfigHelperTests.cs create mode 100644 src/common/UITestAutomation.Next.UnitTests/UITestAutomation.Next.UnitTests.csproj create mode 100644 src/common/UITestAutomation.Next.UnitTests/WaitHelperTests.cs create mode 100644 src/common/UITestAutomation.Next.UnitTests/WinappCliTests.cs create mode 100644 src/common/UITestAutomation.Next/ExplorerShell.cs create mode 100644 src/common/UITestAutomation.Next/VisualAssert.cs create mode 100644 src/common/UITestAutomation.Next/WaitHelper.cs create mode 100644 src/modules/FileLocksmith/Tests/FileLocksmith.UITests/ExplorerHelper.cs create mode 100644 src/modules/FileLocksmith/Tests/FileLocksmith.UITests/FileLocksmith.UITests.csproj create mode 100644 src/modules/FileLocksmith/Tests/FileLocksmith.UITests/FileLocksmithContextMenuTests.cs create mode 100644 src/modules/FileLocksmith/Tests/FileLocksmith.UITests/FileLocksmithProcessListTests.cs create mode 100644 src/modules/FileLocksmith/Tests/FileLocksmith.UITests/FileLocksmithTestHelper.cs create mode 100644 src/modules/FileLocksmith/Tests/FileLocksmith.UITests/app.manifest create mode 100644 src/modules/imageresizer/tests/ImageResizer.UITests/ImageResizer.UITests.csproj create mode 100644 src/modules/imageresizer/tests/ImageResizer.UITests/ImageResizerEndToEndTests.cs create mode 100644 src/modules/imageresizer/tests/ImageResizer.UITests/app.manifest create mode 100644 src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_2_arm64.png create mode 100644 src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_2_x64Win10.png create mode 100644 src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_2_x64Win11.png create mode 100644 src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_4_arm64.png create mode 100644 src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_4_x64Win10.png create mode 100644 src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_4_x64Win11.png create mode 100644 src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_5_arm64.png create mode 100644 src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_5_x64Win10.png create mode 100644 src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_5_x64Win11.png create mode 100644 src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_6_arm64.png create mode 100644 src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_6_x64Win10.png create mode 100644 src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_6_x64Win11.png create mode 100644 src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_7_arm64.png create mode 100644 src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_7_x64Win10.png create mode 100644 src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_7_x64Win11.png create mode 100644 src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_8_arm64.png create mode 100644 src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_8_x64Win10.png create mode 100644 src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_8_x64Win11.png create mode 100644 src/modules/peek/Peek.UITests.Next/Peek.UITests.Next.csproj create mode 100644 src/modules/peek/Peek.UITests.Next/PeekFilePreviewTests.cs create mode 100644 src/modules/peek/Peek.UITests.Next/TestAssets/2.jpg create mode 100644 src/modules/peek/Peek.UITests.Next/TestAssets/4.qoi create mode 100644 src/modules/peek/Peek.UITests.Next/TestAssets/5.cpp create mode 100644 src/modules/peek/Peek.UITests.Next/TestAssets/6.md create mode 100644 src/modules/peek/Peek.UITests.Next/TestAssets/7.zip create mode 100644 src/modules/peek/Peek.UITests.Next/TestAssets/8.png create mode 100644 src/modules/peek/Peek.UITests.Next/app.manifest create mode 100644 src/modules/previewpane/PreviewPane.UITests/FileExplorerAddonsTests.cs create mode 100644 src/modules/previewpane/PreviewPane.UITests/PreviewPane.UITests.csproj create mode 100644 src/modules/previewpane/PreviewPane.UITests/app.manifest diff --git a/.github/skills/ui-tests-local-vm/SKILL.md b/.github/skills/ui-tests-local-vm/SKILL.md new file mode 100644 index 0000000000..5fc1433175 --- /dev/null +++ b/.github/skills/ui-tests-local-vm/SKILL.md @@ -0,0 +1,239 @@ +--- +name: ui-tests-local-vm +description: "Set up and run PowerToys UITest.Next suites in persistent local Hyper-V VMs driven over PowerShell Direct, created unattended from Windows install media. A module is done only when the full suite is green on both Windows 10 LTSC and Windows 11, in separate VMs, plus Windows 11 ARM64 on Windows on ARM hosts. Use for fast agentic UI-test iteration, reusable interactive desktops, non-admin scenarios, payload staging and refresh, evidence export, VM customization, checkpoint-based clean baselines, or hosts without nested virtualization. Keywords: Hyper-V, local VM, virtual machine, PowerShell Direct, Copy-VMFile, VMBus, checkpoint, unattend, autounattend, ISO, Windows 10, Windows 11, ARM64, Windows on ARM, UI tests, UITest.Next, winappcli, TRX." +license: MIT +--- + +# Local VM UI testing + +Run PowerToys `.Next` UI tests in a persistent, interactive Windows VM while keeping product and test +execution off the host. Use this skill as the execution complement to +[ui-tests-migration](../ui-tests-migration/SKILL.md). Restore the baseline checkpoint or recreate the +guest when clean-profile behavior must be validated. + +The guest is a Hyper-V virtual machine. Nothing runs nested, so the same scaffold works on x64 and on +Windows on ARM, where nested virtualization is unavailable to any Linux-hosted emulator. + +A module is done when the **full** suite is green on Windows 10 **and** on Windows 11, in two +separate VMs. Run Windows 10 Enterprise LTSC 2021 first because it gives the fastest feedback, then +run the same unfiltered suite on Windows 11. Differences in the shell, compositor, theming, and +timing break tests that contain nothing Windows 11-specific, and those are exactly the failures +worth catching locally instead of in CI. On a Windows on ARM host, Windows 11 ARM64 is the only +practical guest; run it with `-Platform ARM64` and get the Windows 10 half from an x64 host. + +Start guests with the default resource profile: 4 vCPUs and 8 GB RAM. Get the target suite fully +green before lowering resources with the `Constrained` profile (1 vCPU and 4 GB RAM). + +## How the host reaches the guest + +| Concern | Mechanism | +|---|---| +| Control channel | PowerShell Direct over VMBus. No listener, port, certificate, or firewall rule in the guest. | +| Bulk payload | `Copy-VMFile` over the Guest Service Interface, ~82 MB/s. The session copy is a fallback and stalls on archives near a gigabyte. | +| Exchange | Guest-local `C:\PowerToysUiTestExchange\`, mirrored by the controller. The host never shares a folder with the guest. | +| Host privilege | Hyper-V access: an elevated shell, or an account in the local **Hyper-V Administrators** group. Creating a guest additionally requires real elevation. | +| Console | `scripts/Get-VmConsoleImage.ps1` renders the framebuffer to PNG, so an agent can read boot and desktop state without VMConnect. | + +## When to use this skill + +Use it when asked to: + +- Create or migrate UI tests and iterate repeatedly without reprovisioning Windows each run. +- Validate Explorer, hotkey, WebView2, shell-extension, foreground, or composed-visual behavior in a + real interactive desktop. +- Run tests as a true standard user while retaining a separate administrator control channel. +- Reuse unchanged PowerToys, winappcli, and .NET payloads and refresh only changed archives. +- Keep a reproducible local VM baseline with optional .NET 10, WebView2, diagnostics, or `msvsmon`. +- Collect durable `status.json`, TRX, transcripts, logs, screenshots, and failure attachments. +- Compare revisions in one stable VM before confirming the result from a restored checkpoint. + +Do not treat a persistent VM as proof of clean-profile behavior. Caches, registrations, settings, and +first-run state survive between runs. Restore the baseline checkpoint or recreate the VM when those +are the behavior under test. + +## Relationship to other UI-test skills + +| Skill | Owns | +|---|---| +| `ui-tests-migration` | Test design, project scaffolding, framework APIs, assertions, lifecycle, and CI stability. | +| `ui-tests-local-vm` | Fast persistent-VM setup, deployment, interactive execution, evidence export, and iteration. | + +Do not modify stabilized tests merely to make the local VM green. First prove that the suite executes, +produces assertion-bearing TRX, and has a useful success rate. Classify environment-specific failures +separately unless the task explicitly asks for stabilization. + +## Guest OS policy + +- Two guests, two full suites. Windows 10 Enterprise LTSC 2021 (build 19044/21H2, newer than the + Windows 10 20H2 baseline) and Windows 11. Both must be fully green before a module is done. + LTSC is not available through Fido; `-Source Fido -Windows 10` automates Microsoft's official + mobile-user-agent ISO page and is the practical public default. The public ISO/MCT images are too + old for .NET 10 CET, so Setup Dynamic Update must bring Win10 to 1904x.5007+ before the baseline. + Use licensed Microsoft subscription media for LTSC when available, and always record the edition, + ISO hash, and installed full build ([references/setup.md §3](references/setup.md#3-get-windows-media)). +- Windows 10 runs first: it is the faster loop and surfaces most defects. Windows 11 then runs the + **same** suite, unfiltered - not only the tests that look Windows 11-specific. A test with no + Windows 11 content can still fail there, which is the whole reason for the second pass. +- Narrow filters belong to iteration and diagnosis. They are never the evidence for the Windows 11 + pass. +- Give each OS its own VM name, `vm.config.psd1`, VHDX, checkpoints, and exchange. Never upgrade or + repurpose the Windows 10 guest into the Windows 11 guest; the two baselines must stay independent. +- Surfaces that exist only on Windows 11, such as the tier-1 Explorer context menu, need no special + handling: the full Windows 11 run already covers them. +- On a Windows on ARM host, use a Windows 11 ARM64 guest with `-Platform ARM64`. Hyper-V does not + emulate a foreign architecture, so that host cannot supply the Windows 10 x64 pass - run it on an + x64 host and report both. +- A Windows 11 host requirement does not make Windows 11 the first guest target. +- `-Platform` is not cosmetic: it flows to the guest as the `platform` environment variable, names + visual baselines, and marks the run as pipeline-like. Use only `x64Win10`, `x64Win11`, or `ARM64`. + +## Required reads + +Read only what the task needs: + +1. [references/setup.md](references/setup.md) - host requirements, scaffolding, media acquisition, + unattended guest creation, credentials, standard-user desktop, and checkpoint baselines. +2. [references/agentic-loop.md](references/agentic-loop.md) - payload contract, controller usage, + focused-to-suite iteration, evidence, verdicts, and reset strategy. +3. [references/customization.md](references/customization.md) - persistent image customization, + .NET 10, WebView2, `msvsmon`, resource profiles, and golden-baseline guidance. +4. [references/troubleshooting.md](references/troubleshooting.md) - guest creation, PowerShell Direct, + interactive session, scheduled-task, focus, timeout, and export failures. +5. [references/shell-extensions-and-signing.md](references/shell-extensions-and-signing.md) - **read + for any shell-extension module** (context menu, preview/thumbnail handler). Why unsigned CI PR + builds cannot register a sparse MSIX (0% on CI), classic (registry-COM, signing-free) vs modern + (sparse-MSIX) surfaces, Debug vs Release/`NDEBUG` gating, runtime detection, and reproducing CI's + classic scenario on a local signed VM. +6. [ui-tests-migration](../ui-tests-migration/SKILL.md) - required whenever test code or framework + behavior is being created, migrated, or stabilized. + +## Default agentic cycle + +```mermaid +flowchart LR + A[Design or edit test] --> B[Host build] + B --> C[Package changed payload] + C --> D[Start or reuse VM] + D --> E[Probe standard-user desktop] + E --> F[Run focused test] + F --> G[Export status TRX evidence] + G --> H{Need test change?} + H -- Yes --> A + H -- No --> I[Run full suite on Win10] + I --> J[Run same full suite on Win11] + J --> K{Both fully green?} + K -- No --> A + K -- Yes --> L[Optional checkpoint restore] +``` + +Create and maintain this task list: + +```markdown +- [ ] 0. Verify host setup FIRST: `Initialize-LocalVmHost.ps1 -VmRoot -CheckOnly`. If it reports + IsReady=false, STOP and ask the user to run the elevated command it prints - Hyper-V group + membership, the DPAPI credential, and guest creation all need a human. Never autopilot past it +- [ ] 1. Read ui-tests-migration guidance for the target test surface +- [ ] 1a. Read the target module's dev docs — `doc/devdocs/modules/.md` (search `doc/devdocs/`, + including `common/`, if the exact file is missing) — for development-cycle gotchas such as + Release/`NDEBUG` registration gating, signed sparse-MSIX context menus, and Explorer restarts, + so a module's registration/deployment requirements do not surface as opaque test failures. + For shell-extension modules also read references/shell-extensions-and-signing.md. +- [ ] 2. Scaffold or verify the local VM - references/setup.md +- [ ] 3. Build product and test projects on the host to exit code 0 +- [ ] 4. Package a lean exchange and verify archive hashes +- [ ] 5. Run the controller with -PlanOnly and inspect its request/plan +- [ ] 6. Probe the non-admin interactive desktop before test execution +- [ ] 7. Run one focused test; read the controller result's `.Failed` array (non-passed tests + first + error line) instead of re-parsing TRX, and use `scripts/Invoke-GuestScript.ps1` for guest-state inspection +- [ ] 8. Diagnose the first controlling failure without weakening assertions +- [ ] 9. Rebuild and rerun with -ReuseStagedPayload +- [ ] 10. Widen to the full module suite on Windows 10 and report pass rate/root-cause groups +- [ ] 11. Run the same full suite in the Windows 11 VM; both must be green before the module is done +- [ ] 12. Restore the baseline checkpoint for clean-profile confirmation when required +``` + +## Quick start + +Host setup is a one-time, **human-only** step: Hyper-V group membership, the DPAPI guest credential, +and guest creation all need elevation or a password. Check it before anything else - this needs no +elevation and changes nothing: + +```pwsh +pwsh .github\skills\ui-tests-local-vm\scripts\Initialize-LocalVmHost.ps1 -VmRoot X:\PowerToysUiTestVm -CheckOnly +``` + +If it reports `IsReady=false`, stop and ask the user to run the elevated command it prints (see +[references/setup.md §0](references/setup.md#0-human-only-host-setup-one-command)). Otherwise scaffold +the VM directory outside the repository: + +```pwsh +pwsh .github\skills\ui-tests-local-vm\scripts\Initialize-LocalVm.ps1 ` + -DestinationRoot X:\PowerToysUiTestVm +``` + +The scaffold and its `shared` exchange can live on any volume, including a Dev Drive. Only the VHDX +and VM configuration paths, set separately in `vm.config.psd1`, should point at NTFS. + +Follow [references/setup.md](references/setup.md) to write the untracked `vm.config.psd1`, save the +administrator credential with Windows DPAPI, obtain install media, and create the guest with +`New-UiTestVm.ps1`. Then stage the archives described in +[references/agentic-loop.md](references/agentic-loop.md) and run: + +```pwsh +pwsh .github\skills\ui-tests-local-vm\scripts\Invoke-LocalVmUiTest.ps1 ` + -VmName PowerToysUiTest-Win10 ` + -VmRoot X:\PowerToysUiTestVm ` + -ExchangeRoot X:\PowerToysUiTestVm\shared\PowerToysUiTests\MyModule ` + -TestExecutable MyModule.UITests.Next.exe ` + -Filter 'Name=MyModule.FocusedTest' ` + -Platform x64Win10 ` + -BuildLabel (git rev-parse HEAD) ` + -SuiteTimeout 15m ` + -TimeoutMinutes 25 ` + -ReuseStagedPayload +``` + +The controller starts the VM if needed, verifies the interactive standard-user token and desktop, +dispatches the shared guest runner through a limited interactive scheduled task, streams progress, +waits for parseable `status.json`, summarizes TRX, and leaves the persistent VM running by default. + +## Non-negotiable rules + +- Complete host setup before anything else and **never autopilot around it**. Hyper-V group + membership, the DPAPI guest credential, and guest creation are human-only: two need elevation that + no tool call can approve, one needs a password that must never reach a model. + `Initialize-LocalVmHost.ps1` performs all three; agents run it `-CheckOnly`, and on + `IsReady=false` report `BLOCKED`, print the elevated command it emits, and wait. Do not ask for a + password, do not substitute a weaker channel, do not proceed on a partial setup. + `Invoke-LocalVmUiTest.ps1` enforces the same check. +- Keep the guest's VHDX and VM configuration on NTFS. On this project's host, keeping them on a Dev + Drive wedged the VM management service twice - `vmms` at 0% CPU, even `Get-VM` hanging, host reboot + to recover - and moving to NTFS fixed it. This is an observation on one host, not a property of + ReFS: Hyper-V on plain ReFS is supported, so `-AllowReFsVolume` overrides the default refusal. The + scaffold and the exchange are unaffected and run fine on a Dev Drive. +- Build on the host; run PowerToys and tests only in the VM when host execution is prohibited. +- Finish on two green full suites: Windows 10 and Windows 11, in separate VMs. Windows 10 runs first + for speed; Windows 11 runs the same unfiltered suite, never a Win11-only subset. Narrow filters are + for iteration, not for sign-off. On a Windows on ARM host the ARM64 Windows 11 guest covers the + Windows 11 half and the Windows 10 half needs an x64 host. +- Establish a fully green correctness baseline with the default (4 vCPU / 8 GB) resources before + running the same tests under `Constrained` (1 vCPU / 4 GB) resources. +- Keep VM files and writable exchange folders outside the repository. +- Keep the guest's default inbound network posture. The control channel does not need connectivity, + so do not enable remoting, open ports, or attach the guest to a routable network for test dispatch. +- Use a DPAPI-protected credential file. Never put credentials in prompts, scripts, request JSON, + unattend files kept after install, source control, or command-line arguments. +- Run UI tests in an already logged-on standard-user desktop, never in session 0 or as `SYSTEM`. +- Keep a separate administrator account only for VM control and scheduled-task registration. +- Verify user, token integrity, Explorer presence, session ID, and display size before tests. +- Run product/tests from guest-local storage under `C:\PowerToysUiTestRun`. +- Use PowerShell 7 for interactive probe/test scheduled tasks. PowerShell Direct and OEM bootstrap + remain PS5.1-compatible by design; do not enable a remoting endpoint merely to use PS7. +- Reuse payloads by per-component hashes; refresh only changed tests/product/tools. +- Preserve assertions and visual thresholds. Classify VM-specific failures from evidence. +- Always parse TRX and require `total > 0` plus `executed == total`. A process exit code alone cannot + distinguish assertions, skipped/inconclusive tests, zero tests, timeout, or infrastructure failure. +- Keep the VM after normal runs for iteration. Stop it explicitly when idle; delete its VHDX only for + an intentional baseline reset. +- Final clean-profile claims require a restored baseline checkpoint or a recreated guest. Restore with + `Reset-LocalVm.ps1 -Restore`. diff --git a/.github/skills/ui-tests-local-vm/references/agentic-loop.md b/.github/skills/ui-tests-local-vm/references/agentic-loop.md new file mode 100644 index 0000000000..3c6fb1a044 --- /dev/null +++ b/.github/skills/ui-tests-local-vm/references/agentic-loop.md @@ -0,0 +1,241 @@ +# Agentic local-VM UI-test loop + +This loop assumes the test project follows `Microsoft.PowerToys.UITest.Next`, builds as a +Microsoft.Testing.Platform executable, and has already passed the `ui-tests-migration` design and +CI-stability checks. + +Run the full suite twice: on a Windows 10 Enterprise LTSC 2021 guest first, then the same unfiltered +suite on a separate Windows 11 guest. Both must be green. Windows 11 is not a filtered follow-up - +tests with no Windows 11 content still fail there for shell, compositor, and timing reasons. + +## 1. Build on the host + +Build only; do not launch PowerToys or tests on the host when the task forbids it. + +```pwsh +tools\build\build.cmd ` + -Path src\modules\\Tests\.UITests.Next ` + -Platform x64 -Configuration Debug + +git rev-parse HEAD +``` + +Exit code 0 is required. Record the build label before packaging. + +## 2. Create a lean exchange + +The exchange can be any host folder. Keeping it under the scaffold's `shared` folder keeps VM assets +together and out of the repository; the controller mirrors it into the guest at +`C:\PowerToysUiTestExchange\`: + +```text +\shared\PowerToysUiTests\\ +|-- ui-tests.zip +|-- powertoys-runtime.zip +|-- winappcli.zip +|-- dotnet-runtime.zip +|-- product-overlay.zip # optional +|-- MicrosoftEdgeWebView2RuntimeInstallerX64.exe # optional +`-- LocalVmResults\ +``` + +The controller writes each request and its durable evidence under `LocalVmResults`. + +Package archive contents directly: + +```pwsh +Compress-Archive -Path '\*' ` + -DestinationPath '\ui-tests.zip' -Force +Compress-Archive -Path '\*' ` + -DestinationPath '\powertoys-runtime.zip' -Force +``` + +**Build the product runtime in Release for any shell-extension test.** The runtime context-menu +registration for Image Resizer, File Locksmith, New+, and PowerRename is compiled behind +`#if defined(ENABLE_REGISTRATION) || defined(NDEBUG)`, so a **Debug** runtime silently omits it: the +module enables and logs normally, but the entry never appears in Explorer and menu assertions fail +with no obvious cause (for example, "Explorer did not show 'Resize with Image Resizer'"). CI ships +Release for this reason. If you must validate against a Debug runtime, rebuild only the affected +module DLL with `ENABLE_REGISTRATION` defined and overlay it via `product-overlay.zip`. + +Use the repository-pinned winappcli build and a private .NET runtime matching the test executable. +Even when .NET 10 is installed in the VM baseline, the private runtime remains the default for +reproducibility and revision comparison. + +The controller copies its bundled `templates/run-ui-tests.ps1`, computes per-component SHA-256 +hashes, writes a run-specific request, and never maps the repository or build output directly into +Windows. + +## 3. Validate the plan + +Always run the first request with `-PlanOnly`: + +```pwsh +pwsh .github\skills\ui-tests-local-vm\scripts\Invoke-LocalVmUiTest.ps1 ` + -VmName PowerToysUiTest-Win10 ` + -VmRoot X:\PowerToysUiTestVm ` + -ExchangeRoot X:\PowerToysUiTestVm\shared\PowerToysUiTests\ ` + -TestExecutable .UITests.Next.exe ` + -Filter 'Name=' ` + -BuildLabel (git rev-parse HEAD) ` + -PlanOnly +``` + +Check: + +- `GuestExchangeRoot` in the plan is a path under `C:\PowerToysUiTestExchange`. +- Test, product, winappcli, and .NET hashes are present. +- The filter uses `Name=`, `Name~`, `FullyQualifiedName~`, or `TestCategory=`. +- No password, token, or source path appears in the request. + +## 4. Run one focused test + +Use the default VM resource profile (4 vCPUs and 8 GB RAM) while creating and stabilizing tests. Do +not begin on the constrained profile: first prove the test and product behavior with sufficient CPU +and RAM. + +```pwsh +pwsh .github\skills\ui-tests-local-vm\scripts\Invoke-LocalVmUiTest.ps1 ` + -VmName PowerToysUiTest-Win10 ` + -VmRoot X:\PowerToysUiTestVm ` + -ExchangeRoot X:\PowerToysUiTestVm\shared\PowerToysUiTests\ ` + -TestExecutable .UITests.Next.exe ` + -Filter 'Name=' ` + -Platform x64Win10 ` + -BuildLabel (git rev-parse HEAD) ` + -DesktopWidth 1920 -DesktopHeight 1080 ` + -SuiteTimeout 15m -TimeoutMinutes 25 +``` + +Before the guest runner starts, the controller dispatches a probe into the interactive account and +requires: + +- User is the configured standard user and is not an administrator. +- Session ID is greater than zero. +- Explorer exists in that session. +- Display dimensions match the request, unless both are zero. +- The guest exchange folder is accessible. + +The probe and test tasks execute under the provisioned PowerShell 7 `pwsh.exe`. The narrow +PowerShell Direct control channel remains inbox Windows PowerShell 5.1; no remoting endpoint or +firewall rule is enabled for PS7. + +Failure here is `BLOCKED`, not a test failure. + +Iterate on Windows 10 first; it is the faster loop. Point the same controller at the separate +Windows 11 VM and exchange with `-Platform x64Win11` for the second pass. Do not reuse the Windows 10 +guest disk as the Windows 11 guest. + +## 5. Parse evidence + +Each run writes: + +```text +LocalVmResults\localvm-\ +|-- controller-plan.json +|-- request.json +|-- desktop-probe.ps1 +|-- desktop-probe.json +|-- progress.json +|-- status.json +|-- local-vm-ui-tests.log +`-- TestResults\ + |-- .trx + `-- +``` + +The controller prints scalar TRX counters and per-test outcomes. Read both `status.json` and TRX: + +- Assertion-bearing TRX failures are `FAIL`. +- Skipped, inconclusive, or otherwise `NotExecuted` tests are `FAIL`; require `total > 0` and + `executed == total` even when the test process exits 0. +- Zero selected tests/MTP exit code 8 is `BLOCKED`. +- Missing desktop, control channel, archive, or status is `BLOCKED`. +- Proven display/profile/compositor differences are `ENVIRONMENT`. +- An N/M pass rate proves the execution loop ran, even when the task did not ask to stabilize tests. + +Do not modify an already stabilized suite merely because the local VM differs from CI. Report the +pass rate and group failures by controlling boundary first. + +## 6. Iterate incrementally + +After changing tests or product code: + +1. Build the touched project to exit code 0. +2. Replace only the corresponding archive. +3. Rerun the same focused filter with `-ReuseStagedPayload`. +4. Confirm `RefreshedComponents` contains only the changed component. +5. Widen only after the focused behavior is understood. + +```pwsh +pwsh .github\skills\ui-tests-local-vm\scripts\Invoke-LocalVmUiTest.ps1 ` + ` + -ReuseStagedPayload +``` + +The guest manifest persists under `C:\PowerToysUiTestRun`. Unchanged tests/product/winappcli/.NET +are not extracted again. WebView2 and other baseline tools remain installed. + +The VM stays running after each run. Use `-SkipStart` when it is already healthy, and +`-StopVmAfterRun` only when no further iteration is expected. + +## 7. Widen to the suite, on both guests + +Use a bounded category filter, first on the Windows 10 guest: + +```pwsh +-Filter 'TestCategory=' -SuiteTimeout 45m -TimeoutMinutes 60 +``` + +Report: + +- Executed, passed, failed, and error counts. +- Exact pass rate. +- Root-cause groups, not only test names. +- Guest user/session/display and payload fingerprint. +- Export errors independently from assertion failures. + +Then run the **same** filter against the Windows 11 guest with `-Platform x64Win11` and report that +evidence separately. Narrowing the Windows 11 run to Windows 11-specific tests does not satisfy this +step. The module is done only when both suites are fully green; a Windows 10 pass with an unrun or +red Windows 11 suite is an incomplete result, not a success. + +Once the complete target suite is green, stop the guest, then let the controller restart it with the +`Constrained` profile (1 vCPU and 4 GB RAM). Pass the guest's config explicitly when one VM root owns +multiple guests: + +```pwsh +pwsh \Stop-LocalVm.ps1 -ConfigPath \vm.config.win10.psd1 + +pwsh .github\skills\ui-tests-local-vm\scripts\Invoke-LocalVmUiTest.ps1 ` + -VmName PowerToysUiTest-Win10 ` + -ConfigurationPath \vm.config.win10.psd1 ` + -ResourceProfile Constrained ` + -VmRoot -ExchangeRoot ` + -TestExecutable .UITests.exe ` + -Filter 'TestCategory=' -Platform x64Win10 ` + -ReuseStagedPayload +``` + +`Invoke-LocalVmUiTest.ps1` rejects a config whose `VmName` does not match, records the resource +profile in the request/result, and passes it to `Start-LocalVm.ps1`. Resource changes only apply +while the VM is off; stopping first is therefore required. Repeat separately on Windows 11. Keep the +default-profile TRX as the correctness baseline and classify failures that appear only under +constrained resources separately. + +## 8. Confirm clean-profile behavior + +A retained VM accumulates registry state, caches, thumbnail databases, WebView profiles, Settings, +and first-run suppressions. Choose one final confirmation based on risk: + +- Restore the baseline checkpoint with `Reset-LocalVm.ps1 -Restore`. A standard checkpoint includes + memory, so this returns to the captured logged-on desktop in seconds. +- Rebuild the guest from media with `New-UiTestVm.ps1 -Force` when the checkpoint itself is suspect. + +Do not call a retained run clean merely because the product archive was refreshed. + +## Revision comparison + +Hold the guest, Windows build, display, account, tools, filter, and timeouts constant. Change only the +intentional test/product archive and record both fingerprints. For a clean-baseline comparison, +restore the same checkpoint before each revision. diff --git a/.github/skills/ui-tests-local-vm/references/customization.md b/.github/skills/ui-tests-local-vm/references/customization.md new file mode 100644 index 0000000000..03578e74d0 --- /dev/null +++ b/.github/skills/ui-tests-local-vm/references/customization.md @@ -0,0 +1,145 @@ +# Local VM customization + +## What is actually customized + +The guest is an ordinary Hyper-V virtual machine backed by one VHDX. Installing software does not +produce a new layer or image; it changes that persistent disk. Checkpoints are the only rollback +mechanism, so take one whenever you reach a state later runs should inherit. + +Use three levels deliberately: + +1. **VM configuration** (`vm.config.psd1`) - name, storage paths, disk size, CPU, RAM, switch, + accounts, architecture, locale, and the baseline checkpoint name. +2. **OEM baseline** - deterministic software and policy applied during Windows installation. +3. **Retained disk** - tools, user profiles, caches, and ad hoc diagnostics installed later. + +Pin the Windows media and every installer version for reproducibility. Keep OEM scripts in source +control, and keep `vm.config.psd1`, credentials, Windows media, licensed installers, checkpoints, and +the VHDX out of source control. The scaffold's `.gitignore` already excludes them. + +## OEM installation + +`New-UiTestVm.ps1` builds an answer-file ISO whose `FirstLogonCommands` copy the scaffold's `oem` +folder into `C:\OEM` and run `Provision-UiTestVm.ps1`. Extend that script or call additional scripts +from it. Every addition must be silent, idempotent, checksum-verified, and return a meaningful exit +code. + +Prefer offline, signed installers staged beside the script. Avoid downloading floating `latest` +artifacts during baseline creation. Record versions and SHA-256 values in a provisioning manifest. + +To update an existing VM, run the same idempotent script over PowerShell Direct with +`scripts/Invoke-GuestScript.ps1`, then re-take the baseline checkpoint. Recreate the guest instead +when installation-order or first-logon behavior matters. + +## .NET 10 + +Yes, .NET 10 can be part of the default baseline. + +- Place `dotnet-sdk-10*-win-*.exe` in `oem` to install the SDK and runtimes. +- If guest compilation is unnecessary, place `windowsdesktop-runtime-10*-win-*.exe` instead. +- Match the guest architecture: an ARM64 guest needs `-win-arm64` installers. +- Pin the exact installer version and verify its Microsoft-published checksum. +- Use Windows 10 Enterprise LTSC 2021 for the first maintained baseline on x64, and keep an equally + maintained Windows 11 baseline: both carry a full suite run. + +The UI-test controller still stages a private pinned `dotnet-runtime.zip` by default. This is +intentional: revision runs remain independent of servicing changes in the VM. The baseline runtime is +useful for diagnostics and manually launched tools. Rely on the system runtime only after extending +the guest contract to record and enforce its exact version. + +## WebView2 and other runtime prerequisites + +Place `MicrosoftEdgeWebView2RuntimeInstaller*.exe` in `oem` for WebView/Monaco-heavy suites. The +guest runner also supports a run-specific installer when the baseline lacks it. + +VC++ redistributables, Windows App SDK runtimes, certificates, fonts, media codecs, and test data can +be provisioned the same way. Install only what CI or the target user machine actually has; an overly +rich baseline can hide deployment defects. + +## Visual Studio Remote Debugger (`msvsmon`) + +`msvsmon` is optional. Normal UITest.Next execution requires no Visual Studio installation or remote +tools in the VM. The controller needs only PowerShell Direct, Task Scheduler, the interactive +desktop, winappcli, the product, tests, and the .NET runtime. + +For interactive debugging: + +1. Install the Remote Tools version compatible with the host Visual Studio, or copy the complete + matching Remote Debugger folder from the host installation. +2. Match the guest architecture. The x64 monitor can launch the 32-bit monitor when needed. +3. Attach the guest to a switch the host can reach - the `Default Switch` gives it a host-only NAT + address - and note that address; the control channel itself needs no network. +4. Add guest firewall rules for TCP 4026, and TCP 4025 only for WOW64 debugging. +5. Start `msvsmon` in the same `PTUser` desktop for normal user-process debugging. +6. Use `/nodiscovery` and connect directly to `:4026`; UDP 3702 discovery does not + need to be exposed. +7. Keep Windows authentication. Do not use no-auth mode outside an isolated disposable network. + +Run an elevated monitor only when attaching to an elevated or different-user process. That changes +the integrity boundary and must not be confused with the normal user-only test scenario. + +No additional Visual Studio components are required in the VM unless the guest must compile code. +Keep symbols on the host when possible; copy matching binaries/PDBs or point the debugger at the +staged build outputs. + +The standard controller does not start or stop `msvsmon`. Treat remote debugging as a developer +profile, not a dependency of unattended validation. + +## Golden baselines and reset + +A useful golden checkpoint has: + +- Windows fully serviced and activated as appropriate. +- OEM provisioning complete. +- `PTUser` auto-logon verified and the resolution task applied. +- Optional pinned runtimes installed. +- No PowerToys payload, test results, or module-specific cache in the guest work root. + +```pwsh +pwsh .\Reset-LocalVm.ps1 -List # show checkpoints +pwsh .\Reset-LocalVm.ps1 -CreateBaseline -CheckpointName 'webview2-installed' +pwsh .\Reset-LocalVm.ps1 -Restore -StartAfterRestore # back to the clean baseline +``` + +Standard checkpoints include memory, so restoring returns to the captured logged-on desktop in +seconds rather than a cold boot - far cheaper than reinstalling Windows for every clean-profile run. +Restoring a checkpoint is also more deterministic than accumulating repair scripts. + +Keep the Windows 10 and Windows 11 baselines as separate VMs with their own +configuration files and VHDX paths. Never upgrade one baseline in place to stand in for the other. + +Checkpoints consume disk. Budget at least twice `DiskSizeGB`, plus `MemoryStartupGB` per standard +checkpoint, and prune obsolete ones. + +## Custom Windows media + +`New-UiTestVm.ps1` accepts any Windows ISO through `-InstallMedia`, and +`scripts/Get-WindowsMedia.ps1` validates local media or resolves an official Microsoft retail link. +Host and guest architecture must match: Hyper-V does not emulate a foreign architecture, so an ARM64 +host builds ARM64 guests only. Use custom media when licensing, edition, language, servicing, or +enterprise policy requires it, and keep OEM provisioning independent of the media source. + +## Resource sizing + +Use the default profile until the target suite is fully green: 4 vCPUs and 8 GB RAM, from +`ProcessorCount` and `MemoryStartupGB` in `vm.config.psd1`. Establish correctness and stable timings +with this profile before investigating resource sensitivity. + +Only after the suite is green, restart with the constrained profile. Its defaults are 4 GB RAM and +1 vCPU, overridable with `ConstrainedMemoryStartupGB` and `ConstrainedProcessorCount`. Restricting +the VM to a single core is how this workflow reproduces slow-agent and CI-like timing pressure. Treat +failures introduced only by this second phase as resource-pressure findings; do not weaken assertions +to accommodate them. + +```pwsh +# Default correctness pass. +pwsh .\Start-LocalVm.ps1 -ResourceProfile Default -Wait + +# Post-green pressure iteration. +pwsh .\Start-LocalVm.ps1 -ResourceProfile Constrained -Wait +``` + +Run `Start-LocalVm.ps1 -PlanOnly` to inspect the resolved profile without touching the VM. The guest +runs directly on the platform hypervisor, so its memory comes straight from the host: leave several +gigabytes of headroom for the host and the build. Apply CPU pressure by lowering the VM's vCPU count, +not process affinity. diff --git a/.github/skills/ui-tests-local-vm/references/setup.md b/.github/skills/ui-tests-local-vm/references/setup.md new file mode 100644 index 0000000000..c06dc05d29 --- /dev/null +++ b/.github/skills/ui-tests-local-vm/references/setup.md @@ -0,0 +1,409 @@ +# Local UI-test VM on Hyper-V + +Create a persistent, interactive Windows guest on the platform hypervisor and drive it from the host +over PowerShell Direct. This is the only supported VM backend for this skill; everything after the +guest exists is described in [agentic-loop.md](agentic-loop.md). + +What you get: + +- No nested virtualization, so the scaffold works on x64 and on Windows on ARM alike. +- No guest listener, port, certificate, or firewall rule. A guest with no network adapter at all + still works. +- Fast, repeatable clean baselines: a standard checkpoint restores a logged-on desktop in seconds. +- An agent-readable console: `Get-VmConsoleImage.ps1` writes a PNG of the framebuffer, and + `vmconnect.exe` is available for interaction. + +| Concern | Mechanism | +|---|---| +| Control channel | PowerShell Direct over VMBus | +| Exchange | Guest-local `C:\PowerToysUiTestExchange\`, mirrored by the controller | +| Payload transfer | `Copy-VMFile` over the Guest Service Interface, skipping archives whose SHA-256 already matches; the session copy is a fallback | +| Clean baseline | `Reset-LocalVm.ps1 -Restore` | +| Host shell | **Elevated**, or an account in the local Hyper-V Administrators group | + +## Host requirements + +- Windows 10/11 Pro, Enterprise, or Education with the Hyper-V feature enabled, or Windows Server. +- Permission to manage Hyper-V, granted once through [step 0](#0-grant-hyper-v-access-one-time-elevated). + The scripts probe the capability rather than the token shape, and stop with `BLOCKED` rather than + degrading the channel when neither route is available. +- **Guest storage on an NTFS volume.** On the host this skill was built against, keeping the VHDX on + a Dev Drive wedged the Hyper-V management service mid-operation: `vmms` and `vmwp` sat at 0% CPU, + later management calls never returned - including read-only ones such as `Get-VM` - and recovery + needed a `vmms` restart or a host reboot. Moving the guest to NTFS fixed it. + + Treat that as an observation on one host rather than a property of ReFS. Hyper-V on ReFS is a + supported and in places preferred configuration, and ReFS block cloning accelerates checkpoint + merges. A Dev Drive differs from plain ReFS mainly in that it attaches only an allow-listed set of + filesystem filters, which is a plausible - but unproven - way to strand a storage operation. + + `New-UiTestVm.ps1` therefore refuses ReFS by default and accepts `-AllowReFsVolume` as the + override; ReFS is a cheap proxy for "Dev Drive", since telling the two apart needs elevation. + Check with `(Get-Volume -DriveLetter D).FileSystemType`. + + This applies only to `VhdPath` and `VmPath`. The scaffold, the `shared` exchange, and the staged + archives are ordinary file I/O and run fine on a Dev Drive. +- Free disk for the guest disk plus checkpoints. Budget at least twice `DiskSizeGB`. A standard + checkpoint also stores the guest's memory, so add `MemoryStartupGB` on top. +- Host and guest architecture must match. Hyper-V does not emulate a foreign architecture, so an + ARM64 host builds ARM64 guests only. +- **The Visual C++ redistributable, for MP4 capture.** The harness records each test with + ScreenRecorderLib, a mixed-mode assembly importing `VCRUNTIME140`/`MSVCP140`; a clean Windows image + has neither, so video is skipped (the harness now prints why). `Initialize-LocalVmHost.ps1` + downloads the architecture-matched Microsoft-signed redistributable, verifies its Authenticode + signer, and stages it under `oem`; provisioning installs it automatically and + `ProvisioningReady.json` reports `ScreenRecordingSupported`. The controller also repairs an + existing guest from that verified payload before a run. +- **PowerShell 7 for guest-side orchestration.** The setup helper downloads the pinned official MSI, + verifies both its published release SHA-256 and Microsoft Authenticode signer, and stages it under + `oem`. Provisioning installs it with PS remoting disabled; the controller repairs existing guests + and runs desktop-probe/test scheduled tasks under `pwsh.exe`. + + PowerShell Direct and OEM bootstrap still use inbox Windows PowerShell 5.1. That is intentional: + registering a PS7 remoting endpoint would weaken the no-remoting posture, and provisioning must + work before PS7 exists. Keep every `Invoke-Command -VMName` scriptblock PS5.1-compatible; PS7 + removes that constraint from the much larger interactive runner. + +> **ARM64 guests need ARM64 payloads.** An ARM64 guest needs ARM64 PowerToys, test, winappcli, .NET, +> and WebView2 payloads, and it must be run with `-Platform ARM64` so visual baselines resolve. + +## 0. Human-only host setup (one command) + +Three prerequisites gate every agent-driven run, and **an agent can perform none of them**: two need +elevation, which no tool call can approve, and one needs a password, which must never be routed +through a model. `Initialize-LocalVmHost.ps1` does all three, reports what is already in place, +performs only what is missing, and is safe to re-run. It also refreshes copied scaffold scripts from +the current skill templates before mutating anything, stages VC++ and PowerShell 7 prerequisites, +and verifies Windows 10's .NET 10 CET floor before recapturing the baseline. + +| # | Prerequisite | Why a human | +|---|---|---| +| 1 | Membership in the local **Hyper-V Administrators** group | Elevation; takes effect only after signing out and back in | +| 2 | DPAPI **guest administrator credential** | A password typed straight into the prompt | +| 3 | The **guest** itself (`New-UiTestVm.ps1`) | Elevation, to read the media and create the virtual disk | + +Scaffold ([step 1](#1-scaffold)) and obtain media ([step 3](#3-get-windows-media)) first, then run +this once from an **elevated PowerShell 7** terminal: + +```pwsh +pwsh .github\skills\ui-tests-local-vm\scripts\Initialize-LocalVmHost.ps1 ` + -VmRoot C:\PowerToysUiTestVm ` + -InstallMedia C:\PowerToysUiTestVm\media\Win11_25H2_English_x64.iso +``` + +If the account was not yet in Hyper-V Administrators, the script adds it and stops: group membership +is baked into the logon token, so it **signs out and back in, then re-runs** to finish steps 2 and 3. +Everything after that is unattended. + +### Agents: check, then stop + +Run it with `-CheckOnly`. It needs no elevation, changes nothing, prints a status table, and exits +non-zero when something is missing: + +```pwsh +pwsh .github\skills\ui-tests-local-vm\scripts\Initialize-LocalVmHost.ps1 -VmRoot C:\PowerToysUiTestVm -CheckOnly +``` + +```text +Local UI-test VM host setup - PowerToysUiTest-Win11 + [ok] Hyper-V access ok + [missing] Guest credential missing: ...\admin.credential.xml + [ok] Guest ok (State=Running) +``` + +When it reports `IsReady=false`, **stop and ask the user to run the elevated command it prints.** Do +not autopilot around it, do not ask for a password, and do not substitute a weaker channel. +`Invoke-LocalVmUiTest.ps1` enforces the same check and throws `BLOCKED` with the same instruction. + +Useful switches: `-CheckOnly`, `-SkipScaffoldRefresh`, `-SkipVcRedist`, `-SkipPowerShell`, `-SkipWindowsUpdate`, +`-SkipGroupMembership`, `-SkipCredential`, `-SkipGuestCreation`, `-Account` (defaults to the current +user), `-Force`, `-AllowReFsVolume`. + +### Verifying by hand + +```pwsh +whoami /groups | Select-String 'Hyper-V Administrators' # must print the group +Get-VM # must not throw a permission error +``` + +`Get-VM: You do not have the required permission to complete this task` means the membership is +missing or the session predates it. Membership alone covers the whole run loop - scaffold, start and +stop, checkpoint reset, PowerShell Direct, `Copy-VMFile`; only **creating** a guest additionally needs +an elevated terminal. + +## 1. Scaffold + +```pwsh +pwsh .github\skills\ui-tests-local-vm\scripts\Initialize-LocalVm.ps1 ` + -DestinationRoot X:\PowerToysUiTestVm +``` + +```text +X:\PowerToysUiTestVm\ +|-- vm.config.example.psd1 +|-- New-UiTestVm.ps1 +|-- Start-LocalVm.ps1 +|-- Stop-LocalVm.ps1 +|-- Reset-LocalVm.ps1 +|-- .gitignore +|-- unattend\unattend.xml.template +|-- oem\Provision-UiTestVm.ps1 +`-- shared\ +``` + +Copy `vm.config.example.psd1` to `vm.config.psd1` and set the VM name, storage paths, resources, and +`ProcessorArchitecture`. The configuration never contains a password. + +## 2. Save the administrator credential first + +[Step 0](#0-human-only-host-setup-one-command) does this for you. The equivalent by hand, when you +want to rotate the password or stage it separately: + +`New-UiTestVm.ps1` reads the guest administrator password from a DPAPI-protected file so it never +appears in a command line, a configuration file, or a chat prompt. Type it directly into the prompt. + +```pwsh +$credentialRoot = Join-Path $env:LOCALAPPDATA 'PowerToysUiTestVm' +New-Item $credentialRoot -ItemType Directory -Force | Out-Null +Get-Credential -UserName PTAdmin -Message 'Local UI-test VM administrator' | + Export-Clixml (Join-Path $credentialRoot 'admin.credential.xml') +``` + +The file decrypts only for the same Windows user on the same host. + +## 3. Get Windows media + +```pwsh +# Validate media you already have. +pwsh .github\skills\ui-tests-local-vm\scripts\Get-WindowsMedia.ps1 ` + -Source Local -Path D:\media\Win11_25H2_English_x64.iso + +# Windows 11 (x64 or arm64). +pwsh .github\skills\ui-tests-local-vm\scripts\Get-WindowsMedia.ps1 ` + -Source Fido -Windows 11 -Architecture arm64 -DestinationRoot D:\media + +# Windows 10 for the second guest. Fido automates Microsoft's mobile-user-agent download page; +# the resulting file is hosted by software.download.prss.microsoft.com. +pwsh .github\skills\ui-tests-local-vm\scripts\Get-WindowsMedia.ps1 ` + -Source Fido -Windows 10 -Architecture x64 -DestinationRoot D:\media +``` + +| Source | Use it for | +|---|---| +| `Local` | An ISO you already downloaded. Reports the SHA-256 so a team can pin one baseline. | +| `Url` | A pinned Microsoft Evaluation Center link. Enterprise/LTSC evaluations live here. | +| `Fido` | Official retail links resolved through the GPL-3.0 helper used by Rufus. Covers **Windows 10 and 11**, and is the only public route that also resolves arm64 Windows 11. | + +### Which Windows 10 image + +The two public Microsoft routes are both valid but neither is current enough for this repository: + +| Official route | Image currently produced | Notes | +|---|---|---| +| Microsoft ISO page (mobile user agent), automated by Fido | `Win10_22H2_English_x64v1.iso`, **19045.2965** (May 2023) | Smallest automation surface; direct Microsoft CDN | +| Microsoft Media Creation Tool | **19045.3803** (December 2023 service refresh) | Tool requires UAC and interactive choices | + +.NET 10 needs Windows 10 **1904x.5007 or newer** for complete CET support. Either public image by +itself aborts with `0x80131506` / `Your Windows doesn't fully support CET`. The primary path is +therefore Microsoft media plus the answer file's supported Windows Setup `DynamicUpdate=true`, which +fetches the current cumulative update during installation before the first baseline. The VM needs a +network switch for this (the default `Default Switch` does). + +`Initialize-LocalVmHost.ps1` verifies the installed UBR before accepting the baseline. If Dynamic +Update could not reach 5007, it runs `Update-LocalVmGuest.ps1` as a fallback, handles reboots, and +recreates the baseline. Do not capture a Win10 baseline below that floor. + +Windows 10 **Enterprise LTSC 2021** (build 19044) remains the stricter baseline named in the guest-OS +policy. Its old Evaluation Center page is no longer a dependable public download route; use licensed +Microsoft 365 / Visual Studio subscription media when available, then let Dynamic Update apply the +same CET-floor validation. Record the edition, ISO hash, and installed full build in every run. + +The `Fido` source downloads the helper from a pinned tag and refuses to run it unless its SHA-256 +matches the value pinned in the script. Upstream publishes no Authenticode-signed script, so review +the upstream diff and update the tag and hash together when raising the pin. Fido is never vendored +into this repository. + +A prepared, generalized VHDX is not supported by this script: it always installs from media so that +Setup owns the disk layout and the boot configuration. + +## 4. Create the guest + +[Step 0](#0-human-only-host-setup-one-command) invokes this script for you. Call it directly when you +want `-ListImages`, `-PlanOnly`, or to rebuild an existing guest with `-Force`. + +The scaffold files are copies and can become stale when the skill is updated. Prefer the step-0 +helper, which refreshes them and executes the **source template** directly. If you intentionally run +the copied `X:\PowerToysUiTestVm\New-UiTestVm.ps1`, refresh first with +`Initialize-LocalVm.ps1 -DestinationRoot X:\PowerToysUiTestVm -Force`. + +```pwsh +# Inspect what the media contains. +pwsh .\New-UiTestVm.ps1 -InstallMedia D:\media\Win11_25H2_English_Arm64_v2.iso -ListImages + +# Build the guest. +pwsh .\New-UiTestVm.ps1 -InstallMedia D:\media\Win11_25H2_English_Arm64_v2.iso -ImageName 'Windows 11 Pro' +``` + +The script creates an empty virtual disk, generates an answer file, packs it with the OEM payload +into a small ISO, attaches both that and the installation media, and lets **Windows Setup install +from inside the guest**. Run `-PlanOnly` first to check the resolved configuration and confirm the +answer file renders, without touching Hyper-V. + +Do not be tempted to speed this up by applying the image with DISM and running `bcdboot` on the host. +That is what `Convert-WindowsImage` does, but its goal is *native-VHD boot*, so `bcdboot` records +`vhd=[X:]\path\to.vhdx` device references. Inside a virtual machine that file does not exist - the +VHDX is the disk - and the guest dies with `0xc000000e` before writing a single log line. It cannot +be repaired from the host either: `bcdedit` resolves drive letters through the host's view and +rewrites them straight back into `vhd=` references. + +Several answer-file details are derived from [Rufus](https://github.com/pbatard/rufus) (GPL-3.0, +`src/wue.c`), which solves the same problem for USB media: + +| Setting | Why it matters | +|---|---| +| `` | Setup rejects the answer file without a product key element, even an empty one. | +| `HideOnlineAccountScreens` + a local account | Skips the Microsoft-account wall. Preferred over the deprecated `SkipMachineOOBE`/`SkipUserOOBE`, which Microsoft warns can leave OOBE in an unexpected state. | +| Base64-obfuscated passwords | Windows appends the element name to the password before base64-encoding UTF-16LE, so no plaintext password reaches the media. | +| `PreventDeviceEncryption`, `TCGSecurityActivationDisabled` | The guest has a virtual TPM, so Windows 11 would otherwise silently BitLocker-encrypt the disk and make it unreadable offline. | +| `BypassNRO` in specialize | Removes the online-account requirement during OOBE. | + +The script also presses Enter on the guest's virtual keyboard through `Msvm_Keyboard` while Setup +starts, because installation media waits for "Press any key to boot from CD or DVD" and nothing +types it in an automated VM. + +When provisioning finishes the script detaches both optical drives, deletes the generated answer ISO, +and takes the `provisioned-baseline` checkpoint. Provisioning creates `PTUser`, removes it from +Administrators, grants it the work root, configures console auto-logon, and disables sleep. It does +**not** enable remoting or open any port: the control channel needs neither. + +`Set-UiTestAutoLogon.ps1` validates each generated PTUser credential with `LogonUser`, stores it as +the protected LSA `DefaultPassword` secret, and removes the readable Winlogon `DefaultPassword` and +finite `AutoLogonCount` values. The count in the unattended answer is only a bootstrap until OEM +provisioning replaces the administrator login with persistent PTUser `ForceAutoLogon`. +`Stop-LocalVm.ps1` revalidates and preserves that credential before a cold shutdown, so PTUser's +DPAPI-protected profile data remains decryptable. `Start-LocalVm.ps1` uses the same helper for a +one-time repair when no PTUser Explorer session appears; a new credential is generated only when +the account has no valid protected secret. Updating only the Winlogon registry identity while +leaving an older LSA password produces a bad-password console logon. + +Watch progress at any time without VMConnect: + +```pwsh +pwsh ..\..\scripts\Get-VmConsoleImage.ps1 -VmName PowerToysUiTest-Win11 -Path X:\evidence\console.png +``` + +## 5. Confirm the desktop baseline + +Provisioning registers a logon task that sets the interactive desktop to 1920x1080 through +`ChangeDisplaySettings`, because display settings belong to the interactive session and cannot be +applied from the PowerShell Direct session. No manual step is needed; verify it instead: + +```pwsh +pwsh ..\..\scripts\Get-VmConsoleImage.ps1 -VmName PowerToysUiTest-Win11 -Path X:\evidence\desktop.png +``` + +The controller's own probe is the authoritative check - it fails the run unless the interactive user +is the configured standard user, is not an administrator, has a session ID above zero, has Explorer +running, can reach the guest exchange, and matches the requested resolution. + +If you open the console interactively with `vmconnect.exe localhost "PowerToysUiTest-Win11"`, turn +**off** enhanced session mode in the View menu: it opens a second session and can displace the +console session where the standard user is logged on. + +Re-take the baseline whenever you change the guest in a way later runs should inherit: + +```pwsh +pwsh .\Reset-LocalVm.ps1 -CreateBaseline +``` + +## 6. Run tests + +```pwsh +pwsh .github\skills\ui-tests-local-vm\scripts\Invoke-LocalVmUiTest.ps1 ` + -VmName PowerToysUiTest-Win11 ` + -VmRoot X:\PowerToysUiTestVm ` + -ExchangeRoot X:\PowerToysUiTestVm\shared\PowerToysUiTests\MyModule ` + -TestExecutable MyModule.UITests.Next.exe ` + -Filter 'Name=MyModule.FocusedTest' ` + -Platform ARM64 ` + -BuildLabel (git rev-parse HEAD) ` + -ReuseStagedPayload +``` + +Use `-Platform ARM64` for an ARM64 guest. The value reaches the tests as the `platform` environment +variable, where `VisualAssert` builds baseline filenames from it (`__ARM64.png`) and any +non-empty value makes the framework consider itself in a pipeline. It is restricted to the names CI +uses - `x64Win10`, `x64Win11`, `ARM64` - because an unrecognised value resolves no baseline and fails +silently rather than loudly. + +The controller creates the guest exchange, grants `PTUser` access to it, copies only the archives +whose hash changed, writes the request, probes the interactive desktop, dispatches the shared guest +runner as a limited interactive scheduled task, streams progress, copies the evidence back to +`\LocalVmResults\`, and removes the guest copy of that run folder. + +Payloads move with `Copy-VMFile` over the Guest Service Interface, measured at ~82 MB/s. The +PowerShell Direct session copy is the fallback only: it manages ~17 MB/s and stalls outright on +archives approaching a gigabyte. + +## 6a. Shell-extension modules: sign the payload before packaging + +Modules with a modern Windows 11 context menu (Image Resizer, PowerRename, File Locksmith, New+) +register a sparse MSIX at module-enable time, which requires a signature chaining to a trusted root. +An unsigned package fails `0x800B0100` and the menu never appears - the tests then fail with +messages like "Explorer did not show the 'Resize with Image Resizer' command". + +Sign at **packaging** time, not after deployment. The guest runner extracts the product and runs the +tests in one step, so there is no point in between where the extracted `.msix` could be signed; a +post-deployment signing step costs an extra full run every time the product archive changes. + +```pwsh +# 1. Host: sign the staged product tree without trusting anything on the build machine. +.\.pipelines\signSparsePackages.ps1 ` + -PackageRoot X:\PowerToysUiTestPayload\product ` + -SkipLocalTrust -ExportCertificatePath X:\PowerToysUiTestPayload\pt-test-signer.cer + +# 2. Guest, once per VM: trust the exported public certificate. +pwsh .github\skills\ui-tests-local-vm\scripts\Invoke-GuestScript.ps1 ` + -VmName PowerToysUiTest-Win11 ` + -ScriptBlock { + foreach ($store in 'Cert:\LocalMachine\Root', 'Cert:\LocalMachine\TrustedPeople') { + Import-Certificate -FilePath C:\PowerToysUiTestTools\pt-test-signer.cer -CertStoreLocation $store + } + } +``` + +Then zip the product tree as usual. Every later re-stage carries signed packages, and the trust +anchor lives only inside the disposable guest. The certificate is valid for a year, so step 2 is not +repeated. See [shell-extensions-and-signing.md](shell-extensions-and-signing.md) for why signing - +rather than driving the classic menu - is the faithful fix. + +Inspect guest state at any time over the same channel: + +```pwsh +pwsh .github\skills\ui-tests-local-vm\scripts\Invoke-GuestScript.ps1 ` + -VmName PowerToysUiTest-Win11 ` + -ScriptBlock { Get-Process explorer | Select-Object Id, SessionId } +``` + +## 7. Baselines and resets + +```pwsh +pwsh .\Reset-LocalVm.ps1 -List # show checkpoints +pwsh .\Reset-LocalVm.ps1 -Restore -StartAfterRestore # back to the clean baseline +pwsh .\Reset-LocalVm.ps1 -CreateBaseline -CheckpointName 'webview2-installed' +``` + +Standard checkpoints include memory, so restoring returns to the captured desktop rather than a cold +boot. Use a restored checkpoint, not a long-lived mutated guest, for any clean-profile claim. + +`Stop-LocalVm.ps1 -Save` saves state instead of shutting down when you want the next run to resume +instantly. + +## Security notes + +- No inbound listener, no published port, and no certificate exist. The control channel is VMBus and + is reachable only by a local administrator on this host. +- Auto-logon necessarily stores a recoverable password inside the guest. Treat the guest as an + isolated test machine and never reuse either account elsewhere. +- Keep `vm.config.psd1`, the guest disk, checkpoints, and the credential file out of source control. + The scaffold's `.gitignore` already excludes them. diff --git a/.github/skills/ui-tests-local-vm/references/shell-extensions-and-signing.md b/.github/skills/ui-tests-local-vm/references/shell-extensions-and-signing.md new file mode 100644 index 0000000000..cc378d1413 --- /dev/null +++ b/.github/skills/ui-tests-local-vm/references/shell-extensions-and-signing.md @@ -0,0 +1,164 @@ +# Shell extensions & the CI signing constraint + +Read this before writing or verifying UI tests for any module with a **shell extension** +(context menu, preview handler, thumbnail provider, drag-drop handler). It is the knowledge that is +*not* obvious from the test framework and caused the most trial-and-error. + +## The one fact that matters most + +**CI PR-validation builds are UNSIGNED** (`codeSign:false`). Any test that depends on a +**sparse-MSIX-packaged** shell extension gets **0% on CI**, because the package cannot register +(`0x800B0100 TRUST_E_NOSIGNATURE`). A test that passes on your machine (where you self-signed or +installed a signed build) can therefore fail 100% on CI. + +## Preferred fix: sign the MSIX on CI and force-trust it + +The workarounds below (driving the classic menu, launching the exe directly) let a test pass on an +unsigned build, but they *do not exercise the modern Win11 tier-1 context menu* — the surface real +users see. The faithful fix is to give CI a genuinely **signed** package plus a **test-only trusted +root**, so registration succeeds and the tests drive the real end-user workflow. This is legitimate +because the trust anchor is scoped to the test agent and asserts no security — it just makes Windows +treat the CI-built package as sideload-installable, exactly like a developer self-signing locally. + +**Why signing (not Developer Mode) is required.** PowerToys registers each sparse package at +module-enable time with `PackageManager.AddPackageByUriAsync` (`src/common/utils/package.h` +`RegisterSparsePackage`) — a *packaged* deployment that demands a signature chaining to a trusted +root. Developer Mode / register-by-loose-manifest would only help if the product code called +`AddPackage -Register AppxManifest.xml`, which it does not. So the only route is: **sign the `.msix` +and trust the signer.** + +**Mechanism** (all three steps must happen *before* the module is enabled): + +1. Create a self-signed **code-signing** cert whose subject **exactly equals** the manifest + `Publisher` — every PowerToys context-menu package and the CmdPal `PowerToysSparse.msix` use + `CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US`. The private + key is generated on the agent and never leaves it; nothing is committed. +2. **Force-trust** it via the **machine** stores: import the public cert into `LocalMachine\Root` + **and** `LocalMachine\TrustedPeople` (a self-signed leaf is its own root, and AppX sideload + consults TrustedPeople). These import silently, and the CI test agent is elevated (it installs + machine-level), so it can write them. Do **not** import into `CurrentUser\Root` — the user Root + store raises a CryptoAPI consent dialog that fails non-interactively (`UI is not allowed in this + operation`), even when elevated. `CurrentUser\TrustedPeople` is silent and fine as an extra for + per-user deployment; a non-elevated run that cannot write `LocalMachine\Root` cannot establish + machine root trust silently. +3. `signtool sign /fd SHA256` every sparse `.msix` the product will register. + +A ready-to-use, publisher-aware implementation ships with this skill: +[`.pipelines/signSparsePackages.ps1`](../../../../.pipelines/signSparsePackages.ps1). It reads each +package's manifest publisher, mints/reuses+trusts a matching cert, and signs only packages that are +not already validly signed (so real framework packages like VCLibs are left alone). Point it at +whichever tree hosts the packages: + +```powershell +# buildNow (run-in-place) — sign the packages in the downloaded build tree: +.\.pipelines\signSparsePackages.ps1 -PackageRoot "$(Pipeline.Workspace)\$(TestArtifactsName)" + +# installed (buildNowSlim / official) — sign after install, before the test enables the module. +# Machine install lands in %ProgramFiles%\PowerToys; per-user install in %LOCALAPPDATA%\PowerToys: +.\.pipelines\signSparsePackages.ps1 ` + -PackageRoot "$env:ProgramFiles\PowerToys","$env:LOCALAPPDATA\PowerToys" ` + -RequiredPackage 'ImageResizerContextMenuPackage.msix' + +# local UI-test VM sideload — sign the deployed runtime: +.\.pipelines\signSparsePackages.ps1 -PackageRoot "C:\PowerToysUiTestRun\PowerToys" +``` + +**Where it is wired in CI.** This runs in `.pipelines/v2/templates/job-test-project.yml` after the +download/install steps and before **Run UI Tests**. It recursively searches the run-in-place artifact +and complete machine/per-user install roots. Windows 11/ARM64 Image Resizer and all-module jobs pass +`-RequiredPackage ImageResizerContextMenuPackage.msix`, so missing, unsigned, or untrusted setup fails +at the prerequisite instead of surfacing later as a product-test failure. Jobs that do not exercise +Image Resizer keep signing best-effort because their suites can guard unavailable modern packages: + +```yaml + - pwsh: | + $roots = @( + "$(Pipeline.Workspace)\$(TestArtifactsName)", + "$env:ProgramFiles\PowerToys", + "$env:LOCALAPPDATA\PowerToys") + if ($requiresImageResizer) { + & "$(build.sourcesdirectory)\.pipelines\signSparsePackages.ps1" ` + -PackageRoot $roots -RequiredPackage 'ImageResizerContextMenuPackage.msix' + } else { + try { & "$(build.sourcesdirectory)\.pipelines\signSparsePackages.ps1" -PackageRoot $roots } + catch { Write-Host "##vso[task.logissue type=warning]Sparse MSIX signing skipped: $($_.Exception.Message)" } + } + displayName: "Sign sparse MSIX packages (test trust)" +``` + +**Prerequisite:** `signtool.exe`. The script finds it across PATH, any `Windows Kits` install (all +versions, plus the App Certification Kit), and a restored SDK BuildTools NuGet package; as a last +resort it fetches the public `Microsoft.Windows.SDK.BuildTools` package from nuget.org, so an agent +without the SDK still works given outbound access. Verified end-to-end in a local Win11 +VM — the unsigned package fails `Add-AppxPackage` / `AddPackageByUriAsync` with `0x800B0100`, and +after `signSparsePackages.ps1` signs it and the cert is force-trusted (`LocalMachine\Root` + +`TrustedPeople`) the same registration succeeds and the package appears in `Get-AppxPackage`. + +**Caveat — CmdPal at install time.** The installer's custom action stages/registers +`PowerToysSparse.msix` *during* install (`installer/PowerToysSetupCustomActionsVNext/CustomAction.cpp`), +before any test-time signing step runs. Signing after install still covers every module that +registers at **enable** time (ImageResizer / PowerRename / FileLocksmith / NewPlus). If CmdPal's own +packaged registration is the thing under test on an installed build, the package must instead be +signed at **build** time (self-sign in the build stage and publish the public `.cer` for the test +stage to trust) — the run-in-place `buildNow` path avoids this because nothing registers until the +test enables it. + +With this in place a test can drive the modern surface directly on CI. `ModernRegistered()` (below) +becomes a portability guard for *unsigned* environments rather than a reason to avoid the modern menu. + +## Two shell-extension tiers + +| Tier | Mechanism | Signing | Unsigned CI PR build | +|---|---|---|---| +| **Modern** (Win11 tier-1 context menu, `IExplorerCommand`) | sparse **MSIX** package | **required** | ❌ cannot register | +| **Classic** ("Show more options", Win10 default menu, most preview/thumbnail handlers) | **registry COM** (`HKCU\Software\Classes\...\SystemFileAssociations\\ShellEx\...`) | none | ✅ works | + +**Rule:** you have two options on an unsigned CI build. **(A, preferred)** sign the modern package +and force-trust it (see *Preferred fix* above) so the test drives the real Win11 tier-1 menu. +**(B, fallback)** drive the **signing-free surface** — the classic COM menu, or launch the module exe +directly with the files (the PowerRename pattern; the exe often has a CLI/`FilesArgument`). If you +take the fallback, only assert the modern/tier-1 surface when the package is *actually* registered, +so it runs on signed/official/installed builds only: + +```csharp +private static bool ModernRegistered() => + new Windows.Management.Deployment.PackageManager() + .FindPackagesForUser(string.Empty) + .Any(p => p.Id.Name.Contains("", StringComparison.OrdinalIgnoreCase)); +``` + +Then: `OpenContextMenu(useClassicMenu: !ModernRegistered())`, and gate modern assertions behind +`if (ModernRegistered())`. + +## Debug vs Release — why local != CI + +- The classic registry-COM handler is usually gated `#if defined(ENABLE_REGISTRATION) || defined(NDEBUG)`, + so it is **compiled out of local Debug builds** and present only in CI **Release** (`NDEBUG`). To + exercise the classic menu against a **local Debug** runtime, rebuild the extension DLL with + `ENABLE_REGISTRATION` added to its ``. +- The sparse `.msix` in build output is **unsigned**; registering it locally needs a self-signed cert + whose subject == the package `Publisher` **and** that cert trusted (admin). CI does neither. +- Both handlers typically **self-gate on the module's enabled flag** at query time (classic + `QueryContextMenu` returns `E_FAIL`, modern `GetState` returns `ECS_HIDDEN`), so the entry tracks + the Settings toggle without re-registration. +- Modules register handlers at **enable time** (runtime), and an **already-running Explorer will not + surface a freshly-registered handler until the shell restarts** — restart `explorer.exe` once after + enabling (see PreviewPane / File Explorer add-ons tests). + +## Reproduce CI's classic scenario on a local (signed) VM + +1. Rebuild the extension DLL with `ENABLE_REGISTRATION` and deploy it into the guest runtime + (`C:\PowerToysUiTestRun\PowerToys\WinUI3Apps\`). +2. Neutralize the sparse package so `enable()` cannot register it: rename its `.msix` and + `Get-AppxPackage ** | Remove-AppxPackage -AllUsers`. This mirrors CI's unsigned failure. +3. The `ModernRegistered()` detection now returns false → the tests drive the classic menu exactly as + CI does. Use `Invoke-GuestScript.ps1` for the guest-side steps. + +## Slow-agent / cross-arch robustness + +Shell-extension tests are especially prone to slow-agent and ARM64-only races that you often cannot +reproduce on a local VM (even constrained to 1 core, see customization.md — you cannot emulate ARM64 +on an x64 host, so reason from the failure video/screenshot). The robustness patterns — re-select +before every attempt, retryable transient popups, verify fixtures reached disk, and slow-path +timeouts — are test design and live with the rest of the Explorer/shell test guidance in +[ui-tests-migration explorer-shell-tests.md](../../ui-tests-migration/references/explorer-shell-tests.md). diff --git a/.github/skills/ui-tests-local-vm/references/troubleshooting.md b/.github/skills/ui-tests-local-vm/references/troubleshooting.md new file mode 100644 index 0000000000..9269aeee9f --- /dev/null +++ b/.github/skills/ui-tests-local-vm/references/troubleshooting.md @@ -0,0 +1,104 @@ +# Troubleshooting local VM UI tests + +Classify the first failed boundary before changing test code. + +## Host and guest lifecycle + +| Symptom | Boundary | Action | +|---|---|---| +| `Get-VM` / `New-PSSession -VMName` fails with `You do not have the required permission` | Host Hyper-V access | Rerun from an elevated PowerShell 7 terminal, or add the account to the local `Hyper-V Administrators` group (one-time elevated change, effective after signing out and back in). Creating a guest still needs full elevation because it partitions and mounts disks. | +| `Mount-VHD` fails `0x80070522`, or `Initialize-Disk`/`Get-WindowsImage` is denied | Guest creation without elevation | Group membership is not enough for disk and image APIs. Run `New-UiTestVm.ps1` from a genuinely elevated terminal. Report `BLOCKED` instead of looking for a workaround. | +| Hyper-V operations hang at 0% CPU, `vmms`/`vmwp` never return, and even `Get-VM` blocks | VHDX on a Dev Drive | Move `VhdPath`/`VmPath` to NTFS; the exchange can stay where it is. Observed on one host and fixed by the move - not a property of ReFS, which Hyper-V supports. `New-UiTestVm.ps1` refuses ReFS by default as a proxy for Dev Drive; `-AllowReFsVolume` overrides. Recovery usually needs a `vmms` restart or a host reboot; wrap suspect Hyper-V calls in `Start-Job` + `Wait-Job -Timeout` so a wedged service does not hang the agent. | +| Guest boots to `0xc000000e` after applying an image on the host | Native-VHD boot entries | Do not `bcdboot` a mounted VHDX from the host: the BCD keeps `vhd=[X:]\...` device references that only resolve in the host's drive view. Create the guest by running Windows Setup inside the VM from an answer-file ISO, which is what `New-UiTestVm.ps1` does. | +| Guest boots to Setup instead of the desktop | Answer file was not applied | Confirm the disk was built by `New-UiTestVm.ps1` rather than attached from an unprepared image, and read the guest's `C:\Windows\Panther\setupact.log`. | +| Setup shows a cancel prompt, or stops around 10% | Key injection overshoot | Installation media waits for "Press any key to boot from CD or DVD", so the script types Enter through `Msvm_Keyboard` - but only until the framebuffer brightens, and at most a bounded number of times. Do not send unbounded keystrokes; later Enters land on Setup's Cancel button. | +| Guest cleanly shuts down about hourly; System event 1074 names `wlms.exe` | Expired Windows evaluation | Check `slmgr.vbs /dlv` or `SoftwareLicensingProduct`. Do not bypass licensing enforcement. Recreate the VM with current evaluation media or a properly licensed Windows image. The controller blocks expired time-based evaluations before test dispatch. | +| Console shows a second, empty session | Enhanced session mode | Turn enhanced session off in the VMConnect View menu. It opens an RDP session that displaces the console session where the standard user is logged on. | +| Guest disk grows without bound | Accumulated checkpoints | `Reset-LocalVm.ps1 -List`, then remove obsolete checkpoints. Budget at least twice `DiskSizeGB` plus `MemoryStartupGB` per standard checkpoint. | + +## Control channel and desktop + +| Symptom | Boundary | Action | +|---|---|---| +| `New-PSSession -VMName` fails with a logon error | Control account/DPAPI file | Recreate the credential file with `Get-Credential \| Export-Clixml`, typed directly into the prompt. DPAPI files do not roam between host users or machines. | +| `New-PSSession -VMName` reports the guest is not ready | Guest still booting, or PowerShell Direct disabled | Read the console with `Get-VmConsoleImage.ps1`. PowerShell Direct needs the guest running and the Hyper-V integration services enabled; it does not need networking. | +| `Copy-VMFile` fails `The Guest Service Interface is not enabled` | Integration service off | `Enable-VMIntegrationService -VMName -Name 'Guest Service Interface'`. Without it, the controller falls back to the much slower session copy. | +| A large archive copy stalls near completion | Session-copy fallback on a big file | `Copy-Item -ToSession` stalls on archives approaching a gigabyte. Confirm `Copy-VMFile` is being used; run with `-Verbose` to see why it fell back. | +| Desktop probe times out | No logged-on standard user | Read the console image, verify `PTUser` is the active console user, Explorer is running, and the scheduled task uses `Interactive`/`Limited`. Refresh the scaffold and use the current stop/start scripts: `Set-UiTestAutoLogon.ps1` must update the protected LSA secret and remove stale Winlogon password/count values. | +| Probe says user is administrator | Wrong account/baseline | Remove the test user from Administrators and log on again. Do not accept `RunLevel=Limited` as proof when UAC is disabled; inspect the token as the probe does. | +| Probe reports wrong dimensions | Resolution task did not run | Provisioning registers a logon task that calls `ChangeDisplaySettings` in the interactive session; check `C:\PowerToysUiTestRun\set-resolution.json`. Display settings cannot be applied from the PowerShell Direct session. Use zero for both desktop parameters only for nonvisual tests. | + +## Run dispatch and evidence + +| Symptom | Boundary | Action | +|---|---|---| +| No `status.json` but the task ended | Guest runner/finalization | Inspect scheduled-task `LastTaskResult`, the guest-local transcript, and the request path. A completed UI is not a completion signal. | +| Interactive `powershell.exe` task stays `Running`, but a local `cmd.exe` probe writes immediately | PTUser PowerShell task host | Stop and unregister only the failed task. Stage and extract payloads through the administrator session, then run a guest-local `.cmd` as an `Interactive`/`Limited` PTUser task. Write the exit code and TRX locally and export one evidence archive afterwards. | +| `status.json` exists but is temporarily empty | Create/write race | Wait for parseable JSON with matching `RunId`; never finish on file existence alone. The controller already does this. | +| One attachment subtree fails export | Transient copy failure | Inspect `ExportErrors`. The shared runner uses bounded `robocopy` retries for directories and writes status even when an artifact cannot be copied. | +| Zero tests/MTP exit 8 | Filter | Qualify the filter with `Name=`, `Name~`, `FullyQualifiedName~`, or `TestCategory=`. Treat as `BLOCKED`. | +| Test process exits 0 but TRX has skipped/`NotExecuted` tests | Incomplete suite | Treat the run as `FAIL`. The controller and guest runner require `total > 0` and `executed == total`; inspect inconclusive messages and restore missing prerequisites instead of accepting the process exit code. | +| Reuse reports a missing manifest | First run or cleaned work root | Run once without `-ReuseStagedPayload`, then reuse. A recreated guest necessarily needs a full first stage. | +| Changed archive is not refreshed | Hash/request mismatch | Compare request SHA-256 values with the actual archives and inspect `RefreshedComponents`. Do not compare only apphost EXE hashes. | + +## Test behavior in the VM + +| Symptom | Boundary | Action | +|---|---|---| +| A legitimate winappcli UIA call is killed after 60 seconds on a resource-limited guest | Per-call process guard | The local-VM runner sets `WINAPP_CLI_INVOKE_TIMEOUT_SECONDS=180`. Increase it only for a measured slow guest call; accepted values are 1-3600 seconds, and command-specific `-t`/`--timeout` plus grace still takes precedence. | +| Visual baselines are never found, or the run behaves unexpectedly like CI | `-Platform` value | `-Platform` flows to the guest as `platform`, names baselines (`__.png`), and any non-empty value marks the run as pipeline-like. Use only `x64Win10`, `x64Win11`, or `ARM64`. | +| Win11 tier-1 command is absent and the module log reports MSIX registration error `0x800B0100` | Unsigned local context-menu package | Sign the local MSIX with a test certificate whose subject matches the manifest publisher, import only its public certificate into the guest machine `TrustedPeople` and `Root` stores, and verify `Get-AuthenticodeSignature` reports `Valid`. Sign at packaging time - see [setup.md](setup.md), step 6a. A successful classic COM registration does not validate the modern menu. | +| Windows Search or another shell surface owns foreground | Persistent desktop state | Dismiss/reset the shell state or restart the VM before rerunning. Classify as environment when the test is already stable in CI. | +| A fixture/helper console owns foreground while Explorer cannot become stable | Activating helper launch | Inspect the failure PNG/MP4 and `GetForegroundWindowInfo()` first. If the foreground PID is the fixture, make it non-activating from creation; do not loosen Explorer's foreground assertion. An Explorer-opened `.cmd` can create a console despite `start /b`, and hiding the first enumerated window is racy. Use a direct `CreateNoWindow` child when integrity permits, or a hidden medium-integrity launcher such as `WScript.Shell.Run(..., 0, False)`, then verify no main window/foreground ownership. | +| Exact-HWND foreground check fails, but PNG shows the target usable (or foreground is the same process under a new HWND / zero) | Foreground requirement is broader than the interaction | Check what happens next. Keep strict foreground for Explorer menus, SendInput, coordinates, and drags. For coordinate-free UIA search/invoke, focus can be best-effort: bind readiness to the live process/window and authoritative UIA element, and retain foreground details as diagnostics. | +| WebView/Monaco stays loading | WebView2/runtime/profile | Verify the baseline WebView2 version or stage the signed installer for the run. Preserve WebView logs and screenshots. | +| Remote debugger cannot connect | Firewall/monitor identity | Verify `msvsmon` is running in the guest and that the guest is reachable on the chosen adapter. See [customization.md](customization.md). | +| Tests run but some fail only in this VM | Profile/display/foreground/environment | Preserve TRX and media, report pass rate and failure groups, and compare guest user/session/display with CI. Do not edit stabilized tests unless asked. | +| VM state hides a first-run defect | Retained profile/cache | Restore the baseline checkpoint with `Reset-LocalVm.ps1 -Restore`, or rebuild the guest. | + +## Host diagnostics + +```pwsh +Get-VM PowerToysUiTest-Win11 | Format-List Name, State, Status, Uptime, ProcessorCount, MemoryAssigned +Get-VMIntegrationService -VMName PowerToysUiTest-Win11 | Select-Object Name, Enabled, PrimaryStatusDescription +Get-VMSnapshot -VMName PowerToysUiTest-Win11 | Select-Object Name, SnapshotType, CreationTime +(Get-Volume -DriveLetter C).FileSystemType # NTFS expected for VhdPath/VmPath +pwsh .github\skills\ui-tests-local-vm\scripts\Get-VmConsoleImage.ps1 ` + -VmName PowerToysUiTest-Win11 -Path X:\evidence\console.png +``` + +If a Hyper-V call may be wedged, bound it rather than blocking the agent: + +```pwsh +$job = Start-Job { Get-VM } +if (-not (Wait-Job $job -Timeout 30)) { 'BLOCKED: VMMS is not responding' } +``` + +## Guest control diagnostics + +Use the administrator DPAPI credential over PowerShell Direct: + +```pwsh +pwsh .github\skills\ui-tests-local-vm\scripts\Invoke-GuestScript.ps1 ` + -VmName PowerToysUiTest-Win11 ` + -ScriptBlock { + Get-ScheduledTask -TaskName 'PowerToysUiTest-*' -ErrorAction SilentlyContinue | + Select-Object TaskName, State, @{n='User';e={$_.Principal.UserId}}, @{n='RunLevel';e={$_.Principal.RunLevel}} + query user + Get-CimInstance Win32_Process -Filter "Name='explorer.exe'" | Select-Object ProcessId, SessionId + } +``` + +Do not launch UI tests directly from that session: it is not the interactive desktop. Use the limited +interactive scheduled task created by the controller. + +## Guest-local evidence before termination + +If a run appears hung, use the administrator session only to copy diagnostics into the result folder. +Do not kill Explorer or the test host until process state, foreground details, and the live transcript +are preserved. Let the guest runner's `finally` write status whenever possible. + +## Cleanup + +The controller unregisters its scheduled tasks. Stop the VM with `Stop-LocalVm.ps1`; delete the guest +disk only when destroying the baseline is intentional. Preserve run folders before resetting. diff --git a/.github/skills/ui-tests-local-vm/scripts/Get-VmConsoleImage.ps1 b/.github/skills/ui-tests-local-vm/scripts/Get-VmConsoleImage.ps1 new file mode 100644 index 0000000000..7095e8d361 --- /dev/null +++ b/.github/skills/ui-tests-local-vm/scripts/Get-VmConsoleImage.ps1 @@ -0,0 +1,95 @@ +# Copyright (c) Microsoft Corporation +# The Microsoft Corporation licenses this file to you under the MIT license. +# See the LICENSE file in the project root for more information. + +<# +.SYNOPSIS +Saves the Hyper-V guest console as a PNG so it can be read without VMConnect. + +.DESCRIPTION +A Hyper-V guest console is normally only visible through VMConnect, which an agent cannot read. The +hypervisor exposes the framebuffer through +Msvm_VirtualSystemManagementService.GetVirtualSystemThumbnailImage, which is enough to read boot +errors, Setup progress, and whether the expected desktop is on screen. + +The thumbnail is RGB565; this converts it to PNG. Requires Hyper-V access on the host. + +.EXAMPLE +pwsh ./Get-VmConsoleImage.ps1 -VmName PowerToysUiTest-Win11 -Path X:\evidence\console.png +#> + +[CmdletBinding()] +param( + [Parameter(Mandatory)][string]$VmName, + [Parameter(Mandatory)][string]$Path, + [ValidateRange(64, 1920)][int]$Width = 1024, + [ValidateRange(64, 1200)][int]$Height = 768 +) + +$ErrorActionPreference = 'Stop' + +$namespace = 'root\virtualization\v2' +$service = Get-CimInstance -Namespace $namespace -ClassName Msvm_VirtualSystemManagementService +$system = Get-CimInstance -Namespace $namespace -ClassName Msvm_ComputerSystem -Filter "ElementName='$VmName'" +if ($null -eq $system) { + throw "Virtual machine '$VmName' was not found." +} +$settings = Get-CimAssociatedInstance -InputObject $system -ResultClassName Msvm_VirtualSystemSettingData | + Where-Object { $_.VirtualSystemType -eq 'Microsoft:Hyper-V:System:Realized' } | + Select-Object -First 1 + +$result = Invoke-CimMethod -InputObject $service -MethodName GetVirtualSystemThumbnailImage -Arguments @{ + TargetSystem = [ciminstance]$settings + WidthPixels = [uint16]$Width + HeightPixels = [uint16]$Height +} +if ($result.ReturnValue -ne 0) { + throw "GetVirtualSystemThumbnailImage failed with return value $($result.ReturnValue)." +} +$rgb565 = $result.ImageData +if ($null -eq $rgb565 -or $rgb565.Length -eq 0) { + throw "The hypervisor returned an empty thumbnail for '$VmName'. The guest is probably off." +} + +Add-Type -AssemblyName System.Drawing +$bitmap = [System.Drawing.Bitmap]::new($Width, $Height, [System.Drawing.Imaging.PixelFormat]::Format24bppRgb) +try { + $data = $bitmap.LockBits( + [System.Drawing.Rectangle]::new(0, 0, $Width, $Height), + [System.Drawing.Imaging.ImageLockMode]::WriteOnly, + [System.Drawing.Imaging.PixelFormat]::Format24bppRgb) + try { + $row = [byte[]]::new($data.Stride) + for ($y = 0; $y -lt $Height; $y++) { + for ($x = 0; $x -lt $Width; $x++) { + $index = (($y * $Width) + $x) * 2 + if ($index + 1 -ge $rgb565.Length) { break } + $pixel = [int]$rgb565[$index] -bor ([int]$rgb565[$index + 1] -shl 8) + $offset = $x * 3 + # 24bpp bitmaps are stored blue, green, red. + $row[$offset] = [byte]((($pixel -band 0x1F) * 255) / 31) + $row[$offset + 1] = [byte](((($pixel -shr 5) -band 0x3F) * 255) / 63) + $row[$offset + 2] = [byte](((($pixel -shr 11) -band 0x1F) * 255) / 31) + } + [Runtime.InteropServices.Marshal]::Copy( + $row, 0, [IntPtr]($data.Scan0.ToInt64() + ($y * $data.Stride)), $data.Stride) + } + } + finally { + $bitmap.UnlockBits($data) + } + + New-Item (Split-Path $Path -Parent) -ItemType Directory -Force | Out-Null + $bitmap.Save($Path, [System.Drawing.Imaging.ImageFormat]::Png) +} +finally { + $bitmap.Dispose() +} + +[pscustomobject]@{ + VmName = $VmName + Path = (Resolve-Path $Path).Path + Width = $Width + Height = $Height + Bytes = (Get-Item $Path).Length +} | ConvertTo-Json diff --git a/.github/skills/ui-tests-local-vm/scripts/Get-WindowsMedia.ps1 b/.github/skills/ui-tests-local-vm/scripts/Get-WindowsMedia.ps1 new file mode 100644 index 0000000000..189ef7fcca --- /dev/null +++ b/.github/skills/ui-tests-local-vm/scripts/Get-WindowsMedia.ps1 @@ -0,0 +1,186 @@ +# Copyright (c) Microsoft Corporation +# The Microsoft Corporation licenses this file to you under the MIT license. +# See the LICENSE file in the project root for more information. + +<# +.SYNOPSIS +Obtains Windows installation media for the local UI-test guest from a public Microsoft source. + +.DESCRIPTION +Three sources are supported: + + Local Validate an ISO you already have and report its SHA-256. This is the default. + Url Download a pinned Microsoft URL, such as an Evaluation Center link, and verify its hash. + Fido Resolve an official Microsoft retail ISO link with Fido, the GPL-3.0 download helper used + by Rufus. Fido is fetched from a pinned tag and refused unless its SHA-256 matches the + hash pinned below, because upstream does not publish an Authenticode-signed script. Fido + is the only public route that also resolves arm64 Windows 11 media. It is downloaded on + demand and never vendored into this repository. + +The script never bypasses hash verification. If verification fails it stops and tells you to obtain +the media manually. + +.EXAMPLE +pwsh ./Get-WindowsMedia.ps1 -Source Fido -Windows 11 -Edition Pro -Architecture arm64 -UrlOnly + +.EXAMPLE +pwsh ./Get-WindowsMedia.ps1 -Source Fido -Windows 11 -Edition Pro -DestinationRoot D:\media + +.EXAMPLE +pwsh ./Get-WindowsMedia.ps1 -Source Local -Path D:\media\Win11_24H2_English_x64.iso +#> + +[CmdletBinding()] +param( + [ValidateSet('Fido', 'Url', 'Local')] + [string]$Source = 'Local', + [string]$DestinationRoot = (Join-Path $env:LOCALAPPDATA 'PowerToysUiTestVm-Media'), + + [string]$Windows = '11', + [string]$Release = 'Latest', + [string]$Edition, + [string]$Language = 'English', + [ValidateSet('x64', 'arm64')] + [string]$Architecture, + + [string]$Url, + [string]$Path, + [string]$ExpectedSha256, + + # Pin the helper. Review the script, then update both values together, before raising the tag. + [string]$FidoTag = 'v1.70', + [string]$FidoSha256 = '24C86067FA399D2FD75EF0693A2EC79CA8DB162827F808CAAC03541CBF640C13', + [switch]$UrlOnly +) + +$ErrorActionPreference = 'Stop' + +if ($PSVersionTable.PSVersion.Major -lt 7) { + throw 'Run this script with PowerShell 7 (pwsh).' +} + +if ([string]::IsNullOrWhiteSpace($Architecture)) { + $Architecture = if ($env:PROCESSOR_ARCHITECTURE -eq 'ARM64') { 'arm64' } else { 'x64' } +} + +function Save-LargeFile { + param( + [Parameter(Mandatory)][string]$Uri, + [Parameter(Mandatory)][string]$Destination + ) + + New-Item (Split-Path $Destination -Parent) -ItemType Directory -Force | Out-Null + $bits = Get-Command Start-BitsTransfer -ErrorAction SilentlyContinue + if ($null -ne $bits) { + Start-BitsTransfer -Source $Uri -Destination $Destination -Description 'Windows media' + return + } + Invoke-WebRequest -Uri $Uri -OutFile $Destination +} + +function Get-MediaResult { + param( + [Parameter(Mandatory)][string]$IsoPath, + [string]$ResolvedFrom, + [string]$ResolvedHost + ) + + $item = Get-Item $IsoPath + $hash = (Get-FileHash $IsoPath -Algorithm SHA256).Hash + if (-not [string]::IsNullOrWhiteSpace($ExpectedSha256) -and $hash -ne $ExpectedSha256.ToUpperInvariant()) { + throw "SHA-256 mismatch for $IsoPath. Expected $ExpectedSha256 but found $hash." + } + return [pscustomobject]@{ + Path = $item.FullName + SizeGB = [math]::Round($item.Length / 1GB, 2) + Sha256 = $hash + Source = $ResolvedFrom + ResolvedHost = $ResolvedHost + Architecture = $Architecture + } +} + +switch ($Source) { + 'Local' { + if ([string]::IsNullOrWhiteSpace($Path) -or -not (Test-Path $Path -PathType Leaf)) { + throw 'Specify an existing ISO with -Path when using -Source Local.' + } + Get-MediaResult -IsoPath $Path -ResolvedFrom 'Local' | ConvertTo-Json + return + } + + 'Url' { + if ([string]::IsNullOrWhiteSpace($Url)) { + throw 'Specify -Url when using -Source Url.' + } + if ($UrlOnly) { + [pscustomobject]@{ Url = $Url; Architecture = $Architecture } | ConvertTo-Json + return + } + $fileName = [IO.Path]::GetFileName(([uri]$Url).AbsolutePath) + if ([string]::IsNullOrWhiteSpace($fileName)) { + $fileName = 'windows-media.iso' + } + $destination = Join-Path $DestinationRoot $fileName + Write-Host "Downloading $fileName..." + Save-LargeFile -Uri $Url -Destination $destination + Get-MediaResult -IsoPath $destination -ResolvedFrom 'Url' -ResolvedHost ([uri]$Url).DnsSafeHost | ConvertTo-Json + return + } +} + +$fidoRoot = Join-Path $DestinationRoot "fido-$FidoTag" +$fidoPath = Join-Path $fidoRoot 'Fido.ps1' +if (-not (Test-Path $fidoPath -PathType Leaf)) { + New-Item $fidoRoot -ItemType Directory -Force | Out-Null + $fidoUri = "https://raw.githubusercontent.com/pbatard/Fido/$FidoTag/Fido.ps1" + Write-Host "Downloading the Fido helper from the pinned tag $FidoTag..." + Invoke-WebRequest -Uri $fidoUri -OutFile $fidoPath +} + +$signature = Get-AuthenticodeSignature $fidoPath +$fidoHash = (Get-FileHash $fidoPath -Algorithm SHA256).Hash +if ($fidoHash -ne $FidoSha256.ToUpperInvariant()) { + Remove-Item $fidoPath -Force -ErrorAction SilentlyContinue + throw "BLOCKED: the Fido helper at tag $FidoTag hashed $fidoHash instead of the pinned $FidoSha256. Review the upstream change and pass -FidoSha256 deliberately, or download Windows media manually from the Microsoft Evaluation Center." +} +Write-Host "Fido $FidoTag verified by SHA-256 (Authenticode status: $($signature.Status))." + +$fidoArguments = @( + '-NoLogo', '-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', $fidoPath, + '-Win', $Windows, '-Rel', $Release, '-Lang', $Language, '-Arch', $Architecture, '-GetUrl' +) +if (-not [string]::IsNullOrWhiteSpace($Edition)) { + $fidoArguments += @('-Ed', $Edition) +} + +# Fido targets Windows PowerShell and instantiates WinForms types when it is not in command-line mode. +$fidoOutput = & powershell.exe @fidoArguments 2>&1 +if ($LASTEXITCODE -ne 0) { + throw "Fido failed with exit code $LASTEXITCODE. $($fidoOutput | Out-String)" +} +$resolvedUrl = @($fidoOutput | Where-Object { $_ -match '^https://' }) | Select-Object -Last 1 +if ([string]::IsNullOrWhiteSpace($resolvedUrl)) { + throw "Fido did not return a download URL. $($fidoOutput | Out-String)" +} +$resolvedUri = [uri]$resolvedUrl +$resolvedHost = $resolvedUri.DnsSafeHost.ToLowerInvariant() +if ($resolvedHost -ne 'microsoft.com' -and -not $resolvedHost.EndsWith('.microsoft.com', [StringComparison]::Ordinal)) { + throw "BLOCKED: the mobile-user-agent resolver returned non-Microsoft host '$resolvedHost'. Refusing to download $resolvedUrl" +} + +if ($UrlOnly) { + [pscustomobject]@{ + Url = $resolvedUrl + ResolvedHost = $resolvedHost + Architecture = $Architecture + FidoTag = $FidoTag + } | ConvertTo-Json + return +} + +$fileName = [IO.Path]::GetFileName(([uri]$resolvedUrl).AbsolutePath) +$destination = Join-Path $DestinationRoot $fileName +Write-Host "Downloading $fileName (several GB)..." +Save-LargeFile -Uri $resolvedUrl -Destination $destination +Get-MediaResult -IsoPath $destination -ResolvedFrom "Microsoft ISO page via verified Fido $FidoTag" -ResolvedHost $resolvedHost | ConvertTo-Json diff --git a/.github/skills/ui-tests-local-vm/scripts/Initialize-LocalVm.ps1 b/.github/skills/ui-tests-local-vm/scripts/Initialize-LocalVm.ps1 new file mode 100644 index 0000000000..466c512ed7 --- /dev/null +++ b/.github/skills/ui-tests-local-vm/scripts/Initialize-LocalVm.ps1 @@ -0,0 +1,66 @@ +# Copyright (c) Microsoft Corporation +# The Microsoft Corporation licenses this file to you under the MIT license. +# See the LICENSE file in the project root for more information. + +<# +.SYNOPSIS +Scaffolds a local Hyper-V UI-test VM directory for persistent PowerToys UI-test execution. + +.DESCRIPTION +Copies the Hyper-V VM lifecycle scripts, the unattend template, and the OEM provisioning payload +into a working directory. Everything runs on the platform hypervisor, so no nested virtualization is +needed and the scaffold works on x64 and on Windows on ARM alike. + +.EXAMPLE +pwsh ./Initialize-LocalVm.ps1 -DestinationRoot X:\PowerToysUiTestVm +#> + +[CmdletBinding(SupportsShouldProcess)] +param( + [Parameter(Mandatory)] + [string]$DestinationRoot, + [switch]$Force +) + +$ErrorActionPreference = 'Stop' + +if ($PSVersionTable.PSVersion.Major -lt 7) { + throw 'Run this script with PowerShell 7 (pwsh).' +} + +$templateRoot = [IO.Path]::GetFullPath((Join-Path $PSScriptRoot '..\templates\vm')) +$oemTemplateRoot = [IO.Path]::GetFullPath((Join-Path $PSScriptRoot '..\templates\oem')) +$destination = [IO.Path]::GetFullPath($DestinationRoot) +if (-not (Test-Path $templateRoot -PathType Container)) { + throw "VM templates were not found: $templateRoot" +} +if (-not (Test-Path $oemTemplateRoot -PathType Container)) { + throw "OEM templates were not found: $oemTemplateRoot" +} + +if (Test-Path $destination -PathType Container) { + $existingItems = @(Get-ChildItem $destination -Force) + if ($existingItems.Count -gt 0 -and -not $Force) { + throw "Destination is not empty: $destination. Pass -Force to merge and overwrite template files." + } +} + +if ($PSCmdlet.ShouldProcess($destination, 'Scaffold the local Hyper-V UI-test VM')) { + New-Item $destination -ItemType Directory -Force | Out-Null + Copy-Item (Join-Path $templateRoot '*') $destination -Recurse -Force + New-Item (Join-Path $destination 'oem') -ItemType Directory -Force | Out-Null + Copy-Item (Join-Path $oemTemplateRoot '*') (Join-Path $destination 'oem') -Recurse -Force + New-Item (Join-Path $destination 'shared') -ItemType Directory -Force | Out-Null +} + +[pscustomobject]@{ + VmRoot = $destination + ConfigurationTemplate = (Join-Path $destination 'vm.config.example.psd1') + NextSteps = @( + "Copy vm.config.example.psd1 to vm.config.psd1 and set the VM name, paths, and architecture.", + "Obtain media: pwsh $(Join-Path $PSScriptRoot 'Get-WindowsMedia.ps1') -Source Fido -Windows 11 -Architecture x64 -DestinationRoot $(Join-Path $destination 'media')", + "HUMAN-ONLY, elevated, once: pwsh $(Join-Path $PSScriptRoot 'Initialize-LocalVmHost.ps1') -VmRoot $destination -InstallMedia ", + "It joins Hyper-V Administrators, saves the DPAPI guest credential, and creates the guest - an agent cannot do any of these.", + "Agents: verify with -CheckOnly and stop until it reports IsReady=true." + ) +} | ConvertTo-Json -Depth 4 diff --git a/.github/skills/ui-tests-local-vm/scripts/Initialize-LocalVmHost.ps1 b/.github/skills/ui-tests-local-vm/scripts/Initialize-LocalVmHost.ps1 new file mode 100644 index 0000000000..9d44b436a0 --- /dev/null +++ b/.github/skills/ui-tests-local-vm/scripts/Initialize-LocalVmHost.ps1 @@ -0,0 +1,418 @@ +# Copyright (c) Microsoft Corporation +# The Microsoft Corporation licenses this file to you under the MIT license. +# See the LICENSE file in the project root for more information. + +<# +.SYNOPSIS +Completes the local UI-test VM host setup - the steps an agent cannot perform itself. + +.DESCRIPTION +Three prerequisites gate every agent-driven run, and all three need a human: + + 1. Hyper-V access Membership in the local Hyper-V Administrators group. Needs elevation, and + only takes effect after signing out and back in. + 2. Guest credential A DPAPI-protected PSCredential for the guest administrator. The password is + typed straight into the prompt so it never reaches a command line, a + configuration file, source control, or a model. + 3. The guest itself New-UiTestVm.ps1 reads the installation media and creates the virtual disk, + which needs an elevated shell. + +Run this once per host from an elevated PowerShell 7 terminal. It reports what is already in place, +performs only what is missing, and is safe to re-run. + +Agents: run it with -CheckOnly (no elevation, changes nothing) and, when it reports NotReady, stop +and ask the user to run the command it prints. Do not attempt to work around it. + +.EXAMPLE +# Human, elevated - the whole setup in one command. +pwsh ./Initialize-LocalVmHost.ps1 -VmRoot C:\PowerToysUiTestVm -InstallMedia C:\media\Win11.iso + +.EXAMPLE +# Agent - observe only. +pwsh ./Initialize-LocalVmHost.ps1 -VmRoot C:\PowerToysUiTestVm -CheckOnly +#> + +[CmdletBinding(SupportsShouldProcess)] +param( + [Parameter(Mandatory)] + [string]$VmRoot, + + [string]$ConfigPath, + [string]$InstallMedia, + [string]$ImageName = 'Windows 11 Pro', + + # Account that will run the tests. Defaults to whoever runs this script. + [string]$Account = "$env:USERDOMAIN\$env:USERNAME", + [string]$AdminUserName, + [string]$CredentialPath = (Join-Path $env:LOCALAPPDATA 'PowerToysUiTestVm\admin.credential.xml'), + [string]$VcRedistUrl, + [string]$PowerShellVersion = '7.6.4', + [string]$PowerShellUrl, + [string]$PowerShellSha256, + + [switch]$CheckOnly, + [switch]$SkipScaffoldRefresh, + [switch]$SkipVcRedist, + [switch]$SkipPowerShell, + [switch]$SkipWindowsUpdate, + [switch]$SkipGroupMembership, + [switch]$SkipCredential, + [switch]$SkipGuestCreation, + [switch]$AllowReFsVolume, + [switch]$Force +) + +$ErrorActionPreference = 'Stop' + +if ($PSVersionTable.PSVersion.Major -lt 7) { + throw 'Run this script with PowerShell 7 (pwsh).' +} + +Import-Module (Join-Path $PSScriptRoot 'LocalVmGuest.psm1') -Force + +$vmRootPath = [IO.Path]::GetFullPath($VmRoot) +if (-not (Test-Path $vmRootPath -PathType Container)) { + throw "VM root was not found: $vmRootPath. Run Initialize-LocalVm.ps1 -DestinationRoot $vmRootPath first." +} + +# Existing scaffolds are copies, so they do not receive skill fixes automatically. Refresh before +# every mutating setup run; vm.config.psd1, media, VHDX files, and extra OEM installers are preserved. +if (-not $CheckOnly -and -not $SkipScaffoldRefresh) { + Write-Host 'Refreshing the VM scaffold from the current skill templates...' + & (Join-Path $PSScriptRoot 'Initialize-LocalVm.ps1') -DestinationRoot $vmRootPath -Force | Out-Null +} + +if ([string]::IsNullOrWhiteSpace($ConfigPath)) { + $ConfigPath = Join-Path $vmRootPath 'vm.config.psd1' +} +if (-not (Test-Path $ConfigPath -PathType Leaf)) { + throw "Configuration was not found: $ConfigPath. Copy vm.config.example.psd1 to vm.config.psd1 and edit it." +} + +$configuration = Import-PowerShellDataFile $ConfigPath +$vmName = [string]$configuration.VmName +if ([string]::IsNullOrWhiteSpace($AdminUserName)) { + $AdminUserName = [string]$configuration.AdminUserName +} + +$vcArchitecture = switch ([string]$configuration.ProcessorArchitecture) { + 'arm64' { 'arm64' } + default { 'x64' } +} +$vcRedistPath = Join-Path $vmRootPath "oem\vc_redist.$vcArchitecture.exe" +$vcRedistReady = if (Test-Path $vcRedistPath -PathType Leaf) { + $existingVcSignature = Get-AuthenticodeSignature $vcRedistPath + $existingVcSignature.Status -eq 'Valid' -and + $null -ne $existingVcSignature.SignerCertificate -and + $existingVcSignature.SignerCertificate.Subject -like 'CN=Microsoft Corporation*' +} +else { + $false +} +$powerShellPath = Join-Path $vmRootPath "oem\PowerShell-$PowerShellVersion-win-$vcArchitecture.msi" +$knownPowerShellHashes = @{ + 'x64' = 'D11942DF52FD12470169797ABFA4781D9480EFDC81000BA4FA55A5B921ED8DD0' + 'arm64' = '9B441D52176BEFD22B3AADF34F2F43F3A6F692C8D0181815169A397236B33D1F' +} +$expectedPowerShellHash = if ([string]::IsNullOrWhiteSpace($PowerShellSha256)) { + if ($PowerShellVersion -ne '7.6.4') { + throw '-PowerShellSha256 is required when overriding the pinned PowerShell version 7.6.4.' + } + $knownPowerShellHashes[$vcArchitecture] +} +else { + $PowerShellSha256.ToUpperInvariant() +} +$powerShellPayloadValid = if (Test-Path $powerShellPath -PathType Leaf) { + $existingHash = (Get-FileHash $powerShellPath -Algorithm SHA256).Hash + $existingSignature = Get-AuthenticodeSignature $powerShellPath + $existingSignerIsMicrosoft = $null -ne $existingSignature.SignerCertificate -and + $existingSignature.SignerCertificate.Subject -like 'CN=Microsoft Corporation*' + $existingHash -eq $expectedPowerShellHash -and + $existingSignature.Status -eq 'Valid' -and + $existingSignerIsMicrosoft +} +else { + $false +} +$powerShellMetadataPath = "$powerShellPath.sha256" +$powerShellMetadataValid = (Test-Path $powerShellMetadataPath -PathType Leaf) -and + ((Get-Content $powerShellMetadataPath -Raw).Trim() -eq $expectedPowerShellHash) +$powerShellReady = $powerShellPayloadValid -and $powerShellMetadataValid + +function Install-PowerShellPayload { + if ($powerShellReady) { + return + } + if ($SkipPowerShell) { + return + } + if ($powerShellPayloadValid) { + Set-Content $powerShellMetadataPath $expectedPowerShellHash -Encoding ascii + $script:powerShellMetadataValid = $true + $script:powerShellReady = $true + Write-Host "Repaired PowerShell payload trust metadata: $powerShellMetadataPath" + return + } + + $url = if ([string]::IsNullOrWhiteSpace($PowerShellUrl)) { + "https://github.com/PowerShell/PowerShell/releases/download/v$PowerShellVersion/PowerShell-$PowerShellVersion-win-$vcArchitecture.msi" + } + else { + $PowerShellUrl + } + + New-Item (Split-Path $powerShellPath -Parent) -ItemType Directory -Force | Out-Null + $temporaryPath = "$powerShellPath.download" + Write-Host "Downloading PowerShell $PowerShellVersion for guest-side test orchestration..." + Invoke-WebRequest -Uri $url -OutFile $temporaryPath + + $actualHash = (Get-FileHash $temporaryPath -Algorithm SHA256).Hash + $signature = Get-AuthenticodeSignature $temporaryPath + $isMicrosoft = $null -ne $signature.SignerCertificate -and + $signature.SignerCertificate.Subject -like 'CN=Microsoft Corporation*' + if ($actualHash -ne $expectedPowerShellHash -or $signature.Status -ne 'Valid' -or -not $isMicrosoft) { + Remove-Item $temporaryPath -Force -ErrorAction SilentlyContinue + throw "Refusing PowerShell payload '$url': sha256=$actualHash, expected=$expectedPowerShellHash, signature=$($signature.Status), signer='$($signature.SignerCertificate.Subject)'." + } + + Move-Item $temporaryPath $powerShellPath -Force + Set-Content $powerShellMetadataPath $expectedPowerShellHash -Encoding ascii + $script:powerShellPayloadValid = $true + $script:powerShellMetadataValid = $true + $script:powerShellReady = $true + Write-Host "Staged verified PowerShell ${PowerShellVersion}: $powerShellPath" +} + +function Install-VcRedistPayload { + if ($vcRedistReady -or $SkipVcRedist) { + return + } + + $url = if ([string]::IsNullOrWhiteSpace($VcRedistUrl)) { + "https://aka.ms/vs/17/release/vc_redist.$vcArchitecture.exe" + } + else { + $VcRedistUrl + } + + New-Item (Split-Path $vcRedistPath -Parent) -ItemType Directory -Force | Out-Null + $temporaryPath = "$vcRedistPath.download" + Write-Host "Downloading the Visual C++ redistributable required for MP4 capture..." + Invoke-WebRequest -Uri $url -OutFile $temporaryPath + + $signature = Get-AuthenticodeSignature $temporaryPath + $isMicrosoft = $null -ne $signature.SignerCertificate -and + $signature.SignerCertificate.Subject -like 'CN=Microsoft Corporation*' + if ($signature.Status -ne 'Valid' -or -not $isMicrosoft) { + Remove-Item $temporaryPath -Force -ErrorAction SilentlyContinue + throw "Refusing VC++ redistributable from '$url': signature=$($signature.Status), signer='$($signature.SignerCertificate.Subject)'." + } + + Move-Item $temporaryPath $vcRedistPath -Force + $script:vcRedistReady = $true + Write-Host "Staged the signed Microsoft redistributable: $vcRedistPath" +} + +function Test-Elevation { + return ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole( + [Security.Principal.WindowsBuiltInRole]::Administrator) +} + +function Write-Status { + param([Parameter(Mandatory)]$Status) + + Write-Host '' + Write-Host "Local UI-test VM host setup - $vmName" + foreach ($row in @( + @{ Name = 'Hyper-V access'; Ok = $Status.HyperVAccess; Detail = $Status.HyperVAccessDetail }, + @{ Name = 'Guest credential'; Ok = $Status.Credential; Detail = $Status.CredentialDetail }, + @{ Name = 'Video prerequisite'; Ok = $vcRedistReady; Detail = $(if ($vcRedistReady) { "ok ($vcArchitecture)" } else { "missing: $vcRedistPath" }) }, + @{ Name = 'PowerShell 7'; Ok = $powerShellReady; Detail = $(if ($powerShellReady) { "ok ($PowerShellVersion)" } else { "missing: $powerShellPath" }) }, + @{ Name = 'Guest'; Ok = $Status.Guest; Detail = $Status.GuestDetail })) { + $mark = if ($row.Ok) { '[ok] ' } else { '[missing]' } + Write-Host (" {0} {1,-17} {2}" -f $mark, $row.Name, $row.Detail) + } + Write-Host '' +} + +$status = Test-LocalVmHostSetup -VmName $vmName -CredentialPath $CredentialPath -AdminUserName $AdminUserName +Write-Status -Status $status + +if ($CheckOnly) { + $allMissing = @($status.Missing) + if (-not $vcRedistReady) { + $allMissing += 'VideoPrerequisite' + } + if (-not $powerShellReady) { + $allMissing += 'PowerShell7' + } + $allReady = $status.IsReady -and $vcRedistReady -and $powerShellReady + + if (-not $allReady) { + $media = if ([string]::IsNullOrWhiteSpace($InstallMedia)) { '' } else { $InstallMedia } + Write-Host (Get-LocalVmSetupMessage ` + -Status $status ` + -VmRoot $vmRootPath ` + -InstallMedia $media ` + -ConfigPath $ConfigPath ` + -CredentialPath $CredentialPath) + } + [pscustomobject]@{ + VmName = $vmName + IsReady = $allReady + Missing = $allMissing + CredentialPath = $status.CredentialPath + VcRedistReady = $vcRedistReady + PowerShellReady = $powerShellReady + } | ConvertTo-Json -Depth 3 + exit ($(if ($allReady) { 0 } else { 1 })) +} + +$elevated = Test-Elevation +$needsElevation = (-not $status.HyperVAccess -and -not $SkipGroupMembership) -or + ((-not $status.Guest -or $Force) -and -not $SkipGuestCreation) +if ($needsElevation -and -not $elevated) { + throw @" +BLOCKED: this run needs an elevated PowerShell 7 terminal. +Missing: $($status.Missing -join ', ') + +Start an elevated pwsh and re-run: + pwsh -File "$PSCommandPath" -VmRoot "$vmRootPath" -ConfigPath "$ConfigPath" -CredentialPath "$CredentialPath"$(if ($InstallMedia) { " -InstallMedia `"$InstallMedia`"" }) +"@ +} + +# 1. Hyper-V access ------------------------------------------------------------------------------- +if (-not $status.HyperVAccess -and -not $SkipGroupMembership) { + $member = $Account + Write-Host "Adding '$member' to the local Hyper-V Administrators group..." + if ($PSCmdlet.ShouldProcess($member, 'Add to Hyper-V Administrators')) { + try { + Add-LocalGroupMember -Group 'Hyper-V Administrators' -Member $member -ErrorAction Stop + Write-Host "Added '$member'." + } + catch [Microsoft.PowerShell.Commands.MemberExistsException] { + Write-Host "'$member' is already a member." + } + } + + Write-Warning @' +Group membership is baked into the logon token, so this session cannot use it yet. +SIGN OUT AND BACK IN, then re-run this script to finish the remaining steps. +'@ + return +} + +# 2. Guest credential ----------------------------------------------------------------------------- +if (-not $status.Credential -and -not $SkipCredential) { + Write-Host "Saving the guest administrator credential for '$AdminUserName'." + Write-Host 'Type the password directly into the prompt. Any password works: it only ever exists' + Write-Host 'inside the disposable guest. Never reuse a real account password here.' + + if ($PSCmdlet.ShouldProcess($CredentialPath, 'Save the DPAPI guest credential')) { + New-Item (Split-Path $CredentialPath -Parent) -ItemType Directory -Force | Out-Null + $credential = Get-Credential -UserName $AdminUserName -Message "Local UI-test VM administrator ($vmName)" + if ($null -eq $credential) { + throw 'No credential was entered.' + } + if (($credential.UserName -replace '^.*\\', '') -ne $AdminUserName) { + throw "The credential must be for '$AdminUserName' to match $ConfigPath." + } + $credential | Export-Clixml $CredentialPath + Write-Host "Saved: $CredentialPath (decryptable only by $env:USERNAME on this host)." + } +} + +# 3. Recording prerequisite ----------------------------------------------------------------------- +Install-VcRedistPayload +Install-PowerShellPayload + +# 4. The guest ------------------------------------------------------------------------------------ +if ((-not $status.Guest -or $Force) -and -not $SkipGuestCreation) { + if ([string]::IsNullOrWhiteSpace($InstallMedia)) { + throw @" +BLOCKED: -InstallMedia is required to create '$vmName'. +Obtain media first, for example: + pwsh "$(Join-Path $PSScriptRoot 'Get-WindowsMedia.ps1')" -Source Fido -Windows 11 -Architecture x64 -DestinationRoot "$(Join-Path $vmRootPath 'media')" +"@ + } + + # Execute the source template, not the scaffold copy. A copied script can be stale after the + # skill is updated (the PowerShell 5.1 readiness-query fix exposed exactly this failure mode). + $newVmScript = [IO.Path]::GetFullPath((Join-Path $PSScriptRoot '..\templates\vm\New-UiTestVm.ps1')) + if (-not (Test-Path $newVmScript -PathType Leaf)) { + throw "New-UiTestVm.ps1 template was not found: $newVmScript" + } + + Write-Host "Creating '$vmName' from $InstallMedia. Windows Setup runs inside the guest; this takes a while and needs no interaction." + $arguments = @{ + ConfigPath = $ConfigPath + InstallMedia = $InstallMedia + ImageName = $ImageName + CredentialPath = $CredentialPath + OemPath = (Join-Path $vmRootPath 'oem') + } + if ($AllowReFsVolume) { $arguments.AllowReFsVolume = $true } + if ($Force) { $arguments.Force = $true } + & $newVmScript @arguments +} + +# Windows Setup Dynamic Update is the primary Win10 servicing path. Verify its result against the +# .NET 10 CET floor (1904x.5007); only then use online Windows Update as a fallback and replace the +# pre-update checkpoint. Windows 11 media does not need this compatibility step. +if (-not $SkipWindowsUpdate -and (Get-VM -Name $vmName -ErrorAction SilentlyContinue)) { + & ([IO.Path]::GetFullPath((Join-Path $PSScriptRoot '..\templates\vm\Start-LocalVm.ps1'))) ` + -ConfigPath $ConfigPath ` + -CredentialPath $CredentialPath ` + -Wait | Out-Null + $credential = Import-Clixml $CredentialPath + $session = New-PSSession -VMName $vmName -Credential $credential + try { + $guestVersion = Invoke-Command -Session $session -ScriptBlock { + $currentVersion = Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion' + [pscustomobject]@{ + Build = [int]$currentVersion.CurrentBuild + Ubr = [int]$currentVersion.UBR + Display = "$($currentVersion.CurrentBuild).$($currentVersion.UBR)" + } + } + } + finally { + Remove-PSSession $session -ErrorAction SilentlyContinue + } + + if ($guestVersion.Build -lt 22000 -and + ($guestVersion.Build -lt 19041 -or $guestVersion.Build -gt 19045 -or $guestVersion.Ubr -lt 5007)) { + Write-Warning "Windows Setup Dynamic Update left '$vmName' at $($guestVersion.Display); .NET 10 needs 1904x.5007 or newer. Falling back to online Windows Update." + & (Join-Path $PSScriptRoot 'Update-LocalVmGuest.ps1') ` + -VmName $vmName ` + -CredentialPath $CredentialPath + + & ([IO.Path]::GetFullPath((Join-Path $PSScriptRoot '..\templates\vm\Reset-LocalVm.ps1'))) ` + -ConfigPath $ConfigPath ` + -CreateBaseline | Out-Null + Write-Host "Recreated '$($configuration.BaselineCheckpointName)' after Windows Update." + } +} + +$final = Test-LocalVmHostSetup -VmName $vmName -CredentialPath $CredentialPath -AdminUserName $AdminUserName +Write-Status -Status $final +$finalMissing = @($final.Missing) +if (-not $vcRedistReady) { $finalMissing += 'VideoPrerequisite' } +if (-not $powerShellReady) { $finalMissing += 'PowerShell7' } +$allReady = $final.IsReady -and $vcRedistReady -and $powerShellReady +if ($allReady) { + Write-Host 'Host setup is complete. The agent can now drive Invoke-LocalVmUiTest.ps1 unattended.' +} +else { + Write-Warning "Still missing: $($finalMissing -join ', '). Re-run this script." +} + +[pscustomobject]@{ + VmName = $vmName + IsReady = $allReady + Missing = $finalMissing + CredentialPath = $final.CredentialPath + VcRedistReady = $vcRedistReady + PowerShellReady = $powerShellReady +} | ConvertTo-Json -Depth 3 diff --git a/.github/skills/ui-tests-local-vm/scripts/Invoke-GuestScript.ps1 b/.github/skills/ui-tests-local-vm/scripts/Invoke-GuestScript.ps1 new file mode 100644 index 0000000000..978f79fa8c --- /dev/null +++ b/.github/skills/ui-tests-local-vm/scripts/Invoke-GuestScript.ps1 @@ -0,0 +1,64 @@ +# Copyright (c) Microsoft Corporation +# The Microsoft Corporation licenses this file to you under the MIT license. +# See the LICENSE file in the project root for more information. + +<# +.SYNOPSIS +Runs a scriptblock inside the local UI-test guest over PowerShell Direct, handling the credential +import and PSSession lifecycle. Token-efficient replacement for the repeated +Import-Clixml / New-PSSession / Invoke-Command / Remove-PSSession boilerplate when inspecting or +mutating guest state (package registration, staged runtime files, registry, processes). + +.PARAMETER ScriptBlock +The scriptblock to run in the guest. Its output is returned to the host. + +.PARAMETER VmName +Name of the Hyper-V virtual machine. Hyper-V access is required: either an elevated shell or +membership in the local Hyper-V Administrators group. + +.EXAMPLE +./Invoke-GuestScript.ps1 -VmName PowerToysUiTest-Win11 -ScriptBlock { + Get-AppxPackage *ImageResizerContextMenu* | Select-Object -Expand Name +} + +.EXAMPLE +./Invoke-GuestScript.ps1 -VmName PowerToysUiTest-Win11 -ScriptBlock { + Get-Process explorer | Select-Object Id, SessionId +} + +.EXAMPLE +# Neutralize a sparse package to reproduce CI's unsigned/classic scenario. +./Invoke-GuestScript.ps1 -VmName PowerToysUiTest-Win11 -ScriptBlock { + Get-AppxPackage -AllUsers *ImageResizerContextMenu* | ForEach-Object { Remove-AppxPackage -Package $_.PackageFullName -AllUsers } + Rename-Item C:\PowerToysUiTestRun\PowerToys\WinUI3Apps\ImageResizerContextMenuPackage.msix -NewName ImageResizerContextMenuPackage.msix.disabled +} +#> +[CmdletBinding()] +param( + [Parameter(Mandatory)][scriptblock]$ScriptBlock, + [Parameter(Mandatory)][string]$VmName, + [object[]]$ArgumentList = @(), + [string]$CredentialPath = (Join-Path $env:LOCALAPPDATA 'PowerToysUiTestVm\admin.credential.xml') +) + +$ErrorActionPreference = 'Stop' +if (-not (Test-Path $CredentialPath)) { + throw "Credential file not found: $CredentialPath. Point -CredentialPath at the VM's admin.credential.xml." +} +$credential = Import-Clixml $CredentialPath + +try { + Import-Module Hyper-V -ErrorAction Stop + Get-VM -ErrorAction Stop | Out-Null +} +catch { + throw 'BLOCKED: Hyper-V is not accessible from this shell. Run from an elevated PowerShell 7 terminal, or add this account to the local "Hyper-V Administrators" group.' +} +$session = New-PSSession -VMName $VmName -Credential $credential + +try { + Invoke-Command -Session $session -ScriptBlock $ScriptBlock -ArgumentList $ArgumentList +} +finally { + Remove-PSSession $session -ErrorAction SilentlyContinue +} diff --git a/.github/skills/ui-tests-local-vm/scripts/Invoke-LocalVmUiTest.ps1 b/.github/skills/ui-tests-local-vm/scripts/Invoke-LocalVmUiTest.ps1 new file mode 100644 index 0000000000..6f5254f704 --- /dev/null +++ b/.github/skills/ui-tests-local-vm/scripts/Invoke-LocalVmUiTest.ps1 @@ -0,0 +1,695 @@ +# Copyright (c) Microsoft Corporation +# The Microsoft Corporation licenses this file to you under the MIT license. +# See the LICENSE file in the project root for more information. + +<# +.SYNOPSIS +Runs PowerToys UITest.Next executables in a persistent local Hyper-V VM. + +.DESCRIPTION +Creates a hash-addressed request, starts or reuses the guest, verifies a non-admin interactive +desktop, dispatches the shared guest runner through Task Scheduler, and returns durable status/TRX +evidence. + +The control channel is PowerShell Direct over VMBus and payloads move with Copy-VMFile, so the guest +needs no listener, no published port, and no network. Hyper-V access is required: either an elevated +shell or membership in the local Hyper-V Administrators group. + +.EXAMPLE +pwsh ./Invoke-LocalVmUiTest.ps1 ` + -VmName PowerToysUiTest-Win10 ` + -VmRoot X:\PowerToysUiTestVm ` + -ExchangeRoot X:\PowerToysUiTestVm\shared\PowerToysUiTests\Peek ` + -TestExecutable Peek.UITests.Next.exe ` + -Filter 'Name=Peek.Preview.PDF' ` + -Platform x64Win10 ` + -BuildLabel (git rev-parse HEAD) ` + -ReuseStagedPayload +#> + +[CmdletBinding()] +param( + [Parameter(Mandatory)] + [ValidateScript({ Test-Path $_ -PathType Container })] + [string]$VmRoot, + + [Parameter(Mandatory)] + [ValidateScript({ Test-Path $_ -PathType Container })] + [string]$ExchangeRoot, + + [Parameter(Mandatory)] + [string[]]$TestExecutable, + + [Parameter(Mandatory)] + [string]$VmName, + + [string]$ConfigurationPath, + [ValidateSet('Default', 'Constrained')] + [string]$ResourceProfile = 'Default', + [string]$Filter, + # Flows to the guest as the 'platform' environment variable. The framework uses it for visual + # baseline filenames (VisualAssert) and treats any non-empty value as "running in a pipeline", + # so it must match the names CI uses or baselines silently fail to resolve. + [ValidateSet('x64Win10', 'x64Win11', 'ARM64')] + [string]$Platform = 'x64Win10', + [string]$BuildLabel = 'local', + [string]$TestsArchive = 'ui-tests.zip', + [string]$ProductArchive = 'powertoys-runtime.zip', + [string]$WinAppCliArchive = 'winappcli.zip', + [string]$DotNetArchive = 'dotnet-runtime.zip', + [string]$ProductOverlayArchive, + [string]$WebView2Installer = 'MicrosoftEdgeWebView2RuntimeInstallerX64.exe', + [string]$SuiteTimeout = '45m', + [string[]]$CleanupProcess = @(), + [ValidateRange(0, 300)] + [int]$OutputHeartbeatSeconds = 15, + [ValidateRange(0, 7680)] + [int]$DesktopWidth = 1920, + [ValidateRange(0, 4320)] + [int]$DesktopHeight = 1080, + [ValidateRange(1, 1440)] + [int]$TimeoutMinutes = 60, + [ValidateRange(1, 120)] + [int]$StartupTimeoutMinutes = 45, + [string]$StandardUser = 'PTUser', + [string]$GuestExchangeRoot = 'C:\PowerToysUiTestExchange', + [string]$CredentialPath, + [string]$GuestRunnerSource = (Join-Path $PSScriptRoot '..\templates\run-ui-tests.ps1'), + [switch]$InstallWebView2, + [switch]$ReuseStagedPayload, + [switch]$SkipStart, + [switch]$StopVmAfterRun, + [switch]$PlanOnly +) + +$ErrorActionPreference = 'Stop' + +if ($PSVersionTable.PSVersion.Major -lt 7) { + throw 'Run this controller with PowerShell 7 (pwsh).' +} +if (($DesktopWidth -eq 0) -ne ($DesktopHeight -eq 0)) { + throw 'Set both DesktopWidth and DesktopHeight to 0 to disable display validation.' +} +$CleanupProcess = @($CleanupProcess | ForEach-Object { $_ -split ',' } | ForEach-Object { $_.Trim() } | Where-Object { $_ }) + +Import-Module (Join-Path $PSScriptRoot 'LocalVmGuest.psm1') -Force + +$controllerName = 'Hyper-V local VM' +$vmRootPath = [IO.Path]::GetFullPath($VmRoot) +if ([string]::IsNullOrWhiteSpace($ConfigurationPath)) { + $ConfigurationPath = Join-Path $vmRootPath 'vm.config.psd1' +} +$configurationPathResolved = [IO.Path]::GetFullPath($ConfigurationPath) +if (-not (Test-Path $configurationPathResolved -PathType Leaf)) { + throw "VM configuration was not found: $configurationPathResolved" +} +$vmConfiguration = Import-PowerShellDataFile $configurationPathResolved +if ([string]$vmConfiguration.VmName -ne $VmName) { + throw "VM configuration '$configurationPathResolved' names '$($vmConfiguration.VmName)', but -VmName is '$VmName'." +} + +if ([string]::IsNullOrWhiteSpace($CredentialPath)) { + $CredentialPath = Join-Path $env:LOCALAPPDATA 'PowerToysUiTestVm\admin.credential.xml' +} + +# Hyper-V access, the guest credential, and the guest itself all need a human. Fail on the whole set +# at once so the user gets one actionable instruction instead of three sequential surprises. +if (-not $PlanOnly) { + $guestAdminUser = [string]$vmConfiguration.AdminUserName + + $hostSetup = Test-LocalVmHostSetup -VmName $VmName -CredentialPath $CredentialPath -AdminUserName $guestAdminUser + if (-not $hostSetup.IsReady) { + throw (Get-LocalVmSetupMessage ` + -Status $hostSetup ` + -VmRoot $VmRoot ` + -ConfigPath $configurationPathResolved ` + -CredentialPath $CredentialPath) + } +} + +$exchangePath = [IO.Path]::GetFullPath($ExchangeRoot) +$guestRunnerSourcePath = [IO.Path]::GetFullPath($GuestRunnerSource) +if (-not (Test-Path $guestRunnerSourcePath -PathType Leaf)) { + throw "Guest runner was not found: $guestRunnerSourcePath" +} + +$guestContext = New-LocalVmContext ` + -VmName $VmName -HostExchangeRoot $exchangePath -GuestExchangeRoot $GuestExchangeRoot +$guestExchangeRoot = $guestContext.GuestExchangeRoot + +function Get-ExchangeFileHash { + param([string]$File) + + if ([string]::IsNullOrWhiteSpace($File)) { + return $null + } + return (Get-FileHash (Join-Path $exchangePath $File) -Algorithm SHA256).Hash +} + +function Get-TrxSummary { + param([Parameter(Mandatory)][string]$ResultRoot) + + $suites = @() + $totals = [ordered]@{ Total = 0; Executed = 0; Passed = 0; Failed = 0; Error = 0; NotExecuted = 0 } + foreach ($trx in Get-ChildItem $ResultRoot -Filter '*.trx' -File -Recurse -ErrorAction SilentlyContinue) { + [xml]$document = Get-Content $trx.FullName -Raw + $counters = $document.TestRun.ResultSummary.Counters + $tests = @($document.TestRun.Results.UnitTestResult | ForEach-Object { + [pscustomobject]@{ + Name = [string]$_.testName + Outcome = [string]$_.outcome + Duration = [string]$_.duration + ErrorMessage = [string]$_.Output.ErrorInfo.Message + } + }) + $suite = [ordered]@{ + File = $trx.FullName + Total = [int]$counters.total + Executed = [int]$counters.executed + Passed = [int]$counters.passed + Failed = [int]$counters.failed + Error = [int]$counters.error + NotExecuted = [int]$counters.notExecuted + Tests = $tests + } + $suites += [pscustomobject]$suite + foreach ($name in @('Total', 'Executed', 'Passed', 'Failed', 'Error', 'NotExecuted')) { + $totals[$name] += $suite[$name] + } + } + return [pscustomobject]@{ Totals = [pscustomobject]$totals; Suites = $suites } +} + +function Start-InteractiveTask { + param( + [Parameter(Mandatory)][System.Management.Automation.Runspaces.PSSession]$Session, + [Parameter(Mandatory)][string]$TaskName, + [Parameter(Mandatory)][string]$Executable, + [Parameter(Mandatory)][string]$Arguments, + [Parameter(Mandatory)][string]$UserName, + [Parameter(Mandatory)][int]$ExecutionTimeLimitMinutes + ) + + return Invoke-Command -Session $Session -ScriptBlock { + param($Name, $FilePath, $ArgumentList, $InteractiveUser, $LimitMinutes) + + $ErrorActionPreference = 'Stop' + Unregister-ScheduledTask -TaskName $Name -Confirm:$false -ErrorAction SilentlyContinue + $action = New-ScheduledTaskAction -Execute $FilePath -Argument $ArgumentList + $principal = New-ScheduledTaskPrincipal ` + -UserId "$env:COMPUTERNAME\$InteractiveUser" ` + -LogonType Interactive -RunLevel Limited + $settings = New-ScheduledTaskSettingsSet ` + -ExecutionTimeLimit (New-TimeSpan -Minutes $LimitMinutes) ` + -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries + $task = New-ScheduledTask -Action $action -Principal $principal -Settings $settings + Register-ScheduledTask -TaskName $Name -InputObject $task -Force | Out-Null + Start-ScheduledTask -TaskName $Name + $registered = Get-ScheduledTask -TaskName $Name + [pscustomobject]@{ + TaskName = $Name + State = [string]$registered.State + UserId = $registered.Principal.UserId + RunLevel = [string]$registered.Principal.RunLevel + } + } -ArgumentList $TaskName, $Executable, $Arguments, $UserName, $ExecutionTimeLimitMinutes +} + +$requiredFiles = @($TestsArchive, $ProductArchive, $WinAppCliArchive, $DotNetArchive) +if (-not [string]::IsNullOrWhiteSpace($ProductOverlayArchive)) { + $requiredFiles += $ProductOverlayArchive +} +if ($InstallWebView2) { + $requiredFiles += $WebView2Installer +} +foreach ($file in $requiredFiles) { + if (-not (Test-Path (Join-Path $exchangePath $file) -PathType Leaf)) { + throw "Required exchange file is missing: $file" + } +} + +$payloadFiles = @($requiredFiles | Sort-Object -Unique) +$payloadHashes = [ordered]@{ + Tests = Get-ExchangeFileHash -File $TestsArchive + Product = Get-ExchangeFileHash -File $ProductArchive + ProductOverlay = Get-ExchangeFileHash -File $ProductOverlayArchive + WinAppCli = Get-ExchangeFileHash -File $WinAppCliArchive + DotNet = Get-ExchangeFileHash -File $DotNetArchive + WebView2Installer = if ($InstallWebView2) { Get-ExchangeFileHash -File $WebView2Installer } else { $null } +} +$fingerprintLines = foreach ($file in $payloadFiles) { + '{0}={1}' -f $file, (Get-ExchangeFileHash -File $file) +} +$sha256 = [Security.Cryptography.SHA256]::Create() +try { + $payloadFingerprint = [Convert]::ToHexString( + $sha256.ComputeHash([Text.Encoding]::UTF8.GetBytes($fingerprintLines -join "`n"))) +} +finally { + $sha256.Dispose() +} + +$runId = 'localvm-{0}-{1}' -f [DateTime]::UtcNow.ToString('yyyyMMdd-HHmmss'), [guid]::NewGuid().ToString('N').Substring(0, 8) +$resultRelative = "LocalVmResults\$runId" +$hostResultRoot = Join-Path $exchangePath $resultRelative +$guestResultRoot = Join-Path $guestExchangeRoot $resultRelative +$requestRelative = Join-Path $resultRelative 'request.json' +$statusRelative = Join-Path $resultRelative 'status.json' +$progressRelative = Join-Path $resultRelative 'progress.json' +$probeScriptRelative = Join-Path $resultRelative 'desktop-probe.ps1' +$probeRelative = Join-Path $resultRelative 'desktop-probe.json' +$requestPath = Join-Path $hostResultRoot 'request.json' +$guestRequestPath = Join-Path $guestResultRoot 'request.json' +$guestProbeScriptPath = Join-Path $guestResultRoot 'desktop-probe.ps1' +$guestProbePath = Join-Path $guestResultRoot 'desktop-probe.json' +$guestRunnerName = 'run-ui-tests.ps1' +$hostRunnerPath = Join-Path $exchangePath $guestRunnerName +$guestRunnerPath = Join-Path $guestExchangeRoot $guestRunnerName + +New-Item $hostResultRoot -ItemType Directory -Force | Out-Null +Copy-Item $guestRunnerSourcePath $hostRunnerPath -Force + +$request = [ordered]@{ + RunId = $runId + Controller = $controllerName + ExchangeRoot = $guestExchangeRoot + BuildLabel = $BuildLabel + TestExecutables = @($TestExecutable) + Filter = $Filter + Platform = $Platform + ResourceProfile = $ResourceProfile + SuiteTimeout = $SuiteTimeout + OutputHeartbeatSeconds = $OutputHeartbeatSeconds + DesktopWidth = $DesktopWidth + DesktopHeight = $DesktopHeight + ReuseStagedPayload = [bool]$ReuseStagedPayload + PayloadFingerprint = $payloadFingerprint + PayloadFiles = $payloadFiles + PayloadHashes = $payloadHashes + Archives = [ordered]@{ + Tests = $TestsArchive + Product = $ProductArchive + WinAppCli = $WinAppCliArchive + DotNet = $DotNetArchive + ProductOverlay = $ProductOverlayArchive + } + WebView2Installer = if ($InstallWebView2) { $WebView2Installer } else { $null } + CleanupProcesses = @($CleanupProcess) +} +$requestJson = $request | ConvertTo-Json -Depth 8 +$requestJson | Set-Content $requestPath -Encoding utf8 + +$plan = [ordered]@{ + Controller = $controllerName + RunId = $runId + VmRoot = $vmRootPath + VmName = $guestContext.VmName + ConfigurationPath = $configurationPathResolved + ResourceProfile = $ResourceProfile + ExchangeRoot = $exchangePath + GuestExchangeRoot = $guestExchangeRoot + GuestRunnerSource = $guestRunnerSourcePath + GuestRequestPath = $guestRequestPath + StandardUser = $StandardUser + ControlChannel = $guestContext.ControlChannel + ReuseStagedPayload = [bool]$ReuseStagedPayload + StopVmAfterRun = [bool]$StopVmAfterRun + PayloadFingerprint = $payloadFingerprint + PayloadHashes = $payloadHashes +} +$plan | ConvertTo-Json -Depth 6 | Set-Content (Join-Path $hostResultRoot 'controller-plan.json') -Encoding utf8 +if ($PlanOnly) { + [pscustomobject]@{ + Status = 'PLAN' + RunId = $runId + ResultsPath = $hostResultRoot + RequestPath = $requestPath + PayloadFingerprint = $payloadFingerprint + } | ConvertTo-Json + return +} + +if (-not (Test-Path $CredentialPath -PathType Leaf)) { + throw "DPAPI credential file was not found: $CredentialPath" +} +$credential = Import-Clixml $CredentialPath +if ($credential -isnot [System.Management.Automation.PSCredential]) { + throw "Credential file does not contain a PSCredential: $CredentialPath" +} + +$session = $null +$evidenceExported = $false +$probeTaskName = "PowerToysUiTest-Probe-$runId" +$testTaskName = "PowerToysUiTest-Run-$runId" +$controllerResult = $null +try { + if (-not $SkipStart) { + $startScript = Join-Path $vmRootPath 'Start-LocalVm.ps1' + if (-not (Test-Path $startScript -PathType Leaf)) { + throw "VM start script was not found: $startScript" + } + $startupOutput = & $startScript ` + -ConfigPath $configurationPathResolved ` + -CredentialPath $CredentialPath ` + -ResourceProfile $ResourceProfile ` + -Wait ` + -TimeoutMinutes $StartupTimeoutMinutes | Out-String + Write-Verbose $startupOutput + } + + $session = New-LocalVmSession ` + -Context $guestContext -Credential $credential -TimeoutMinutes $StartupTimeoutMinutes + + $guestWindowsVersion = Invoke-Command -Session $session -ScriptBlock { + $currentVersion = Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion' + [pscustomobject]@{ + Build = [int]$currentVersion.CurrentBuild + Ubr = [int]$currentVersion.UBR + Display = "$($currentVersion.CurrentBuild).$($currentVersion.UBR)" + } + } + if ($guestWindowsVersion.Build -lt 22000 -and + ($guestWindowsVersion.Build -lt 19041 -or $guestWindowsVersion.Build -gt 19045 -or $guestWindowsVersion.Ubr -lt 5007)) { + throw "BLOCKED: '$VmName' is Windows $($guestWindowsVersion.Display). .NET 10 and PowerShell 7.6 require Windows 10 1904x.5007 or newer for CET. Recreate through Initialize-LocalVmHost.ps1 (Setup Dynamic Update) or run Update-LocalVmGuest.ps1." + } + + $vcArchitecture = if ([string]$vmConfiguration.ProcessorArchitecture -eq 'arm64') { 'arm64' } else { 'x64' } + $vcRuntimePresent = Invoke-Command -Session $session -ScriptBlock { + Test-Path "$env:WINDIR\System32\VCRUNTIME140.dll" -PathType Leaf + } + if (-not $vcRuntimePresent) { + $vcRedistPath = Join-Path $vmRootPath "oem\vc_redist.$vcArchitecture.exe" + if (-not (Test-Path $vcRedistPath -PathType Leaf)) { + throw "BLOCKED: '$VmName' cannot record failure video because VCRUNTIME140.dll is missing, and no repair payload exists at '$vcRedistPath'. Run Initialize-LocalVmHost.ps1 for this VM config." + } + + $vcSignature = Get-AuthenticodeSignature $vcRedistPath + if ($vcSignature.Status -ne 'Valid' -or $vcSignature.SignerCertificate.Subject -notlike 'CN=Microsoft Corporation*') { + throw "BLOCKED: refusing untrusted VC++ redistributable '$vcRedistPath' (status=$($vcSignature.Status))." + } + + Invoke-Command -Session $session -ScriptBlock { + New-Item C:\PowerToysUiTestTools -ItemType Directory -Force | Out-Null + } + $guestVcRedist = 'C:\PowerToysUiTestTools\vc_redist.exe' + Copy-Item $vcRedistPath -Destination $guestVcRedist -ToSession $session -Force + $vcExitCode = Invoke-Command -Session $session -ScriptBlock { + param($Installer) + (Start-Process $Installer -ArgumentList '/install', '/quiet', '/norestart' -Wait -PassThru).ExitCode + } -ArgumentList $guestVcRedist + if ($vcExitCode -notin 0, 1638, 3010 -or -not (Invoke-Command -Session $session -ScriptBlock { Test-Path "$env:WINDIR\System32\VCRUNTIME140.dll" })) { + throw "BLOCKED: Visual C++ redistributable installation failed in '$VmName' (exit=$vcExitCode)." + } + Write-Host "Installed the Visual C++ runtime in '$VmName' for failure-video capture." + } + + $guestPowerShell = 'C:\Program Files\PowerShell\7\pwsh.exe' + $powerShellPresent = Invoke-Command -Session $session -ScriptBlock { + param($Path) + Test-Path $Path -PathType Leaf + } -ArgumentList $guestPowerShell + if (-not $powerShellPresent) { + $powerShellMsi = Get-ChildItem (Join-Path $vmRootPath 'oem') ` + -Filter "PowerShell-*-win-$vcArchitecture.msi" -File | + Where-Object { Test-Path "$($_.FullName).sha256" -PathType Leaf } | + Sort-Object Name -Descending | Select-Object -First 1 + if ($null -eq $powerShellMsi) { + throw "BLOCKED: PowerShell 7 is missing in '$VmName', and no verified repair MSI exists under '$(Join-Path $vmRootPath 'oem')'. Run Initialize-LocalVmHost.ps1 for this VM config." + } + $expectedPowerShellHash = (Get-Content "$($powerShellMsi.FullName).sha256" -Raw).Trim() + $actualPowerShellHash = (Get-FileHash $powerShellMsi.FullName -Algorithm SHA256).Hash + $powerShellSignature = Get-AuthenticodeSignature $powerShellMsi.FullName + if ($actualPowerShellHash -ne $expectedPowerShellHash -or + $powerShellSignature.Status -ne 'Valid' -or + $powerShellSignature.SignerCertificate.Subject -notlike 'CN=Microsoft Corporation*') { + throw "BLOCKED: refusing unverified PowerShell MSI '$($powerShellMsi.FullName)' (sha256=$actualPowerShellHash, expected=$expectedPowerShellHash, status=$($powerShellSignature.Status))." + } + + Invoke-Command -Session $session -ScriptBlock { + New-Item C:\PowerToysUiTestTools -ItemType Directory -Force | Out-Null + } + $guestPowerShellMsi = 'C:\PowerToysUiTestTools\PowerShell.msi' + Copy-Item $powerShellMsi.FullName -Destination $guestPowerShellMsi -ToSession $session -Force + $powerShellExitCode = Invoke-Command -Session $session -ScriptBlock { + param($Installer) + (Start-Process msiexec.exe -ArgumentList @( + '/i', $Installer, '/qn', '/norestart', + 'ADD_PATH=1', 'REGISTER_MANIFEST=1', + 'ENABLE_PSREMOTING=0', 'USE_MU=0', 'ENABLE_MU=0') -Wait -PassThru).ExitCode + } -ArgumentList $guestPowerShellMsi + if ($powerShellExitCode -notin 0, 1638, 3010 -or -not (Invoke-Command -Session $session -ScriptBlock { + param($Path) + Test-Path $Path -PathType Leaf + } -ArgumentList $guestPowerShell)) { + throw "BLOCKED: PowerShell 7 installation failed in '$VmName' (exit=$powerShellExitCode)." + } + Write-Host "Installed PowerShell 7 in '$VmName' for guest-side test orchestration." + } + + Initialize-GuestExchange -Context $guestContext -Session $session -StandardUser $StandardUser + $stagedFiles = @(Copy-ToGuest ` + -Context $guestContext -Session $session -FileName (@($guestRunnerName) + $payloadFiles)) + if ($stagedFiles.Count -gt 0) { + Write-Host "Staged into the guest: $($stagedFiles -join ', ')" + } + Write-GuestText ` + -Context $guestContext -Session $session -RelativePath $requestRelative -Value $requestJson + + $controlIdentity = Invoke-Command -Session $session -ScriptBlock { + $identity = [Security.Principal.WindowsIdentity]::GetCurrent() + $principal = [Security.Principal.WindowsPrincipal]$identity + $windowsApplicationId = '55c92734-d682-4d71-983e-d6ec3f16059f' + $windowsLicense = Get-CimInstance SoftwareLicensingProduct -ErrorAction SilentlyContinue | + Where-Object { + $_.ApplicationID -eq $windowsApplicationId -and + -not [string]::IsNullOrWhiteSpace($_.PartialProductKey) -and + $_.Name -like 'Windows*' + } | + Select-Object -First 1 + [pscustomobject]@{ + User = $identity.Name + IsAdministrator = $principal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator) + WindowsLicenseDescription = [string]$windowsLicense.Description + WindowsLicenseStatus = [int]$windowsLicense.LicenseStatus + WindowsGracePeriodMinutes = [int]$windowsLicense.GracePeriodRemaining + } + } + if (-not $controlIdentity.IsAdministrator) { + throw "The control identity '$($controlIdentity.User)' is not an administrator." + } + if ($controlIdentity.WindowsLicenseDescription.Contains('TIMEBASED_EVAL', [StringComparison]::OrdinalIgnoreCase) -and + ([int]$controlIdentity.WindowsLicenseStatus -eq 5 -or [int]$controlIdentity.WindowsGracePeriodMinutes -le 0)) { + throw 'The Windows evaluation period has expired. The guest will shut down hourly; replace it with current evaluation media or a properly licensed baseline before running UI tests.' + } + + $escapedProbePath = $guestProbePath.Replace("'", "''") + $escapedExchangeRoot = $guestExchangeRoot.Replace("'", "''") + $probeScript = @" +`$identity = [Security.Principal.WindowsIdentity]::GetCurrent() +`$principal = [Security.Principal.WindowsPrincipal]`$identity +`$sessionId = (Get-Process -Id `$PID).SessionId +Add-Type -AssemblyName System.Windows.Forms +[ordered]@{ + User = `$identity.Name + SessionId = `$sessionId + IsAdministrator = `$principal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator) + ExplorerCount = @(Get-Process explorer -ErrorAction SilentlyContinue | Where-Object SessionId -eq `$sessionId).Count + DesktopWidth = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds.Width + DesktopHeight = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds.Height + ExchangeAccessible = Test-Path '$escapedExchangeRoot' +} | ConvertTo-Json | Set-Content '$escapedProbePath' -Encoding utf8 +"@ + Write-GuestText ` + -Context $guestContext -Session $session -RelativePath $probeScriptRelative -Value $probeScript + $probeArguments = '-NoLogo -NoProfile -ExecutionPolicy Bypass -File "{0}"' -f $guestProbeScriptPath + $probeTask = Start-InteractiveTask ` + -Session $session -TaskName $probeTaskName ` + -Executable $guestPowerShell -Arguments $probeArguments ` + -UserName $StandardUser -ExecutionTimeLimitMinutes 2 + Write-Host "Desktop probe task: $($probeTask.TaskName), user $($probeTask.UserId)" + + $probeDeadline = [DateTime]::UtcNow.AddMinutes(2) + do { + $desktopProbe = Read-GuestJson ` + -Context $guestContext -Session $session -RelativePath $probeRelative -Attempts 3 + if ($null -ne $desktopProbe) { + break + } + if ([DateTime]::UtcNow -ge $probeDeadline) { + $probeTaskInfo = Invoke-Command -Session $session -ScriptBlock { + param($Name) + $task = Get-ScheduledTask -TaskName $Name -ErrorAction SilentlyContinue + $info = Get-ScheduledTaskInfo -TaskName $Name -ErrorAction SilentlyContinue + [pscustomobject]@{ State = [string]$task.State; LastTaskResult = $info.LastTaskResult } + } -ArgumentList $probeTaskName + throw "Interactive desktop probe did not complete. Task state: $($probeTaskInfo.State); result: $($probeTaskInfo.LastTaskResult)." + } + Start-Sleep -Seconds 1 + } while ($true) + + if ($desktopProbe.IsAdministrator) { + throw "Interactive test user '$($desktopProbe.User)' is an administrator." + } + if (-not $desktopProbe.User.EndsWith("\$StandardUser", [StringComparison]::OrdinalIgnoreCase)) { + throw "Interactive task ran as '$($desktopProbe.User)', expected '$StandardUser'." + } + if ([int]$desktopProbe.SessionId -le 0 -or [int]$desktopProbe.ExplorerCount -le 0) { + throw "No interactive Explorer desktop is available for '$StandardUser'." + } + if (-not $desktopProbe.ExchangeAccessible) { + throw "The interactive user cannot access '$guestExchangeRoot'." + } + if ($DesktopWidth -ne 0 -and + ([int]$desktopProbe.DesktopWidth -ne $DesktopWidth -or [int]$desktopProbe.DesktopHeight -ne $DesktopHeight)) { + throw "Guest desktop is $($desktopProbe.DesktopWidth)x$($desktopProbe.DesktopHeight); expected ${DesktopWidth}x${DesktopHeight}." + } + + $runnerArguments = '-NoLogo -NoProfile -WindowStyle Hidden -ExecutionPolicy Bypass -File "{0}" -RequestPath "{1}"' -f $guestRunnerPath, $guestRequestPath + $taskLimitMinutes = [Math]::Min(1440, $TimeoutMinutes + 5) + $testTask = Start-InteractiveTask ` + -Session $session -TaskName $testTaskName ` + -Executable $guestPowerShell -Arguments $runnerArguments ` + -UserName $StandardUser -ExecutionTimeLimitMinutes $taskLimitMinutes + Write-Host "UI-test task: $($testTask.TaskName), user $($testTask.UserId)" + + $deadline = [DateTime]::UtcNow.AddMinutes($TimeoutMinutes) + $lastProgress = $null + $status = $null + do { + $progress = Read-GuestJson ` + -Context $guestContext -Session $session -RelativePath $progressRelative + if ($null -ne $progress) { + $progressKey = "$($progress.Stage):$($progress.Detail)" + if ($progressKey -ne $lastProgress) { + Write-Host "[$($progress.Stage)] $($progress.Detail)" + $lastProgress = $progressKey + } + } + $candidate = Read-GuestJson ` + -Context $guestContext -Session $session -RelativePath $statusRelative + if ($null -ne $candidate -and $candidate.RunId -eq $runId) { + $status = $candidate + break + } + if ([DateTime]::UtcNow -ge $deadline) { + # Absorb a status file that was still being created when the deadline elapsed. + $candidate = Read-GuestJson ` + -Context $guestContext -Session $session -RelativePath $statusRelative -Attempts 20 + if ($null -ne $candidate -and $candidate.RunId -eq $runId) { + $status = $candidate + break + } + $taskInfo = Invoke-Command -Session $session -ScriptBlock { + param($Name) + $task = Get-ScheduledTask -TaskName $Name -ErrorAction SilentlyContinue + $info = Get-ScheduledTaskInfo -TaskName $Name -ErrorAction SilentlyContinue + [pscustomobject]@{ State = [string]$task.State; LastTaskResult = $info.LastTaskResult } + } -ArgumentList $testTaskName + throw "Local VM UI-test run timed out. Task state: $($taskInfo.State); result: $($taskInfo.LastTaskResult)." + } + Start-Sleep -Seconds 1 + } while ($true) + + Copy-FromGuest -Context $guestContext -Session $session -RelativePath $resultRelative + $evidenceExported = $true + + $trx = Get-TrxSummary -ResultRoot $hostResultRoot + $nonPassingTests = @($trx.Suites | ForEach-Object { $_.Tests } | Where-Object { $_.Outcome -ne 'Passed' }) + $effectiveExitCode = [int]$status.ExitCode + $effectiveStatus = [string]$status.Status + if ($trx.Suites.Count -eq 0 -or + $trx.Totals.Total -eq 0 -or + $trx.Totals.Executed -ne $trx.Totals.Total -or + $nonPassingTests.Count -gt 0) { + $effectiveStatus = 'FAIL' + if ($effectiveExitCode -eq 0) { + $effectiveExitCode = 1 + } + } + $controllerResult = [pscustomobject]@{ + Controller = $controllerName + RunId = $runId + BuildLabel = $status.BuildLabel + Status = $effectiveStatus + ExitCode = $effectiveExitCode + ResultsPath = $hostResultRoot + ControlUser = $controlIdentity.User + GuestUser = $status.User + GuestSessionId = $status.SessionId + DesktopWidth = $status.DesktopWidth + DesktopHeight = $status.DesktopHeight + ResourceProfile = $ResourceProfile + ReusedStagedPayload = $status.ReusedStagedPayload + RefreshedComponents = $status.RefreshedComponents + ExportErrors = $status.ExportErrors + Tests = $trx.Totals + Failed = @($nonPassingTests | ForEach-Object { + [pscustomobject]@{ + Name = $_.Name + Outcome = $_.Outcome + Duration = $_.Duration + Error = (($_.ErrorMessage -split "`n") | Select-Object -First 1) + } + }) + Suites = $trx.Suites + } +} +finally { + if ($null -ne $session) { + if ($session.State -eq 'Opened') { + if (-not $evidenceExported) { + try { + Copy-FromGuest -Context $guestContext -Session $session -RelativePath $resultRelative + $evidenceExported = $true + } + catch { + Write-Warning "Guest evidence could not be exported: $($_.Exception.Message)" + } + } + if ($evidenceExported) { + try { + Remove-GuestItem -Context $guestContext -Session $session -RelativePath $resultRelative + } + catch { + Write-Warning "The guest run folder could not be removed: $($_.Exception.Message)" + } + } + } + try { + if ($session.State -eq 'Opened') { + Invoke-Command -Session $session -ScriptBlock { + param($ProbeTaskName, $TestTaskName) + foreach ($name in @($ProbeTaskName, $TestTaskName)) { + Unregister-ScheduledTask -TaskName $name -Confirm:$false -ErrorAction SilentlyContinue + } + } -ArgumentList $probeTaskName, $testTaskName -ErrorAction Stop + } + } + catch { + Write-Warning "Scheduled-task cleanup was skipped because the guest session was unavailable: $($_.Exception.Message)" + } + finally { + Remove-PSSession $session -ErrorAction SilentlyContinue + } + } + if ($StopVmAfterRun) { + $stopScript = Join-Path $vmRootPath 'Stop-LocalVm.ps1' + if (Test-Path $stopScript -PathType Leaf) { + try { + & $stopScript ` + -ConfigPath $configurationPathResolved ` + -CredentialPath $CredentialPath | Out-Host + } + catch { + Write-Warning "The requested post-run VM stop failed: $($_.Exception.Message)" + } + } + } +} + +if ($null -ne $controllerResult) { + $controllerResult | ConvertTo-Json -Depth 8 + if ($controllerResult.ExitCode -ne 0) { + exit $controllerResult.ExitCode + } +} diff --git a/.github/skills/ui-tests-local-vm/scripts/LocalVmGuest.psm1 b/.github/skills/ui-tests-local-vm/scripts/LocalVmGuest.psm1 new file mode 100644 index 0000000000..0db4017088 --- /dev/null +++ b/.github/skills/ui-tests-local-vm/scripts/LocalVmGuest.psm1 @@ -0,0 +1,443 @@ +# Copyright (c) Microsoft Corporation +# The Microsoft Corporation licenses this file to you under the MIT license. +# See the LICENSE file in the project root for more information. + +<# +.SYNOPSIS +Guest transport for the local Hyper-V UI-test VM. + +.DESCRIPTION +The control channel is PowerShell Direct over VMBus: no listener, no published port, no certificate, +and no network dependency. Bulk payloads move with Copy-VMFile over the Guest Service Interface, +measured at ~82 MB/s against ~17 MB/s for the PowerShell Direct session copy - and the session copy +stalls outright on archives approaching a gigabyte, so it is only a fallback. + +The exchange is guest-local storage that this module mirrors in both directions, so the host never +shares a folder with the guest. +#> + +Set-StrictMode -Version 3.0 + +$script:DefaultGuestExchangeRoot = 'C:\PowerToysUiTestExchange' + +function Test-HyperVAccess { + <# + .SYNOPSIS + Reports whether this shell can manage Hyper-V. + + .DESCRIPTION + Tests the capability rather than the token shape. Elevation is the usual way to get it, but + membership in the local Hyper-V Administrators group survives UAC filtering and is enough for + Get-VM, Copy-VMFile, and PowerShell Direct. + #> + try { + Import-Module Hyper-V -ErrorAction Stop + Get-VM -ErrorAction Stop | Out-Null + return $true + } + catch { + return $false + } +} + +function Get-HyperVAccessMessage { + return 'BLOCKED: Hyper-V is not accessible from this shell. Run from an elevated PowerShell 7 terminal, or add this account to the local "Hyper-V Administrators" group (a one-time elevated change that takes effect after signing out and back in).' +} + +function Test-LocalVmHostSetup { + <# + .SYNOPSIS + Reports which of the human-only host prerequisites are in place. + + .DESCRIPTION + Three things must exist before any agent-driven run can work, and none of them can be created by + an agent: Hyper-V access for this shell, the DPAPI guest-administrator credential, and the guest + itself. Initialize-LocalVmHost.ps1 performs all three; this function only observes them. + #> + [CmdletBinding()] + param( + [string]$VmName, + [string]$CredentialPath, + [string]$AdminUserName = 'PTAdmin' + ) + + if ([string]::IsNullOrWhiteSpace($CredentialPath)) { + $CredentialPath = Join-Path $env:LOCALAPPDATA 'PowerToysUiTestVm\admin.credential.xml' + } + + $hyperVAccess = Test-HyperVAccess + + $credentialDetail = 'ok' + $credentialReady = $false + if (-not (Test-Path $CredentialPath -PathType Leaf)) { + $credentialDetail = "missing: $CredentialPath" + } + else { + try { + $credential = Import-Clixml $CredentialPath + if ($credential -isnot [pscredential]) { + $credentialDetail = 'file does not contain a PSCredential' + } + else { + $credentialUser = $credential.UserName -replace '^.*\\', '' + if ($credentialUser -ne $AdminUserName) { + $credentialDetail = "stored for '$credentialUser' but the configuration expects '$AdminUserName'" + } + else { + $credentialReady = $true + } + } + } + catch { + # A credential saved by another Windows user or on another host cannot be decrypted here. + $credentialDetail = "unreadable ($($_.Exception.Message))" + } + } + + $guestReady = $false + $guestDetail = 'not checked (no Hyper-V access)' + if ($hyperVAccess -and -not [string]::IsNullOrWhiteSpace($VmName)) { + $guest = Get-VM -Name $VmName -ErrorAction SilentlyContinue + if ($null -eq $guest) { + $guestDetail = "missing: no virtual machine named '$VmName'" + } + else { + $guestReady = $true + $guestDetail = "ok (State=$($guest.State))" + } + } + elseif ($hyperVAccess) { + $guestDetail = 'not checked (no VmName supplied)' + $guestReady = $true + } + + $missing = @() + if (-not $hyperVAccess) { $missing += 'HyperVAccess' } + if (-not $credentialReady) { $missing += 'Credential' } + if (-not $guestReady) { $missing += 'Guest' } + + return [pscustomobject]@{ + HyperVAccess = $hyperVAccess + HyperVAccessDetail = if ($hyperVAccess) { 'ok' } else { 'missing: elevate, or join the local "Hyper-V Administrators" group and sign out/in' } + Credential = $credentialReady + CredentialDetail = $credentialDetail + CredentialPath = $CredentialPath + Guest = $guestReady + GuestDetail = $guestDetail + VmName = $VmName + Missing = $missing + IsReady = $missing.Count -eq 0 + } +} + +function Get-LocalVmSetupMessage { + <# + .SYNOPSIS + Builds the BLOCKED message naming the one command a human must run. + #> + [CmdletBinding()] + param( + [Parameter(Mandatory)]$Status, + [string]$VmRoot = '', + [string]$InstallMedia = '', + [string]$ConfigPath, + [string]$CredentialPath + ) + + $configArgument = if ([string]::IsNullOrWhiteSpace($ConfigPath)) { '' } else { " -ConfigPath `"$ConfigPath`"" } + $credentialArgument = if ([string]::IsNullOrWhiteSpace($CredentialPath)) { '' } else { " -CredentialPath `"$CredentialPath`"" } + $lines = @( + "BLOCKED: local-VM host setup is incomplete ($($Status.Missing -join ', ')).", + " Hyper-V access : $($Status.HyperVAccessDetail)", + " Credential : $($Status.CredentialDetail)", + " Guest : $($Status.GuestDetail)", + '', + 'These steps need a human: they require elevation (which no tool call can approve) and a', + 'password (which must never be routed through a model). Ask the user to run, once:', + '', + " pwsh -File \scripts\Initialize-LocalVmHost.ps1 -VmRoot `"$VmRoot`" -InstallMedia `"$InstallMedia`"$configArgument$credentialArgument", + '', + 'Do not continue or work around this - re-check with -CheckOnly after they confirm.') + return ($lines -join [Environment]::NewLine) +} + +function New-LocalVmContext { + <# + .SYNOPSIS + Describes how to reach the guest without connecting to it. + + .DESCRIPTION + The returned context is safe to serialize into a plan: it contains no credential material. + #> + [CmdletBinding()] + param( + [Parameter(Mandatory)] + [string]$VmName, + + [Parameter(Mandatory)] + [string]$HostExchangeRoot, + + [string]$GuestExchangeRoot = $script:DefaultGuestExchangeRoot + ) + + $hostExchangePath = [IO.Path]::GetFullPath($HostExchangeRoot) + if (-not (Test-Path $hostExchangePath -PathType Container)) { + throw "Host exchange root was not found: $hostExchangePath" + } + + $exchangeName = Split-Path $hostExchangePath -Leaf + return [pscustomobject]@{ + VmName = $VmName + HostExchangeRoot = $hostExchangePath + GuestExchangeRoot = (Join-Path $GuestExchangeRoot.TrimEnd('\') $exchangeName) + ControlChannel = "vmbus://$VmName" + } +} + +function New-LocalVmSession { + <# + .SYNOPSIS + Opens an administrative PowerShell Direct session to the guest, retrying until the deadline. + #> + [CmdletBinding()] + param( + [Parameter(Mandatory)][psobject]$Context, + [Parameter(Mandatory)][pscredential]$Credential, + [ValidateRange(1, 240)][int]$TimeoutMinutes = 45 + ) + + if (-not (Test-HyperVAccess)) { + throw (Get-HyperVAccessMessage) + } + + $deadline = [DateTime]::UtcNow.AddMinutes($TimeoutMinutes) + do { + try { + return New-PSSession -VMName $Context.VmName -Credential $Credential -ErrorAction Stop + } + catch { + if ([DateTime]::UtcNow -ge $deadline) { + throw "Could not establish PowerShell Direct to '$($Context.VmName)'. $($_.Exception.Message)" + } + Start-Sleep -Seconds 5 + } + } while ($true) +} + +function Initialize-GuestExchange { + <# + .SYNOPSIS + Ensures the guest exchange directory exists and is writable by the interactive test user. + #> + [CmdletBinding()] + param( + [Parameter(Mandatory)][psobject]$Context, + [Parameter(Mandatory)][System.Management.Automation.Runspaces.PSSession]$Session, + [Parameter(Mandatory)][string]$StandardUser + ) + + Invoke-Command -Session $Session -ScriptBlock { + param($Path, $User) + + $ErrorActionPreference = 'Stop' + New-Item $Path -ItemType Directory -Force | Out-Null + $acl = Get-Acl $Path + $rule = [Security.AccessControl.FileSystemAccessRule]::new( + "$env:COMPUTERNAME\$User", + [Security.AccessControl.FileSystemRights]::Modify, + [Security.AccessControl.InheritanceFlags]'ContainerInherit, ObjectInherit', + [Security.AccessControl.PropagationFlags]::None, + [Security.AccessControl.AccessControlType]::Allow) + $acl.SetAccessRule($rule) + Set-Acl $Path $acl + } -ArgumentList $Context.GuestExchangeRoot, $StandardUser +} + +function Copy-ToGuest { + <# + .SYNOPSIS + Copies exchange files into the guest, skipping files that already match by hash. + + .OUTPUTS + The names of the files that were actually transferred. + #> + [CmdletBinding()] + param( + [Parameter(Mandatory)][psobject]$Context, + [Parameter(Mandatory)][System.Management.Automation.Runspaces.PSSession]$Session, + [Parameter(Mandatory)][string[]]$FileName, + [switch]$Force + ) + + $guestHashes = @{} + if (-not $Force) { + $guestHashes = Invoke-Command -Session $Session -ScriptBlock { + param($Root, $Names) + + $result = @{} + foreach ($name in $Names) { + $path = Join-Path $Root $name + if (Test-Path $path -PathType Leaf) { + $result[$name] = (Get-FileHash $path -Algorithm SHA256).Hash + } + } + return $result + } -ArgumentList $Context.GuestExchangeRoot, $FileName + } + + $copied = @() + foreach ($name in $FileName) { + $source = Join-Path $Context.HostExchangeRoot $name + if (-not (Test-Path $source -PathType Leaf)) { + throw "Required exchange file is missing: $source" + } + if (-not $Force -and $guestHashes.ContainsKey($name) -and + $guestHashes[$name] -eq (Get-FileHash $source -Algorithm SHA256).Hash) { + continue + } + + $destination = Join-Path $Context.GuestExchangeRoot $name + $copied += $name + try { + Copy-VMFile -Name $Context.VmName -SourcePath $source -DestinationPath $destination ` + -CreateFullPath -FileSource Host -Force -ErrorAction Stop + } + catch { + Write-Verbose "Copy-VMFile failed for '$name', falling back to the session copy: $($_.Exception.Message)" + Invoke-Command -Session $Session -ScriptBlock { + param($Path) + New-Item (Split-Path $Path -Parent) -ItemType Directory -Force | Out-Null + } -ArgumentList $destination + Copy-Item $source -Destination $destination -ToSession $Session -Force + } + } + + return $copied +} + +function Copy-FromGuest { + <# + .SYNOPSIS + Merges a guest directory subtree into the matching host exchange location. + + .DESCRIPTION + Children are copied individually so that host-authored evidence already present in the + destination (request, plan, probe script) survives the transfer. Copy-VMFile is host-to-guest + only, so evidence returns over the session - it is small. + #> + [CmdletBinding()] + param( + [Parameter(Mandatory)][psobject]$Context, + [Parameter(Mandatory)][System.Management.Automation.Runspaces.PSSession]$Session, + [Parameter(Mandatory)][string]$RelativePath + ) + + $source = Join-Path $Context.GuestExchangeRoot $RelativePath + $destination = Join-Path $Context.HostExchangeRoot $RelativePath + $children = Invoke-Command -Session $Session -ScriptBlock { + param($Path) + if (Test-Path $Path -PathType Container) { + @(Get-ChildItem $Path -Force | Select-Object -ExpandProperty FullName) + } + else { + @() + } + } -ArgumentList $source + if (@($children).Count -eq 0) { + return + } + + New-Item $destination -ItemType Directory -Force | Out-Null + foreach ($child in $children) { + Copy-Item $child -Destination $destination -FromSession $Session -Recurse -Force + } +} + +function Remove-GuestItem { + <# + .SYNOPSIS + Deletes an exchange-relative path in the guest after its evidence has been exported. + #> + [CmdletBinding()] + param( + [Parameter(Mandatory)][psobject]$Context, + [Parameter(Mandatory)][System.Management.Automation.Runspaces.PSSession]$Session, + [Parameter(Mandatory)][string]$RelativePath + ) + + Invoke-Command -Session $Session -ScriptBlock { + param($Path) + Remove-Item $Path -Recurse -Force -ErrorAction SilentlyContinue + } -ArgumentList (Join-Path $Context.GuestExchangeRoot $RelativePath) +} + +function Write-GuestText { + <# + .SYNOPSIS + Writes a UTF-8 text file at an exchange-relative path on both sides. + #> + [CmdletBinding()] + param( + [Parameter(Mandatory)][psobject]$Context, + [Parameter(Mandatory)][System.Management.Automation.Runspaces.PSSession]$Session, + [Parameter(Mandatory)][string]$RelativePath, + [Parameter(Mandatory)][AllowEmptyString()][string]$Value + ) + + $hostPath = Join-Path $Context.HostExchangeRoot $RelativePath + New-Item (Split-Path $hostPath -Parent) -ItemType Directory -Force | Out-Null + $Value | Set-Content $hostPath -Encoding utf8 + + Invoke-Command -Session $Session -ScriptBlock { + param($Path, $Text) + + $ErrorActionPreference = 'Stop' + New-Item (Split-Path $Path -Parent) -ItemType Directory -Force | Out-Null + Set-Content -Path $Path -Value $Text -Encoding utf8 + } -ArgumentList (Join-Path $Context.GuestExchangeRoot $RelativePath), $Value +} + +function Read-GuestJson { + <# + .SYNOPSIS + Reads an exchange-relative JSON file, tolerating the create/write race. + + .OUTPUTS + The parsed object, or $null when the file is absent or not yet complete. + #> + [CmdletBinding()] + param( + [Parameter(Mandatory)][psobject]$Context, + [Parameter(Mandatory)][System.Management.Automation.Runspaces.PSSession]$Session, + [Parameter(Mandatory)][string]$RelativePath, + [ValidateRange(1, 100)][int]$Attempts = 1 + ) + + for ($attempt = 1; $attempt -le $Attempts; $attempt++) { + try { + $text = Invoke-Command -Session $Session -ScriptBlock { + param($Path) + if (Test-Path $Path -PathType Leaf) { + Get-Content $Path -Raw -ErrorAction SilentlyContinue + } + } -ArgumentList (Join-Path $Context.GuestExchangeRoot $RelativePath) + + if (-not [string]::IsNullOrWhiteSpace($text)) { + return $text | ConvertFrom-Json + } + } + catch { + } + if ($attempt -lt $Attempts) { + Start-Sleep -Milliseconds 100 + } + } + + return $null +} + +Export-ModuleMember -Function ` + Test-HyperVAccess, Get-HyperVAccessMessage, Test-LocalVmHostSetup, Get-LocalVmSetupMessage, ` + New-LocalVmContext, New-LocalVmSession, ` + Initialize-GuestExchange, Copy-ToGuest, Copy-FromGuest, Remove-GuestItem, Write-GuestText, ` + Read-GuestJson diff --git a/.github/skills/ui-tests-local-vm/scripts/Update-LocalVmGuest.ps1 b/.github/skills/ui-tests-local-vm/scripts/Update-LocalVmGuest.ps1 new file mode 100644 index 0000000000..6a04bb5e4d --- /dev/null +++ b/.github/skills/ui-tests-local-vm/scripts/Update-LocalVmGuest.ps1 @@ -0,0 +1,147 @@ +# Copyright (c) Microsoft Corporation +# The Microsoft Corporation licenses this file to you under the MIT license. +# See the LICENSE file in the project root for more information. + +<# +.SYNOPSIS +Installs Windows updates in a local Hyper-V UI-test guest and handles required reboots. + +.DESCRIPTION +Retail Windows 10 22H2 media starts at an unserviced build that .NET 10 rejects with: +"Your Windows doesn't fully support CET. Please install all available Windows updates." +This script drives the in-box Windows Update COM API over PowerShell Direct, reboots as needed, and +repeats until no software updates remain or MaxPasses is reached. + +.EXAMPLE +pwsh ./Update-LocalVmGuest.ps1 -VmName PowerToysUiTest-Win10 +#> + +[CmdletBinding()] +param( + [Parameter(Mandatory)] + [string]$VmName, + [string]$CredentialPath = (Join-Path $env:LOCALAPPDATA 'PowerToysUiTestVm\admin.credential.xml'), + [ValidateRange(1, 10)] + [int]$MaxPasses = 4, + [ValidateRange(1, 120)] + [int]$ReconnectTimeoutMinutes = 30 +) + +$ErrorActionPreference = 'Stop' + +if ($PSVersionTable.PSVersion.Major -lt 7) { + throw 'Run this script with PowerShell 7 (pwsh).' +} +if (-not (Test-Path $CredentialPath -PathType Leaf)) { + throw "DPAPI credential file was not found: $CredentialPath" +} + +Import-Module Hyper-V -ErrorAction Stop +$credential = Import-Clixml $CredentialPath + +function New-GuestSession { + $deadline = [DateTime]::UtcNow.AddMinutes($ReconnectTimeoutMinutes) + do { + try { + return New-PSSession -VMName $VmName -Credential $credential -ErrorAction Stop + } + catch { + if ([DateTime]::UtcNow -ge $deadline) { + throw "PowerShell Direct did not reconnect to '$VmName' within $ReconnectTimeoutMinutes minute(s): $($_.Exception.Message)" + } + Start-Sleep -Seconds 5 + } + } while ($true) +} + +$vm = Get-VM -Name $VmName -ErrorAction Stop +if ($vm.State -ne 'Running') { + Start-VM -Name $VmName +} + +$passes = @() +for ($pass = 1; $pass -le $MaxPasses; $pass++) { + $session = New-GuestSession + try { + $result = Invoke-Command -Session $session -ScriptBlock { + $ErrorActionPreference = 'Stop' + $updateSession = New-Object -ComObject Microsoft.Update.Session + $searcher = $updateSession.CreateUpdateSearcher() + $search = $searcher.Search("IsInstalled=0 and Type='Software' and IsHidden=0") + $titles = @($search.Updates | ForEach-Object Title) + + if ($search.Updates.Count -eq 0) { + $ubr = (Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion').UBR + return [pscustomobject]@{ + Count = 0 + Titles = @() + DownloadResult = $null + InstallResult = $null + RebootRequired = $false + Version = "$([Environment]::OSVersion.Version.Major).$([Environment]::OSVersion.Version.Minor).$([Environment]::OSVersion.Version.Build).$ubr" + } + } + + $updates = New-Object -ComObject Microsoft.Update.UpdateColl + foreach ($update in $search.Updates) { + if (-not $update.EulaAccepted) { $update.AcceptEula() } + [void]$updates.Add($update) + } + + $downloader = $updateSession.CreateUpdateDownloader() + $downloader.Updates = $updates + $download = $downloader.Download() + + $installer = $updateSession.CreateUpdateInstaller() + $installer.Updates = $updates + $install = $installer.Install() + + $ubr = (Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion').UBR + [pscustomobject]@{ + Count = $updates.Count + Titles = $titles + DownloadResult = [int]$download.ResultCode + InstallResult = [int]$install.ResultCode + RebootRequired = [bool]$install.RebootRequired + Version = "$([Environment]::OSVersion.Version.Major).$([Environment]::OSVersion.Version.Minor).$([Environment]::OSVersion.Version.Build).$ubr" + } + } + } + finally { + Remove-PSSession $session -ErrorAction SilentlyContinue + } + + $passes += $result + Write-Host "Windows Update pass $pass`: $($result.Count) update(s), download=$($result.DownloadResult), install=$($result.InstallResult), version=$($result.Version)" + foreach ($title in $result.Titles) { Write-Host " $title" } + + if ($result.Count -eq 0) { + break + } + if ($result.DownloadResult -notin 2, 3 -or $result.InstallResult -notin 2, 3) { + throw "Windows Update failed in '$VmName' (download=$($result.DownloadResult), install=$($result.InstallResult))." + } + + if ($result.RebootRequired) { + Write-Host "Restarting '$VmName'..." + $session = New-GuestSession + try { + Invoke-Command -Session $session -ScriptBlock { Restart-Computer -Force } -ErrorAction SilentlyContinue + } + finally { + Remove-PSSession $session -ErrorAction SilentlyContinue + } + $null = New-GuestSession | ForEach-Object { Remove-PSSession $_ } + } +} + +if ($passes.Count -eq $MaxPasses -and $passes[-1].Count -gt 0) { + throw "Windows Update still found updates after $MaxPasses passes in '$VmName'. Re-run the script." +} + +[pscustomobject]@{ + VmName = $VmName + Passes = $passes.Count + FinalVersion = $passes[-1].Version + PendingUpdates = $passes[-1].Count +} | ConvertTo-Json -Depth 4 diff --git a/.github/skills/ui-tests-local-vm/templates/oem/Provision-UiTestVm.ps1 b/.github/skills/ui-tests-local-vm/templates/oem/Provision-UiTestVm.ps1 new file mode 100644 index 0000000000..965f63ed50 --- /dev/null +++ b/.github/skills/ui-tests-local-vm/templates/oem/Provision-UiTestVm.ps1 @@ -0,0 +1,168 @@ +<# +.SYNOPSIS +Provisions the PowerToys UI-test guest: standard-user desktop, auto-logon, and optional tooling. + +.DESCRIPTION +The host reaches this guest over PowerShell Direct, so no remote listener, no firewall opening, and +no certificate is created. The guest keeps its default inbound posture. +#> + +[CmdletBinding()] +param( + [string]$StandardUser = 'PTUser' +) + +$ErrorActionPreference = 'Stop' + +$standardUser = $StandardUser +$workRoot = 'C:\PowerToysUiTestRun' + +function Invoke-OfflineInstaller { + param( + [Parameter(Mandatory)] + [string]$Path, + [Parameter(Mandatory)] + [string[]]$Arguments + ) + + $process = Start-Process $Path -ArgumentList $Arguments -Wait -PassThru + if ($process.ExitCode -notin @(0, 3010)) { + throw "Installer '$Path' failed with exit code $($process.ExitCode)." + } +} + +$autoLogonScript = 'C:\OEM\Set-UiTestAutoLogon.ps1' +if (-not (Test-Path $autoLogonScript -PathType Leaf)) { + throw "Auto-logon provisioning helper was not found: $autoLogonScript" +} +& $autoLogonScript -StandardUser $standardUser | Out-Null +Remove-LocalGroupMember -Group 'Administrators' -Member $standardUser -ErrorAction SilentlyContinue +if ($null -eq (Get-LocalGroupMember -Group 'Users' -Member $standardUser -ErrorAction SilentlyContinue)) { + Add-LocalGroupMember -Group 'Users' -Member $standardUser +} +$remoteDesktopUsers = Get-LocalGroup -SID 'S-1-5-32-555' -ErrorAction SilentlyContinue +if ($null -ne $remoteDesktopUsers -and + $null -eq (Get-LocalGroupMember -Group $remoteDesktopUsers.Name -Member $standardUser -ErrorAction SilentlyContinue)) { + Add-LocalGroupMember -Group $remoteDesktopUsers.Name -Member $standardUser +} + +New-Item $workRoot -ItemType Directory -Force | Out-Null +$acl = Get-Acl $workRoot +$rule = [Security.AccessControl.FileSystemAccessRule]::new( + "$env:COMPUTERNAME\$standardUser", + [Security.AccessControl.FileSystemRights]::Modify, + [Security.AccessControl.InheritanceFlags]'ContainerInherit, ObjectInherit', + [Security.AccessControl.PropagationFlags]::None, + [Security.AccessControl.AccessControlType]::Allow) +$acl.SetAccessRule($rule) +Set-Acl $workRoot $acl + +powercfg.exe /change monitor-timeout-ac 0 | Out-Null +powercfg.exe /change standby-timeout-ac 0 | Out-Null +powercfg.exe /hibernate off | Out-Null + +# Display settings belong to the interactive session, which does not exist yet while provisioning +# runs, so apply them from a logon task in the standard user's own session instead. +$resolutionScript = Join-Path $workRoot 'Set-GuestResolution.ps1' +$resolutionTaskRegistered = $false +if (Test-Path C:\OEM\Set-GuestResolution.ps1 -PathType Leaf) { + Copy-Item C:\OEM\Set-GuestResolution.ps1 $resolutionScript -Force + $resolutionAction = New-ScheduledTaskAction -Execute 'powershell.exe' ` + -Argument "-NoLogo -NoProfile -WindowStyle Hidden -ExecutionPolicy Bypass -File `"$resolutionScript`"" + $resolutionTrigger = New-ScheduledTaskTrigger -AtLogOn -User "$env:COMPUTERNAME\$standardUser" + $resolutionPrincipal = New-ScheduledTaskPrincipal ` + -UserId "$env:COMPUTERNAME\$standardUser" -LogonType Interactive -RunLevel Limited + $resolutionSettings = New-ScheduledTaskSettingsSet -ExecutionTimeLimit (New-TimeSpan -Minutes 2) + Register-ScheduledTask -TaskName 'PowerToysUiTest-Resolution' -Force -InputObject (New-ScheduledTask ` + -Action $resolutionAction -Trigger $resolutionTrigger ` + -Principal $resolutionPrincipal -Settings $resolutionSettings) | Out-Null + $resolutionTaskRegistered = $true +} + +$dotNetSdk = Get-ChildItem C:\OEM -Filter 'dotnet-sdk-10*-win-*.exe' -File | Select-Object -First 1 +if ($null -ne $dotNetSdk) { + Invoke-OfflineInstaller -Path $dotNetSdk.FullName -Arguments @('/install', '/quiet', '/norestart') +} +else { + $desktopRuntime = Get-ChildItem C:\OEM -Filter 'windowsdesktop-runtime-10*-win-*.exe' -File | Select-Object -First 1 + if ($null -ne $desktopRuntime) { + Invoke-OfflineInstaller -Path $desktopRuntime.FullName -Arguments @('/install', '/quiet', '/norestart') + } +} + +$webView2Installer = Get-ChildItem C:\OEM -Filter 'MicrosoftEdgeWebView2RuntimeInstaller*.exe' -File | Select-Object -First 1 +if ($null -ne $webView2Installer) { + Invoke-OfflineInstaller -Path $webView2Installer.FullName -Arguments @('/silent', '/install') +} + +# ScreenRecorderLib is a mixed-mode assembly importing VCRUNTIME140/MSVCP140. A clean Windows image +# has neither, so without this the harness silently captures no video. +$vcRedist = Get-ChildItem C:\OEM -Filter 'vc_redist.*.exe' -File | Select-Object -First 1 +if ($null -ne $vcRedist) { + $vcSignature = Get-AuthenticodeSignature $vcRedist.FullName + if ($vcSignature.Status -ne 'Valid' -or + $vcSignature.SignerCertificate.Subject -notlike 'CN=Microsoft Corporation*') { + throw "Refusing untrusted Visual C++ redistributable '$($vcRedist.FullName)'." + } + Invoke-OfflineInstaller -Path $vcRedist.FullName -Arguments @('/install', '/quiet', '/norestart') +} + +$powerShellArchitecture = if ($env:PROCESSOR_ARCHITECTURE -eq 'ARM64') { 'arm64' } else { 'x64' } +$availablePowerShellMsis = @(Get-ChildItem C:\OEM -Filter "PowerShell-*-win-$powerShellArchitecture.msi" -File) +$powerShellMsi = Get-ChildItem C:\OEM -Filter "PowerShell-*-win-$powerShellArchitecture.msi" -File | + Where-Object { Test-Path "$($_.FullName).sha256" -PathType Leaf } | + Sort-Object Name -Descending | + Select-Object -First 1 +if ($availablePowerShellMsis.Count -gt 0 -and $null -eq $powerShellMsi) { + throw "PowerShell MSI trust metadata is missing. Re-stage the OEM payload with Initialize-LocalVmHost.ps1." +} +if ($null -ne $powerShellMsi) { + $expectedPowerShellHash = (Get-Content "$($powerShellMsi.FullName).sha256" -Raw).Trim() + $actualPowerShellHash = (Get-FileHash $powerShellMsi.FullName -Algorithm SHA256).Hash + $powerShellSignature = Get-AuthenticodeSignature $powerShellMsi.FullName + if ($actualPowerShellHash -ne $expectedPowerShellHash -or + $powerShellSignature.Status -ne 'Valid' -or + $powerShellSignature.SignerCertificate.Subject -notlike 'CN=Microsoft Corporation*') { + throw "Refusing unverified PowerShell MSI '$($powerShellMsi.FullName)'." + } + Invoke-OfflineInstaller -Path msiexec.exe -Arguments @( + '/i', $powerShellMsi.FullName, '/qn', '/norestart', + 'ADD_PATH=1', 'REGISTER_MANIFEST=1', + 'ENABLE_PSREMOTING=0', 'USE_MU=0', 'ENABLE_MU=0') +} +$powerShellExecutable = 'C:\Program Files\PowerShell\7\pwsh.exe' + +$windowsApplicationId = '55c92734-d682-4d71-983e-d6ec3f16059f' +$windowsLicense = Get-CimInstance SoftwareLicensingProduct -ErrorAction SilentlyContinue | + Where-Object { + $_.ApplicationID -eq $windowsApplicationId -and + -not [string]::IsNullOrWhiteSpace($_.PartialProductKey) -and + $_.Name -like 'Windows*' + } | + Select-Object -First 1 +$windowsVersion = Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion' +$fullWindowsBuild = "$($windowsVersion.CurrentBuild).$($windowsVersion.UBR)" +$windowsBuild = [int]$windowsVersion.CurrentBuild +$dotNet10CetReady = $windowsBuild -ge 22000 -or + ($windowsBuild -ge 19041 -and $windowsBuild -le 19045 -and [int]$windowsVersion.UBR -ge 5007) + +[ordered]@{ + ProvisionedUtc = [DateTime]::UtcNow.ToString('O') + ComputerName = $env:COMPUTERNAME + StandardUser = $standardUser + StandardUserIsAdministrator = $false + WorkRoot = $workRoot + ResolutionTaskRegistered = $resolutionTaskRegistered + DotNetSdkInstaller = if ($null -ne $dotNetSdk) { $dotNetSdk.Name } else { $null } + WebView2Installer = if ($null -ne $webView2Installer) { $webView2Installer.Name } else { $null } + VcRedistInstaller = if ($null -ne $vcRedist) { $vcRedist.Name } else { $null } + ScreenRecordingSupported = (Test-Path "$env:WINDIR\System32\VCRUNTIME140.dll") + PowerShellVersion = if (Test-Path $powerShellExecutable) { + (& $powerShellExecutable -NoLogo -NoProfile -Command '$PSVersionTable.PSVersion.ToString()').Trim() + } else { $null } + WindowsBuild = $fullWindowsBuild + DotNet10CetReady = $dotNet10CetReady + WindowsLicenseDescription = [string]$windowsLicense.Description + WindowsLicenseStatus = [int]$windowsLicense.LicenseStatus + WindowsGracePeriodMinutes = [int]$windowsLicense.GracePeriodRemaining +} | ConvertTo-Json | Set-Content C:\OEM\ProvisioningReady.json -Encoding utf8 diff --git a/.github/skills/ui-tests-local-vm/templates/oem/Set-GuestResolution.ps1 b/.github/skills/ui-tests-local-vm/templates/oem/Set-GuestResolution.ps1 new file mode 100644 index 0000000000..33b7d442bf --- /dev/null +++ b/.github/skills/ui-tests-local-vm/templates/oem/Set-GuestResolution.ps1 @@ -0,0 +1,90 @@ +# Sets the interactive desktop resolution for the UI-test guest. +# Runs inside the guest as the standard user via an interactive scheduled task: display settings +# belong to the interactive session, so a PowerShell Direct session (session 0) cannot change them. + +[CmdletBinding()] +param( + [int]$Width = 1920, + [int]$Height = 1080 +) + +$ErrorActionPreference = 'Stop' + +Add-Type -TypeDefinition @' +using System; +using System.Runtime.InteropServices; + +public static class DisplayConfiguration +{ + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] + public struct DEVMODE + { + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)] public string dmDeviceName; + public short dmSpecVersion; + public short dmDriverVersion; + public short dmSize; + public short dmDriverExtra; + public int dmFields; + public int dmPositionX; + public int dmPositionY; + public int dmDisplayOrientation; + public int dmDisplayFixedOutput; + public short dmColor; + public short dmDuplex; + public short dmYResolution; + public short dmTTOption; + public short dmCollate; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)] public string dmFormName; + public short dmLogPixels; + public int dmBitsPerPel; + public int dmPelsWidth; + public int dmPelsHeight; + public int dmDisplayFlags; + public int dmDisplayFrequency; + public int dmICMMethod; + public int dmICMIntent; + public int dmMediaType; + public int dmDitherType; + public int dmReserved1; + public int dmReserved2; + public int dmPanningWidth; + public int dmPanningHeight; + } + + [DllImport("user32.dll", CharSet = CharSet.Unicode)] + public static extern int EnumDisplaySettings(string deviceName, int modeNum, ref DEVMODE devMode); + + [DllImport("user32.dll", CharSet = CharSet.Unicode)] + public static extern int ChangeDisplaySettings(ref DEVMODE devMode, int flags); +} +'@ + +$mode = New-Object DisplayConfiguration+DEVMODE +# Pass the instance: Marshal::SizeOf binds its object overload, and a Type argument is rejected. +$mode.dmSize = [int16][Runtime.InteropServices.Marshal]::SizeOf($mode) + +# [NullString]::Value marshals as a real NULL; PowerShell would turn $null into an empty string, +# and EnumDisplaySettings needs NULL to mean "the current display device". +if ([DisplayConfiguration]::EnumDisplaySettings([NullString]::Value, -1, [ref]$mode) -eq 0) { + throw 'EnumDisplaySettings failed.' +} + +$before = "$($mode.dmPelsWidth)x$($mode.dmPelsHeight)" +$mode.dmPelsWidth = $Width +$mode.dmPelsHeight = $Height +# DM_PELSWIDTH | DM_PELSHEIGHT +$mode.dmFields = 0x00080000 -bor 0x00100000 + +# CDS_UPDATEREGISTRY makes the change persist for later logons. +$result = [DisplayConfiguration]::ChangeDisplaySettings([ref]$mode, 0x00000001) + +Add-Type -AssemblyName System.Windows.Forms +$bounds = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds +[ordered]@{ + Before = $before + Requested = "${Width}x${Height}" + ChangeDisplaySettingsResult = $result + After = "$($bounds.Width)x$($bounds.Height)" + User = [Security.Principal.WindowsIdentity]::GetCurrent().Name + SessionId = (Get-Process -Id $PID).SessionId +} | ConvertTo-Json | Set-Content C:\PowerToysUiTestRun\set-resolution.json -Encoding utf8 diff --git a/.github/skills/ui-tests-local-vm/templates/oem/Set-UiTestAutoLogon.ps1 b/.github/skills/ui-tests-local-vm/templates/oem/Set-UiTestAutoLogon.ps1 new file mode 100644 index 0000000000..f598dac2a4 --- /dev/null +++ b/.github/skills/ui-tests-local-vm/templates/oem/Set-UiTestAutoLogon.ps1 @@ -0,0 +1,209 @@ +# Copyright (c) Microsoft Corporation +# The Microsoft Corporation licenses this file to you under the MIT license. +# See the LICENSE file in the project root for more information. + +[CmdletBinding()] +param( + [Parameter(Mandatory)] + [string]$StandardUser, + [string]$Description = 'PowerToys standard-user UI-test account' +) + +$ErrorActionPreference = 'Stop' + +if ($null -eq ('PowerToysUiTestAutoLogon' -as [type])) { + Add-Type -TypeDefinition @' +using System; +using System.Runtime.InteropServices; + +public static class PowerToysUiTestAutoLogon +{ + [StructLayout(LayoutKind.Sequential)] + private struct LsaUnicodeString + { + public ushort Length; + public ushort MaximumLength; + public IntPtr Buffer; + } + + [StructLayout(LayoutKind.Sequential)] + private struct LsaObjectAttributes + { + public int Length; + public IntPtr RootDirectory; + public IntPtr ObjectName; + public uint Attributes; + public IntPtr SecurityDescriptor; + public IntPtr SecurityQualityOfService; + } + + [DllImport("advapi32.dll")] + private static extern uint LsaOpenPolicy(IntPtr systemName, ref LsaObjectAttributes attributes, uint access, out IntPtr policy); + + [DllImport("advapi32.dll")] + private static extern uint LsaStorePrivateData(IntPtr policy, ref LsaUnicodeString key, ref LsaUnicodeString value); + + [DllImport("advapi32.dll")] + private static extern uint LsaRetrievePrivateData(IntPtr policy, ref LsaUnicodeString key, out IntPtr value); + + [DllImport("advapi32.dll")] + private static extern uint LsaFreeMemory(IntPtr buffer); + + [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Unicode)] + private static extern bool LogonUser(string userName, string domain, string password, int logonType, int provider, out IntPtr token); + + [DllImport("advapi32.dll")] + private static extern uint LsaClose(IntPtr policy); + + [DllImport("kernel32.dll")] + private static extern bool CloseHandle(IntPtr handle); + + private static LsaUnicodeString CreateString(string value) + { + return new LsaUnicodeString + { + Length = (ushort)(value.Length * 2), + MaximumLength = (ushort)((value.Length + 1) * 2), + Buffer = Marshal.StringToHGlobalUni(value), + }; + } + + public static uint StorePassword(string password) + { + var attributes = new LsaObjectAttributes { Length = Marshal.SizeOf(typeof(LsaObjectAttributes)) }; + IntPtr policy; + var status = LsaOpenPolicy(IntPtr.Zero, ref attributes, 0x20, out policy); + if (status != 0) + { + return status; + } + + var key = CreateString("DefaultPassword"); + var value = CreateString(password); + try + { + return LsaStorePrivateData(policy, ref key, ref value); + } + finally + { + Marshal.FreeHGlobal(key.Buffer); + Marshal.FreeHGlobal(value.Buffer); + LsaClose(policy); + } + } + + public static string ReadPassword() + { + var attributes = new LsaObjectAttributes { Length = Marshal.SizeOf(typeof(LsaObjectAttributes)) }; + IntPtr policy; + var status = LsaOpenPolicy(IntPtr.Zero, ref attributes, 0x4, out policy); + if (status != 0) + { + return null; + } + + var key = CreateString("DefaultPassword"); + try + { + IntPtr value; + status = LsaRetrievePrivateData(policy, ref key, out value); + if (status != 0) + { + return null; + } + + try + { + var secret = (LsaUnicodeString)Marshal.PtrToStructure(value, typeof(LsaUnicodeString)); + return secret.Buffer == IntPtr.Zero ? null : Marshal.PtrToStringUni(secret.Buffer, secret.Length / 2); + } + finally + { + LsaFreeMemory(value); + } + } + finally + { + Marshal.FreeHGlobal(key.Buffer); + LsaClose(policy); + } + } + + public static bool ValidatePassword(string userName, string domain, string password, out int errorCode) + { + IntPtr token; + var valid = LogonUser(userName, domain, password, 2, 0, out token); + errorCode = valid ? 0 : Marshal.GetLastWin32Error(); + if (token != IntPtr.Zero) + { + CloseHandle(token); + } + + return valid; + } +} +'@ +} + +$localUser = Get-LocalUser -Name $StandardUser -ErrorAction SilentlyContinue +$plainPassword = if ($null -ne $localUser) { [PowerToysUiTestAutoLogon]::ReadPassword() } else { $null } +$credentialError = 0 +$credentialValid = -not [string]::IsNullOrEmpty($plainPassword) -and + [PowerToysUiTestAutoLogon]::ValidatePassword( + $StandardUser, + $env:COMPUTERNAME, + $plainPassword, + [ref]$credentialError) +$credentialRotated = $false +if (-not $credentialValid) { + $passwordBytes = New-Object byte[] 12 + $random = [Security.Cryptography.RandomNumberGenerator]::Create() + try { + $random.GetBytes($passwordBytes) + } + finally { + $random.Dispose() + } + $plainPassword = ([BitConverter]::ToString($passwordBytes) -replace '-', '') + 'aA1!' + $securePassword = ConvertTo-SecureString $plainPassword -AsPlainText -Force + if ($null -eq $localUser) { + New-LocalUser ` + -Name $StandardUser ` + -Password $securePassword ` + -AccountNeverExpires ` + -PasswordNeverExpires ` + -Description $Description | Out-Null + } + else { + Set-LocalUser -Name $StandardUser -Password $securePassword + } + + $credentialError = 0 + if (-not [PowerToysUiTestAutoLogon]::ValidatePassword( + $StandardUser, + $env:COMPUTERNAME, + $plainPassword, + [ref]$credentialError)) { + throw "The generated auto-logon credential did not authenticate (Win32 error $credentialError)." + } + $lsaStatus = [PowerToysUiTestAutoLogon]::StorePassword($plainPassword) + if ($lsaStatus -ne 0) { + throw "LsaStorePrivateData failed with NTSTATUS 0x$($lsaStatus.ToString('X8'))." + } + $credentialRotated = $true +} +Set-LocalUser -Name $StandardUser -PasswordNeverExpires $true + +$winlogon = 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon' +Set-ItemProperty $winlogon AutoAdminLogon '1' +Set-ItemProperty $winlogon ForceAutoLogon '1' +Set-ItemProperty $winlogon DefaultUserName $StandardUser +Set-ItemProperty $winlogon DefaultDomainName $env:COMPUTERNAME +Remove-ItemProperty $winlogon DefaultPassword -ErrorAction SilentlyContinue +Remove-ItemProperty $winlogon AutoLogonCount -ErrorAction SilentlyContinue + +[pscustomobject]@{ + StandardUser = $StandardUser + CredentialValidated = $true + CredentialRotated = $credentialRotated +} \ No newline at end of file diff --git a/.github/skills/ui-tests-local-vm/templates/run-ui-tests.ps1 b/.github/skills/ui-tests-local-vm/templates/run-ui-tests.ps1 new file mode 100644 index 0000000000..bc2e501f80 --- /dev/null +++ b/.github/skills/ui-tests-local-vm/templates/run-ui-tests.ps1 @@ -0,0 +1,510 @@ +# Copyright (c) Microsoft Corporation +# The Microsoft Corporation licenses this file to you under the MIT license. +# See the LICENSE file in the project root for more information. + +<# +.SYNOPSIS +Stages and runs a PowerToys UITest.Next payload inside a persistent local Windows VM. + +.DESCRIPTION +This guest template is dispatched by Invoke-LocalVmUiTest.ps1. It reads the generated request, +extracts archives to guest-local storage, provisions optional WebView2, runs the test executable, +and exports progress, status, TRX, logs, and attachments through the shared exchange. +#> + +[CmdletBinding()] +param( + [Parameter(Mandatory)] + [string]$RequestPath, + [switch]$Detached +) + +$ErrorActionPreference = 'Stop' +$currentPowerShell = (Get-Process -Id $PID).Path + +if ($Detached) { + $arguments = '-NoLogo -NoProfile -ExecutionPolicy Bypass -File "{0}" -RequestPath "{1}"' -f $PSCommandPath,$RequestPath + Start-Process $currentPowerShell -ArgumentList $arguments -WindowStyle Hidden + return +} + +$request = Get-Content $RequestPath -Raw | ConvertFrom-Json +$exchangeRoot = if ($request.PSObject.Properties.Name -contains 'ExchangeRoot') { + [string]$request.ExchangeRoot +} +else { + 'C:\PowerToysUiTestExchange' +} +if ([string]::IsNullOrWhiteSpace($exchangeRoot) -or -not [IO.Path]::IsPathRooted($exchangeRoot)) { + throw 'ExchangeRoot must be an absolute path.' +} +$workRoot = 'C:\PowerToysUiTestRun' +$testRoot = Join-Path $workRoot 'Tests' +$productRoot = Join-Path $workRoot 'PowerToys' +$winAppRoot = Join-Path $workRoot 'winappcli' +$dotNetRoot = Join-Path $workRoot 'dotnet' +$localResultsRoot = Join-Path $workRoot 'TestResults' +$localLog = Join-Path $workRoot 'local-vm-ui-tests.log' +$stagingManifestPath = Join-Path $workRoot 'staging-manifest.json' +$hostResultsRoot = Join-Path $exchangeRoot "LocalVmResults\$($request.RunId)" +$startedUtc = [DateTime]::UtcNow +$exitCode = 1 +$errorMessage = $null +$transcriptStarted = $false +$outputHeartbeatSeconds = if ($null -eq $request.OutputHeartbeatSeconds) { 0 } else { [int]$request.OutputHeartbeatSeconds } +$reusedStagedPayload = $false +$heartbeatProcess = $null +$webView2Version = $null +$exportErrors = @() + +function Write-SharedText { + param( + [Parameter(Mandatory)] + [string]$Path, + [Parameter(Mandatory)] + [string]$Value + ) + + for ($attempt = 1; $attempt -le 20; $attempt++) { + try { + $Value | Set-Content $Path -Encoding utf8 + return + } + catch [IO.IOException] { + if ($attempt -eq 20) { + throw + } + [Threading.Thread]::Sleep(100) + } + } +} + +function Write-RunProgress { + param( + [Parameter(Mandatory)] + [string]$Stage, + [string]$Detail + ) + + New-Item $hostResultsRoot -ItemType Directory -Force | Out-Null + $payload = [ordered]@{ + Stage = $Stage + Detail = $Detail + UpdatedUtc = [DateTime]::UtcNow.ToString('O') + RunId = $request.RunId + } | ConvertTo-Json + Write-SharedText -Path (Join-Path $hostResultsRoot 'progress.json') -Value $payload +} + +function Copy-SharedItem { + param( + [Parameter(Mandatory)] + [string]$Path, + [Parameter(Mandatory)] + [string]$Destination + ) + + $sourceItem = Get-Item $Path -Force + if ($sourceItem.PSIsContainer) { + $directoryDestination = Join-Path $Destination $sourceItem.Name + New-Item $directoryDestination -ItemType Directory -Force | Out-Null + & robocopy.exe $sourceItem.FullName $directoryDestination ` + /E /R:5 /W:1 /COPY:DAT /DCOPY:DAT /XJ /NP /NFL /NDL /NJH /NJS | Out-Null + $robocopyExitCode = $LASTEXITCODE + if ($robocopyExitCode -ge 8) { + throw "robocopy failed with exit code $robocopyExitCode while exporting '$Path'." + } + return + } + + for ($attempt = 1; $attempt -le 5; $attempt++) { + try { + $fileDestination = Join-Path $Destination $sourceItem.Name + Copy-Item $Path $fileDestination -Force -ErrorAction Stop + return + } + catch { + if ($attempt -eq 5) { + throw + } + [Threading.Thread]::Sleep(200) + } + } +} + +function Expand-PayloadArchive { + param( + [Parameter(Mandatory)] + [string]$Path, + [Parameter(Mandatory)] + [string]$Destination + ) + + New-Item $Destination -ItemType Directory -Force | Out-Null + $tar = Get-Command tar.exe -ErrorAction SilentlyContinue + if ($null -eq $tar) { + Expand-Archive -Path $Path -DestinationPath $Destination -Force + return + } + + & $tar.Source -xf $Path -C $Destination + if ($LASTEXITCODE -ne 0) { + throw "tar.exe failed with exit code $LASTEXITCODE while extracting '$Path'." + } +} + +function Stop-RunProcesses { + $cleanupProcesses = @('PowerToys', 'PowerToys.Settings', 'winapp') + @($request.CleanupProcesses) + Get-Process -Name ($cleanupProcesses | Sort-Object -Unique) -ErrorAction SilentlyContinue | + Stop-Process -Force -ErrorAction SilentlyContinue +} + +function Start-OutputHeartbeat { + if ($outputHeartbeatSeconds -le 0) { + return $null + } + + $intervalMilliseconds = $outputHeartbeatSeconds * 1000 + $heartbeatScript = @" +while (`$true) { + Write-Output ('[GuestHeartbeat] ' + [DateTime]::UtcNow.ToString('O')) + [Threading.Thread]::Sleep($intervalMilliseconds) +} +"@ + $encodedHeartbeat = [Convert]::ToBase64String([Text.Encoding]::Unicode.GetBytes($heartbeatScript)) + return Start-Process $currentPowerShell ` + -ArgumentList '-NoLogo','-NoProfile','-EncodedCommand',$encodedHeartbeat ` + -NoNewWindow -PassThru +} + +function Get-WebView2RuntimeVersion { + $clientId = '{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}' + $registryPaths = @( + "HKLM:\SOFTWARE\WOW6432Node\Microsoft\EdgeUpdate\Clients\$clientId", + "HKCU:\Software\Microsoft\EdgeUpdate\Clients\$clientId" + ) + foreach ($registryPath in $registryPaths) { + try { + $versionText = [string](Get-ItemPropertyValue -Path $registryPath -Name 'pv' -ErrorAction Stop) + if (-not [string]::IsNullOrWhiteSpace($versionText) -and [version]$versionText -gt [version]'0.0.0.0') { + return $versionText + } + } + catch { + } + } + + $runtimeRoots = @( + 'C:\Program Files (x86)\Microsoft\EdgeWebView\Application', + (Join-Path $env:LOCALAPPDATA 'Microsoft\EdgeWebView\Application') + ) + foreach ($runtimeRoot in $runtimeRoots) { + if (-not (Test-Path $runtimeRoot -PathType Container)) { + continue + } + foreach ($versionDirectory in Get-ChildItem $runtimeRoot -Directory -ErrorAction SilentlyContinue | Sort-Object Name -Descending) { + try { + if ([version]$versionDirectory.Name -gt [version]'0.0.0.0' -and + (Test-Path (Join-Path $versionDirectory.FullName 'msedgewebview2.exe') -PathType Leaf)) { + return $versionDirectory.Name + } + } + catch { + } + } + } + + return $null +} + +try { + Write-RunProgress -Stage 'Starting' -Detail 'The guest runner is active.' + $heartbeatProcess = Start-OutputHeartbeat + + Stop-RunProcesses + $reuseRequested = $request.PSObject.Properties.Name -contains 'ReuseStagedPayload' -and [bool]$request.ReuseStagedPayload + $refreshTests = $true + $refreshProduct = $true + $refreshWinAppCli = $true + $refreshDotNet = $true + $refreshedComponents = @() + if ($reuseRequested) { + if (-not (Test-Path $stagingManifestPath -PathType Leaf)) { + throw 'Staged payload reuse was requested, but the guest manifest is missing.' + } + $stagingManifest = Get-Content $stagingManifestPath -Raw | ConvertFrom-Json + if ($null -eq $request.PayloadHashes -or $null -eq $stagingManifest.PayloadHashes) { + throw 'Staged payload reuse requires per-component hashes in both the request and guest manifest.' + } + + $refreshTests = $stagingManifest.PayloadHashes.Tests -ne $request.PayloadHashes.Tests -or + -not (Test-Path $testRoot -PathType Container) + $refreshProduct = $stagingManifest.PayloadHashes.Product -ne $request.PayloadHashes.Product -or + $stagingManifest.PayloadHashes.ProductOverlay -ne $request.PayloadHashes.ProductOverlay -or + -not (Test-Path $productRoot -PathType Container) + $refreshWinAppCli = $stagingManifest.PayloadHashes.WinAppCli -ne $request.PayloadHashes.WinAppCli -or + -not (Test-Path $winAppRoot -PathType Container) + $refreshDotNet = $stagingManifest.PayloadHashes.DotNet -ne $request.PayloadHashes.DotNet -or + -not (Test-Path $dotNetRoot -PathType Container) + $reusedStagedPayload = $true + $changedComponents = @() + if ($refreshTests) { $changedComponents += 'Tests' } + if ($refreshProduct) { $changedComponents += 'Product' } + if ($refreshWinAppCli) { $changedComponents += 'winappcli' } + if ($refreshDotNet) { $changedComponents += '.NET' } + $reuseDetail = if ($changedComponents.Count -eq 0) { + "Unchanged payload $($request.PayloadFingerprint)" + } + else { + "Refreshing: $($changedComponents -join ', ')" + } + Write-RunProgress -Stage 'Reusing' -Detail $reuseDetail + } + else { + Remove-Item $workRoot -Recurse -Force -ErrorAction SilentlyContinue + New-Item $workRoot -ItemType Directory -Force | Out-Null + } + + Remove-Item $localResultsRoot -Recurse -Force -ErrorAction SilentlyContinue + Remove-Item $localLog -Force -ErrorAction SilentlyContinue + New-Item $localResultsRoot -ItemType Directory -Force | Out-Null + Start-Transcript -Path $localLog -Force | Out-Null + $transcriptStarted = $true + + $components = @( + [pscustomobject]@{ Name = 'Tests'; Refresh = $refreshTests; Archive = $request.Archives.Tests; Destination = $testRoot }, + [pscustomobject]@{ Name = 'Product'; Refresh = $refreshProduct; Archive = $request.Archives.Product; Destination = $productRoot }, + [pscustomobject]@{ Name = 'winappcli'; Refresh = $refreshWinAppCli; Archive = $request.Archives.WinAppCli; Destination = $winAppRoot }, + [pscustomobject]@{ Name = '.NET'; Refresh = $refreshDotNet; Archive = $request.Archives.DotNet; Destination = $dotNetRoot } + ) + foreach ($component in $components) { + if (-not $component.Refresh) { + continue + } + $archivePath = Join-Path $exchangeRoot $component.Archive + if (-not (Test-Path $archivePath -PathType Leaf)) { + throw "Required payload is missing: $archivePath" + } + Remove-Item $component.Destination -Recurse -Force -ErrorAction SilentlyContinue + $stage = if ($reuseRequested) { 'Refreshing' } else { 'Extracting' } + Write-RunProgress -Stage $stage -Detail "$($component.Name): $($component.Archive)" + Expand-PayloadArchive -Path $archivePath -Destination $component.Destination + $refreshedComponents += $component.Name + } + + if ($refreshProduct) { + if (-not [string]::IsNullOrWhiteSpace($request.Archives.ProductOverlay)) { + $overlayPath = Join-Path $exchangeRoot $request.Archives.ProductOverlay + Write-RunProgress -Stage 'Overlaying' -Detail $request.BuildLabel + Expand-PayloadArchive -Path $overlayPath -Destination $productRoot + } + } + + if (-not [string]::IsNullOrWhiteSpace($request.WebView2Installer)) { + $webView2Version = Get-WebView2RuntimeVersion + if ([string]::IsNullOrWhiteSpace($webView2Version)) { + $installer = Join-Path $exchangeRoot $request.WebView2Installer + if (-not (Test-Path $installer -PathType Leaf)) { + throw "WebView2 installer is missing: $installer" + } + + Write-RunProgress -Stage 'Installing' -Detail 'Microsoft Edge WebView2 Runtime (5 minute limit)' + $installerProcess = Start-Process $installer -ArgumentList '/silent','/install' -PassThru + if (-not $installerProcess.WaitForExit(300000)) { + Stop-Process -Id $installerProcess.Id -Force -ErrorAction SilentlyContinue + throw 'WebView2 installation exceeded five minutes.' + } + $webView2Version = Get-WebView2RuntimeVersion + if ([string]::IsNullOrWhiteSpace($webView2Version)) { + $installerExitCode = $installerProcess.ExitCode + $installerExitCodeHex = '0x{0:X8}' -f ([uint32]([int64]$installerExitCode -band 0xffffffffL)) + throw "WebView2 installation failed with exit code $installerExitCode ($installerExitCodeHex), and no runtime was detected." + } + } + Write-RunProgress -Stage 'Preparing' -Detail "Microsoft Edge WebView2 Runtime $webView2Version" + } + + [ordered]@{ + PayloadFingerprint = $request.PayloadFingerprint + PayloadFiles = @($request.PayloadFiles) + PayloadHashes = $request.PayloadHashes + StagedUtc = [DateTime]::UtcNow.ToString('O') + } | ConvertTo-Json -Depth 4 | Set-Content $stagingManifestPath -Encoding utf8 + + Write-RunProgress -Stage 'Preparing' -Detail 'Locating the test runner and dependencies.' + Get-ChildItem $winAppRoot -Recurse | Unblock-File -ErrorAction SilentlyContinue + + $requestedExecutables = if ($request.PSObject.Properties.Name -contains 'TestExecutables') { + @($request.TestExecutables) + } + elseif ($request.PSObject.Properties.Name -contains 'TestExecutable') { + @($request.TestExecutable) + } + else { + @() + } + if ($requestedExecutables.Count -eq 0) { + throw 'No test executables were requested.' + } + + $testExecutables = @() + foreach ($requestedExecutable in $requestedExecutables) { + $testExe = Get-ChildItem $testRoot -Recurse -Filter $requestedExecutable -File | Select-Object -First 1 + if ($null -eq $testExe) { + throw "$requestedExecutable was not found under $testRoot." + } + $testExecutables += $testExe + } + + $winApp = Get-ChildItem $winAppRoot -Recurse -Filter 'winapp.exe' -File | Select-Object -First 1 + if ($null -eq $winApp) { + throw "winapp.exe was not found under $winAppRoot." + } + if (-not (Test-Path (Join-Path $dotNetRoot 'dotnet.exe'))) { + throw "dotnet.exe was not found under $dotNetRoot." + } + if (-not (Test-Path (Join-Path $productRoot 'PowerToys.exe'))) { + throw "PowerToys.exe was not found under $productRoot." + } + + $env:POWERTOYS_INSTALL_DIR = $productRoot + $env:WINAPP_CLI_PATH = $winApp.FullName + $env:WINAPP_CLI_INVOKE_TIMEOUT_SECONDS = '180' + $env:DOTNET_ROOT = $dotNetRoot + $env:PATH = "$dotNetRoot;$env:PATH" + $env:TF_BUILD = 'true' + $env:platform = $request.Platform + $env:TESTINGPLATFORM_TELEMETRY_OPTOUT = '1' + + $overallExitCode = 0 + for ($testIndex = 0; $testIndex -lt $testExecutables.Count; $testIndex++) { + $testExe = $testExecutables[$testIndex] + $testArguments = @( + '--report-trx', + '--report-trx-filename', "$($testExe.BaseName).trx", + '--results-directory', $localResultsRoot, + '--timeout', $request.SuiteTimeout + ) + $effectiveFilter = $null + if (-not [string]::IsNullOrWhiteSpace($request.Filter)) { + $effectiveFilter = if ($request.Filter -match '[=~!&|()]') { $request.Filter } else { "Name=$($request.Filter)" } + $testArguments += @('--filter', $effectiveFilter) + } + + $testDetail = "$($testExe.Name) ($($testIndex + 1)/$($testExecutables.Count))" + if ($effectiveFilter) { + $testDetail += ": $effectiveFilter" + } + Write-RunProgress -Stage 'Testing' -Detail $testDetail + Set-Location $testExe.DirectoryName + & $testExe.FullName @testArguments + $testExitCode = $LASTEXITCODE + $trxPath = Join-Path $localResultsRoot "$($testExe.BaseName).trx" + if ($testExitCode -eq 0) { + if (-not (Test-Path $trxPath -PathType Leaf)) { + Write-Host "Test runner returned success without producing '$trxPath'." + $testExitCode = 1 + } + else { + [xml]$trx = Get-Content $trxPath -Raw + $counters = $trx.TestRun.ResultSummary.Counters + $total = [int]$counters.total + $executed = [int]$counters.executed + if ($total -eq 0 -or $executed -ne $total) { + Write-Host "Incomplete test run: total=$total, executed=$executed, notExecuted=$([int]$counters.notExecuted)." + $testExitCode = 1 + } + } + } + if ($testExitCode -ne 0 -and $overallExitCode -eq 0) { + $overallExitCode = $testExitCode + } + + Stop-RunProcesses + } + $exitCode = $overallExitCode +} +catch { + $errorMessage = $_.Exception.Message + Write-Host "Local VM guest runner failed: $errorMessage" +} +finally { + if ($null -ne $heartbeatProcess) { + Stop-Process -Id $heartbeatProcess.Id -Force -ErrorAction SilentlyContinue + $heartbeatProcess.Dispose() + } + Stop-RunProcesses + + if ($transcriptStarted) { + Stop-Transcript -ErrorAction SilentlyContinue | Out-Null + } + + New-Item $hostResultsRoot -ItemType Directory -Force | Out-Null + if (Test-Path $localResultsRoot) { + $hostTestResultsRoot = Join-Path $hostResultsRoot 'TestResults' + New-Item $hostTestResultsRoot -ItemType Directory -Force | Out-Null + foreach ($resultItem in Get-ChildItem $localResultsRoot -Force) { + try { + Copy-SharedItem -Path $resultItem.FullName -Destination $hostTestResultsRoot + } + catch { + $exportErrors += "Failed to export '$($resultItem.FullName)': $($_.Exception.Message)" + } + } + } + if (Test-Path $localLog) { + try { + Copy-SharedItem -Path $localLog -Destination $hostResultsRoot + } + catch { + $exportErrors += "Failed to export '$localLog': $($_.Exception.Message)" + } + } + if ($exportErrors.Count -gt 0) { + if ($exitCode -eq 0) { + $exitCode = 1 + } + $exportErrorMessage = $exportErrors -join ' ' + $errorMessage = if ([string]::IsNullOrWhiteSpace($errorMessage)) { + $exportErrorMessage + } + else { + "$errorMessage $exportErrorMessage" + } + } + + $status = [ordered]@{ + Status = if ($exitCode -eq 0) { 'PASS' } else { 'FAIL' } + ExitCode = $exitCode + Error = $errorMessage + ExportErrors = @($exportErrors) + BuildLabel = $request.BuildLabel + Filter = $request.Filter + Platform = $request.Platform + OutputHeartbeatSeconds = $outputHeartbeatSeconds + WebView2Version = $webView2Version + DesktopWidth = 0 + DesktopHeight = 0 + ReusedStagedPayload = $reusedStagedPayload + RefreshedComponents = $refreshedComponents + PayloadFingerprint = $request.PayloadFingerprint + RunId = $request.RunId + StartedUtc = $startedUtc.ToString('O') + CompletedUtc = [DateTime]::UtcNow.ToString('O') + User = [Security.Principal.WindowsIdentity]::GetCurrent().Name + SessionId = (Get-Process -Id $PID).SessionId + OsVersion = [Environment]::OSVersion.Version.ToString() + } + try { + Add-Type -AssemblyName System.Windows.Forms + $desktopBounds = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds + $status.DesktopWidth = $desktopBounds.Width + $status.DesktopHeight = $desktopBounds.Height + } + catch { + } + Write-SharedText -Path (Join-Path $hostResultsRoot 'status.json') -Value ($status | ConvertTo-Json) + Write-RunProgress -Stage 'Completed' -Detail $status.Status +} + +exit $exitCode diff --git a/.github/skills/ui-tests-local-vm/templates/vm/.gitignore b/.github/skills/ui-tests-local-vm/templates/vm/.gitignore new file mode 100644 index 0000000000..cc7d1f82c0 --- /dev/null +++ b/.github/skills/ui-tests-local-vm/templates/vm/.gitignore @@ -0,0 +1,5 @@ +vm.config.psd1 +vm/ +shared/ +*.vhdx +*.credential.xml diff --git a/.github/skills/ui-tests-local-vm/templates/vm/New-UiTestVm.ps1 b/.github/skills/ui-tests-local-vm/templates/vm/New-UiTestVm.ps1 new file mode 100644 index 0000000000..8e5c219bc8 --- /dev/null +++ b/.github/skills/ui-tests-local-vm/templates/vm/New-UiTestVm.ps1 @@ -0,0 +1,585 @@ +# Copyright (c) Microsoft Corporation +# The Microsoft Corporation licenses this file to you under the MIT license. +# See the LICENSE file in the project root for more information. + +<# +.SYNOPSIS +Builds a persistent Hyper-V guest for PowerToys UI tests by running Windows Setup inside the guest. + +.DESCRIPTION +Creates an empty virtual disk, attaches the Windows installation media plus a generated answer-file +ISO, and lets Windows Setup partition and install from inside the virtual machine. Nothing about the +guest disk is ever prepared from the host, so every boot reference Setup writes is correct by +construction. + +An earlier design applied the image with DISM and ran bcdboot on the host against the mounted VHDX. +That is the technique Convert-WindowsImage uses, but its goal is native-VHD boot, so bcdboot records +'vhd=[X:]\path\to.vhdx' device references. Inside a virtual machine that file does not exist - the +VHDX is the disk - and the guest fails with 0xc000000e. Repairing it from the host is not possible +either, because bcdedit resolves drive letters through the host's view and rewrites them straight +back into vhd= references. + +The administrator password is never accepted as a parameter or stored in the configuration file. It +is read from a DPAPI-protected credential file and written to the answer file using the base64 +obfuscation Windows expects, so no plaintext password reaches the media. + +.EXAMPLE +pwsh ./New-UiTestVm.ps1 -InstallMedia D:\media\Win11_25H2_English_Arm64_v2.iso -ListImages + +.EXAMPLE +pwsh ./New-UiTestVm.ps1 -InstallMedia D:\media\Win11_25H2_English_Arm64_v2.iso -ImageName 'Windows 11 Pro' +#> + +[CmdletBinding(SupportsShouldProcess)] +param( + [string]$ConfigPath = (Join-Path $PSScriptRoot 'vm.config.psd1'), + [string]$InstallMedia, + [string]$ImageName = 'Windows 11 Pro', + [string]$CredentialPath = (Join-Path $env:LOCALAPPDATA 'PowerToysUiTestVm\admin.credential.xml'), + [string]$OemPath = (Join-Path $PSScriptRoot 'oem'), + [ValidateRange(5, 720)] + [int]$TimeoutMinutes = 90, + [switch]$ListImages, + [switch]$PlanOnly, + [switch]$AllowReFsVolume, + [switch]$Force +) + +$ErrorActionPreference = 'Stop' + +if ($PSVersionTable.PSVersion.Major -lt 7) { + throw 'Run this script with PowerShell 7 (pwsh).' +} + +function Test-Elevation { + $identity = [Security.Principal.WindowsIdentity]::GetCurrent() + return ([Security.Principal.WindowsPrincipal]$identity).IsInRole( + [Security.Principal.WindowsBuiltInRole]::Administrator) +} + +function ConvertTo-UnattendPassword { + <# + .SYNOPSIS + Applies the base64 obfuscation Windows expects for answer-file passwords. + + .DESCRIPTION + Windows appends the name of the containing element to the password before base64-encoding the + UTF-16LE bytes. This is obfuscation, not encryption, but it keeps the plaintext off the media. + #> + param( + [Parameter(Mandatory)][AllowEmptyString()][string]$Password, + [Parameter(Mandatory)][ValidateSet('Password', 'AdministratorPassword')][string]$Element + ) + + return [Convert]::ToBase64String([Text.Encoding]::Unicode.GetBytes($Password + $Element)) +} + +function Assert-SupportedVmVolume { + <# + .SYNOPSIS + Refuses to store the guest on a ReFS volume such as a Dev Drive. + + .DESCRIPTION + Keeping the VHDX on a Dev Drive has been observed to wedge the Hyper-V management service: + subsequent management calls, including read-only ones, never return, and recovery needs a vmms + restart or a reboot. Hyper-V on plain ReFS is supported, so this refusal is deliberately + conservative - ReFS is a cheap proxy for "Dev Drive", which cannot be detected without elevation. + Use -AllowReFsVolume on a known-good ReFS volume. Only VhdPath and VmPath are checked; the + exchange is ordinary file I/O and needs no such restriction. + #> + param( + [Parameter(Mandatory)][string]$Path, + [switch]$Allow + ) + + $root = [IO.Path]::GetPathRoot([IO.Path]::GetFullPath($Path)) + if ($root -notmatch '^(?[A-Za-z]):\\$') { + return + } + $volume = Get-Volume -DriveLetter $Matches.Letter -ErrorAction SilentlyContinue + if ($null -eq $volume -or [string]$volume.FileSystemType -ne 'ReFS') { + return + } + + $message = "Guest storage '$Path' is on a $($volume.FileSystemType) volume ($($Matches.Letter):). Prefer NTFS: hosting a VHDX on a Dev Drive has been observed to hang the Hyper-V management service." + if ($Allow) { + Write-Warning $message + return + } + throw "BLOCKED: $message Pass -AllowReFsVolume to override." +} + +function Get-MountedImageRoot { + <# + .SYNOPSIS + Returns the drive root of mounted installation media that carries a Windows image. + + .DESCRIPTION + Uses System.IO.DriveInfo rather than Get-Volume: PowerShell 7 reaches the Storage cmdlets through + the Windows PowerShell compatibility layer, where CIM enum properties do not compare reliably. + #> + param([Parameter(Mandatory)][string]$ImagePath) + + foreach ($drive in [IO.DriveInfo]::GetDrives() | Where-Object { $_.DriveType -eq 'CDRom' -and $_.IsReady }) { + $root = $drive.Name.TrimEnd('\') + foreach ($name in 'install.wim', 'install.esd') { + if (Test-Path (Join-Path $root "sources\$name") -PathType Leaf) { + return $root + } + } + } + + throw "No Windows image was found on the mounted media: $ImagePath" +} + +function Get-WindowsImageList { + param([Parameter(Mandatory)][string]$MediaRoot) + + foreach ($name in 'install.wim', 'install.esd') { + $candidate = Join-Path $MediaRoot "sources\$name" + if (Test-Path $candidate -PathType Leaf) { + return @(Get-WindowsImage -ImagePath $candidate) + } + } + + throw "No install.wim or install.esd was found under $MediaRoot\sources." +} + +function New-DataIso { + <# + .SYNOPSIS + Builds a small ISO from a folder using the in-box IMAPI2 file system image COM API. + + .DESCRIPTION + Windows Setup only reads autounattend.xml from removable media, and generation 2 virtual + machines have no floppy controller, so the answer file has to be delivered as a second optical + disc. This avoids a dependency on oscdimg from the ADK. + #> + param( + [Parameter(Mandatory)][string]$SourceFolder, + [Parameter(Mandatory)][string]$Destination, + [string]$VolumeName = 'PTUNATTEND' + ) + + if (-not ('PowerToysUiTestVm.IsoWriter' -as [type])) { + Add-Type -Namespace PowerToysUiTestVm -Name IsoWriter -MemberDefinition @' +[System.Runtime.InteropServices.DllImport("shlwapi.dll", CharSet = System.Runtime.InteropServices.CharSet.Unicode, ExactSpelling = true, PreserveSig = false)] +private static extern void SHCreateStreamOnFileEx(string fileName, uint grfMode, uint dwAttributes, + bool fCreate, System.Runtime.InteropServices.ComTypes.IStream reserved, + out System.Runtime.InteropServices.ComTypes.IStream ppstm); + +public static void Write(object imageStream, string path) +{ + System.Runtime.InteropServices.ComTypes.IStream source = + (System.Runtime.InteropServices.ComTypes.IStream)imageStream; + System.Runtime.InteropServices.ComTypes.IStream target; + // STGM_CREATE | STGM_WRITE, FILE_ATTRIBUTE_NORMAL + SHCreateStreamOnFileEx(path, 0x00001001, 0x80, true, null, out target); + source.CopyTo(target, long.MaxValue, System.IntPtr.Zero, System.IntPtr.Zero); + target.Commit(0); +} +'@ + } + + Remove-Item $Destination -Force -ErrorAction SilentlyContinue + $fileSystemImage = New-Object -ComObject IMAPI2FS.MsftFileSystemImage + try { + $fileSystemImage.FileSystemsToCreate = 3 # ISO9660 | Joliet + $fileSystemImage.VolumeName = $VolumeName + $fileSystemImage.Root.AddTree($SourceFolder, $false) + $resultImage = $fileSystemImage.CreateResultImage() + [PowerToysUiTestVm.IsoWriter]::Write($resultImage.ImageStream, $Destination) + } + finally { + [Runtime.InteropServices.Marshal]::ReleaseComObject($fileSystemImage) | Out-Null + } + + if (-not (Test-Path $Destination -PathType Leaf)) { + throw "The answer-file ISO was not created: $Destination" + } +} + +function New-UnattendContent { + param( + [Parameter(Mandatory)][hashtable]$Configuration, + [Parameter(Mandatory)][AllowEmptyString()][string]$ObfuscatedPassword, + [Parameter(Mandatory)][string]$SelectedImageName, + [Parameter(Mandatory)][string]$ProvisionArguments, + [Parameter(Mandatory)][string]$TemplatePath + ) + + if (-not (Test-Path $TemplatePath -PathType Leaf)) { + throw "Answer-file template was not found: $TemplatePath" + } + + $tokens = @{ + '{{ARCH}}' = $Configuration.ProcessorArchitecture + '{{COMPUTERNAME}}' = $Configuration.ComputerName + '{{LOCALE}}' = $Configuration.Locale + '{{TIMEZONE}}' = $Configuration.TimeZone + '{{ADMINUSER}}' = $Configuration.AdminUserName + '{{ADMINPASSWORD}}' = $ObfuscatedPassword + '{{IMAGENAME}}' = [Security.SecurityElement]::Escape($SelectedImageName) + '{{PROVISIONARGUMENTS}}' = $ProvisionArguments + } + $content = Get-Content $TemplatePath -Raw + foreach ($token in $tokens.GetEnumerator()) { + $content = $content.Replace($token.Key, [string]$token.Value) + } + if ($content -match '\{\{[A-Z]+\}\}') { + throw "The answer-file template still contains unresolved placeholders: $($Matches[0])" + } + [xml]$content | Out-Null + return $content +} + +function Get-GuestScreenLevel { + <# + .SYNOPSIS + Returns the mean intensity of the guest framebuffer, used to tell a text-mode boot prompt from a + graphical Setup screen. + + .DESCRIPTION + The firmware and the "Press any key to boot from CD or DVD" prompt are near-black; Setup's UI is + a saturated blue. Averaging the raw RGB565 bytes separates the two without decoding the image. + #> + param([Parameter(Mandatory)][string]$VmName) + + $namespace = 'root\virtualization\v2' + $service = Get-CimInstance -Namespace $namespace -ClassName Msvm_VirtualSystemManagementService + $system = Get-CimInstance -Namespace $namespace -ClassName Msvm_ComputerSystem -Filter "ElementName='$VmName'" + $settings = Get-CimAssociatedInstance -InputObject $system -ResultClassName Msvm_VirtualSystemSettingData | + Where-Object { $_.VirtualSystemType -eq 'Microsoft:Hyper-V:System:Realized' } | + Select-Object -First 1 + $result = Invoke-CimMethod -InputObject $service -MethodName GetVirtualSystemThumbnailImage -Arguments @{ + TargetSystem = [ciminstance]$settings + WidthPixels = [uint16]160 + HeightPixels = [uint16]120 + } + if ($result.ReturnValue -ne 0 -or $null -eq $result.ImageData -or $result.ImageData.Length -eq 0) { + return 0 + } + + $total = 0 + foreach ($byte in $result.ImageData) { + $total += $byte + } + return [math]::Round($total / $result.ImageData.Length, 2) +} + +function Send-GuestKey { + <# + .SYNOPSIS + Presses a key on the guest's virtual keyboard. + + .DESCRIPTION + Windows installation media prompts "Press any key to boot from CD or DVD". Nothing types that key + in an automated virtual machine, so the firmware falls through to an empty disk and the install + never starts. + #> + param( + [Parameter(Mandatory)][string]$VmName, + [uint32]$KeyCode = 0x0D, + [int]$Count = 1 + ) + + $system = Get-CimInstance -Namespace root\virtualization\v2 -ClassName Msvm_ComputerSystem ` + -Filter "ElementName='$VmName'" + $keyboard = Get-CimAssociatedInstance -InputObject $system -ResultClassName Msvm_Keyboard + for ($index = 0; $index -lt $Count; $index++) { + Invoke-CimMethod -InputObject $keyboard -MethodName TypeKey -Arguments @{ keyCode = $KeyCode } | Out-Null + Start-Sleep -Milliseconds 400 + } +} + +if (-not (Test-Path $ConfigPath -PathType Leaf)) { + throw "Configuration was not found: $ConfigPath. Copy vm.config.example.psd1 to vm.config.psd1 first." +} +$configuration = Import-PowerShellDataFile $ConfigPath +foreach ($key in 'VmName', 'ComputerName', 'VmPath', 'VhdPath', 'DiskSizeGB', 'MemoryStartupGB', + 'ProcessorCount', 'AdminUserName', 'StandardUser', 'ProcessorArchitecture', 'Locale', 'TimeZone', + 'BaselineCheckpointName') { + if (-not $configuration.ContainsKey($key) -or [string]::IsNullOrWhiteSpace([string]$configuration[$key])) { + throw "Configuration value '$key' is missing from $ConfigPath." + } +} +if ($configuration.ProcessorArchitecture -notin @('amd64', 'arm64')) { + throw "ProcessorArchitecture must be amd64 or arm64, not '$($configuration.ProcessorArchitecture)'." +} +$hostArchitecture = switch ($env:PROCESSOR_ARCHITECTURE) { + 'AMD64' { 'amd64' } + 'ARM64' { 'arm64' } + default { $env:PROCESSOR_ARCHITECTURE.ToLowerInvariant() } +} +if ($configuration.ProcessorArchitecture -ne $hostArchitecture) { + throw "Hyper-V cannot run a $($configuration.ProcessorArchitecture) guest on a $hostArchitecture host." +} + +$answerIsoPath = Join-Path $configuration.VmPath 'answer-file.iso' +$answerTemplatePath = Join-Path $PSScriptRoot 'unattend\autounattend.xml.template' +Assert-SupportedVmVolume -Path $configuration.VhdPath -Allow:$AllowReFsVolume +Assert-SupportedVmVolume -Path $configuration.VmPath -Allow:$AllowReFsVolume +$plan = [ordered]@{ + VmName = $configuration.VmName + ComputerName = $configuration.ComputerName + VmPath = $configuration.VmPath + VhdPath = $configuration.VhdPath + DiskSizeGB = $configuration.DiskSizeGB + MemoryStartupGB = $configuration.MemoryStartupGB + ProcessorCount = $configuration.ProcessorCount + SwitchName = [string]$configuration.SwitchName + ProcessorArchitecture = $configuration.ProcessorArchitecture + InstallMedia = $InstallMedia + ImageName = $ImageName + AnswerIso = $answerIsoPath + OemPath = $OemPath + CredentialPath = $CredentialPath + BaselineCheckpointName = $configuration.BaselineCheckpointName +} + +if ($PlanOnly) { + $preview = New-UnattendContent -Configuration $configuration ` + -ObfuscatedPassword (ConvertTo-UnattendPassword -Password 'preview' -Element 'Password') ` + -SelectedImageName $ImageName ` + -ProvisionArguments "-StandardUser $($configuration.StandardUser)" ` + -TemplatePath $answerTemplatePath + $plan.AnswerFileBytes = $preview.Length + $plan.AnswerFileIsWellFormed = $true + [pscustomobject]$plan | ConvertTo-Json -Depth 4 + return +} + +if (-not (Test-Elevation)) { + throw 'BLOCKED: creating a Hyper-V guest requires an elevated host shell.' +} +Import-Module Hyper-V -ErrorAction Stop + +if ([string]::IsNullOrWhiteSpace($InstallMedia) -or -not (Test-Path $InstallMedia -PathType Leaf)) { + throw "Installation media was not found: $InstallMedia" +} + +if ($ListImages) { + Mount-DiskImage -ImagePath $InstallMedia -Access ReadOnly -StorageType ISO | Out-Null + try { + Get-WindowsImageList -MediaRoot (Get-MountedImageRoot -ImagePath $InstallMedia) | + Select-Object ImageIndex, ImageName, ImageDescription + } + finally { + Dismount-DiskImage -ImagePath $InstallMedia | Out-Null + } + return +} + +if (-not (Test-Path $OemPath -PathType Container)) { + throw "OEM payload folder was not found: $OemPath" +} +if (-not (Test-Path (Join-Path $OemPath 'Provision-UiTestVm.ps1') -PathType Leaf)) { + throw "Provision-UiTestVm.ps1 was not found under $OemPath." +} +if (-not (Test-Path $CredentialPath -PathType Leaf)) { + throw "DPAPI credential file was not found: $CredentialPath. Create it with Get-Credential | Export-Clixml." +} +$credential = Import-Clixml $CredentialPath +if ($credential -isnot [pscredential]) { + throw "Credential file does not contain a PSCredential: $CredentialPath" +} +$credentialUser = $credential.UserName -replace '^.*\\', '' +if ($credentialUser -ne $configuration.AdminUserName) { + throw "The credential file is for '$credentialUser', but the configuration expects '$($configuration.AdminUserName)'." +} + +$existingVm = Get-VM -Name $configuration.VmName -ErrorAction SilentlyContinue +if (($null -ne $existingVm -or (Test-Path $configuration.VhdPath -PathType Leaf)) -and -not $Force) { + throw "Virtual machine '$($configuration.VmName)' or its disk already exists. Pass -Force to replace it." +} +if (-not $PSCmdlet.ShouldProcess($configuration.VmName, 'Create the local UI-test Hyper-V guest')) { + return +} + +if ($null -ne $existingVm) { + if ($existingVm.State -ne 'Off') { + Stop-VM -Name $configuration.VmName -TurnOff -Force + } + Get-VMSnapshot -VMName $configuration.VmName -ErrorAction SilentlyContinue | Remove-VMSnapshot -Confirm:$false + Remove-VM -Name $configuration.VmName -Force +} +Remove-Item $configuration.VhdPath -Force -ErrorAction SilentlyContinue +New-Item $configuration.VmPath -ItemType Directory -Force | Out-Null +New-Item (Split-Path $configuration.VhdPath -Parent) -ItemType Directory -Force | Out-Null + +Write-Host 'Validating the requested edition on the installation media...' +Mount-DiskImage -ImagePath $InstallMedia -Access ReadOnly -StorageType ISO | Out-Null +try { + $images = Get-WindowsImageList -MediaRoot (Get-MountedImageRoot -ImagePath $InstallMedia) + $selected = $images | Where-Object { $_.ImageName -eq $ImageName } | Select-Object -First 1 + if ($null -eq $selected) { + throw "Edition '$ImageName' is not on this media. Available: $(($images | ForEach-Object { $_.ImageName }) -join ' | ')" + } + Write-Host "Selected image $($selected.ImageIndex): $($selected.ImageName)" +} +finally { + Dismount-DiskImage -ImagePath $InstallMedia | Out-Null +} + +Write-Host 'Building the answer-file ISO...' +$stagingRoot = Join-Path ([IO.Path]::GetTempPath()) ("ptvm-answer-" + [guid]::NewGuid().ToString('N')) +try { + New-Item $stagingRoot -ItemType Directory -Force | Out-Null + $unattend = New-UnattendContent -Configuration $configuration ` + -ObfuscatedPassword (ConvertTo-UnattendPassword -Password $credential.GetNetworkCredential().Password -Element 'Password') ` + -SelectedImageName $selected.ImageName ` + -ProvisionArguments "-StandardUser $($configuration.StandardUser)" ` + -TemplatePath $answerTemplatePath + Set-Content (Join-Path $stagingRoot 'autounattend.xml') -Value $unattend -Encoding utf8 + $unattend = $null + Copy-Item $OemPath (Join-Path $stagingRoot 'OEM') -Recurse -Force + New-DataIso -SourceFolder $stagingRoot -Destination $answerIsoPath +} +finally { + Remove-Item $stagingRoot -Recurse -Force -ErrorAction SilentlyContinue +} + +Write-Host "Creating virtual machine '$($configuration.VmName)'..." +New-VHD -Path $configuration.VhdPath -SizeBytes ($configuration.DiskSizeGB * 1GB) -Dynamic | Out-Null +$newVmParameters = @{ + Name = $configuration.VmName + Generation = 2 + MemoryStartupBytes = ($configuration.MemoryStartupGB * 1GB) + VHDPath = $configuration.VhdPath + Path = $configuration.VmPath +} +if (-not [string]::IsNullOrWhiteSpace([string]$configuration.SwitchName)) { + $newVmParameters.SwitchName = $configuration.SwitchName +} +New-VM @newVmParameters | Out-Null + +Set-VMProcessor -VMName $configuration.VmName -Count $configuration.ProcessorCount +Set-VMMemory -VMName $configuration.VmName -DynamicMemoryEnabled $false +Set-VM -Name $configuration.VmName ` + -AutomaticCheckpointsEnabled $false -CheckpointType Standard ` + -AutomaticStartAction Nothing -AutomaticStopAction ShutDown +Set-VMFirmware -VMName $configuration.VmName -EnableSecureBoot On -SecureBootTemplate MicrosoftWindows +try { + Set-VMKeyProtector -VMName $configuration.VmName -NewLocalKeyProtector -ErrorAction Stop + Enable-VMTPM -VMName $configuration.VmName -ErrorAction Stop +} +catch { + Write-Warning "The virtual TPM could not be enabled: $($_.Exception.Message)" +} +Enable-VMIntegrationService -VMName $configuration.VmName -Name 'Guest Service Interface' + +Add-VMDvdDrive -VMName $configuration.VmName -Path $InstallMedia +Add-VMDvdDrive -VMName $configuration.VmName -Path $answerIsoPath +$installDvd = Get-VMDvdDrive -VMName $configuration.VmName | Where-Object { $_.Path -eq $InstallMedia } +Set-VMFirmware -VMName $configuration.VmName -FirstBootDevice $installDvd + +Write-Host 'Starting Windows Setup in the guest...' +Start-VM -Name $configuration.VmName +# The media waits for "Press any key to boot from CD or DVD" and gives up without it. Stop as soon as +# Setup's own UI is up: Enter there activates Cancel and aborts the installation. +for ($attempt = 0; $attempt -lt 10; $attempt++) { + Start-Sleep -Seconds 2 + $screenLevel = try { Get-GuestScreenLevel -VmName $configuration.VmName } catch { 0 } + if ($screenLevel -gt 12) { + Write-Host " Setup is on screen after $($attempt * 2)s; no further key presses." + break + } + try { + Send-GuestKey -VmName $configuration.VmName -Count 1 + } + catch { + Write-Verbose "Key press failed: $($_.Exception.Message)" + } +} + +Write-Host 'Waiting for Setup and provisioning to finish...' +$deadline = [DateTime]::UtcNow.AddMinutes($TimeoutMinutes) +$provisioning = $null +$desktopUser = $null +$lastConnectionError = $null +$lastFailureStage = 'connect' +$attempt = 0 +do { + Start-Sleep -Seconds 20 + $attempt++ + try { + $lastFailureStage = 'connect' + $session = New-PSSession -VMName $configuration.VmName -Credential $credential -ErrorAction Stop + $lastFailureStage = 'query' + try { + $guestState = Invoke-Command -Session $session -ScriptBlock { + param($InteractiveUser) + # PowerShell Direct lands on the guest's in-box PowerShell 5.1, whose parser rejects a + # multi-line statement as a hashtable value ("The hash literal was incomplete"). Build + # the values first so this scriptblock parses on 5.1 as well as 7. + $provisioningJson = $null + if (Test-Path C:\OEM\ProvisioningReady.json -PathType Leaf) { + $provisioningJson = Get-Content C:\OEM\ProvisioningReady.json -Raw + } + $interactiveExplorer = @(Get-Process explorer -IncludeUserName -ErrorAction SilentlyContinue | + Where-Object { $_.UserName -like "*\$InteractiveUser" } | + Select-Object -First 1 -ExpandProperty UserName) + [pscustomobject]@{ + Provisioning = $provisioningJson + DesktopUser = $interactiveExplorer + } + } -ArgumentList $configuration.StandardUser + $provisioning = $guestState.Provisioning + $desktopUser = @($guestState.DesktopUser) | Select-Object -First 1 + $lastConnectionError = $null + } + finally { + Remove-PSSession $session -ErrorAction SilentlyContinue + } + } + catch { + $lastConnectionError = $_.Exception.Message + } + # Surface why the guest is still not answering; silence here hides real failures for the whole timeout. + if (($attempt % 6) -eq 0) { + if ($null -ne $lastConnectionError) { + # A guest-side failure looks nothing like an unreachable guest: reporting both as + # "not reachable" hid a scriptblock parse error until the timeout expired. + $stagePrefix = if ($lastFailureStage -eq 'connect') { 'not reachable' } else { 'reachable, but the guest query failed' } + $state = "${stagePrefix}: $lastConnectionError" + } + else { + $state = "reachable; provisioned=$(-not [string]::IsNullOrWhiteSpace($provisioning)) desktopUser='$desktopUser'" + } + Write-Host " still waiting after $([int]($attempt * 20 / 60)) minute(s) - $state" + } + # Provisioning ends with a reboot into the standard-user desktop, so both signals are required. + if (-not [string]::IsNullOrWhiteSpace($provisioning) -and -not [string]::IsNullOrWhiteSpace($desktopUser)) { + break + } + if ([DateTime]::UtcNow -ge $deadline) { + $reason = if ($null -ne $lastConnectionError) { + if ($lastFailureStage -eq 'connect') { + "the guest never answered PowerShell Direct: $lastConnectionError" + } + else { + "PowerShell Direct connected but the readiness query failed: $lastConnectionError" + } + } + elseif ([string]::IsNullOrWhiteSpace($provisioning)) { + 'C:\OEM\ProvisioningReady.json was never written' + } + else { + "no interactive Explorer session for $($configuration.StandardUser) appeared" + } + throw "The guest did not finish provisioning within $TimeoutMinutes minute(s): $reason. The virtual machine and its disk are preserved; inspect the console with Get-VmConsoleImage.ps1 or vmconnect.exe." + } +} while ($true) + +Write-Host "Interactive desktop user: $desktopUser" +Write-Host 'Detaching installation media...' +Get-VMDvdDrive -VMName $configuration.VmName | Remove-VMDvdDrive +Remove-Item $answerIsoPath -Force -ErrorAction SilentlyContinue + +Write-Host "Creating baseline checkpoint '$($configuration.BaselineCheckpointName)'..." +Checkpoint-VM -Name $configuration.VmName -SnapshotName $configuration.BaselineCheckpointName + +$plan.Provisioning = $provisioning | ConvertFrom-Json +$plan.DesktopUser = $desktopUser +$plan.Checkpoint = $configuration.BaselineCheckpointName +[pscustomobject]$plan | ConvertTo-Json -Depth 5 diff --git a/.github/skills/ui-tests-local-vm/templates/vm/Reset-LocalVm.ps1 b/.github/skills/ui-tests-local-vm/templates/vm/Reset-LocalVm.ps1 new file mode 100644 index 0000000000..309b8bc7c4 --- /dev/null +++ b/.github/skills/ui-tests-local-vm/templates/vm/Reset-LocalVm.ps1 @@ -0,0 +1,106 @@ +# Copyright (c) Microsoft Corporation +# The Microsoft Corporation licenses this file to you under the MIT license. +# See the LICENSE file in the project root for more information. + +<# +.SYNOPSIS +Manages clean-baseline checkpoints for the Hyper-V UI-test guest. + +.DESCRIPTION +Restoring a standard checkpoint returns the guest to the exact state it was captured in, including +the logged-on desktop, which makes it the fast equivalent of recreating the VM. Use it for every +clean-profile claim instead of trusting a long-lived, mutated guest. + +.EXAMPLE +pwsh ./Reset-LocalVm.ps1 -List + +.EXAMPLE +pwsh ./Reset-LocalVm.ps1 -Restore + +.EXAMPLE +pwsh ./Reset-LocalVm.ps1 -CreateBaseline -CheckpointName 'webview2-installed' +#> + +[CmdletBinding(SupportsShouldProcess, DefaultParameterSetName = 'List')] +param( + [string]$ConfigPath = (Join-Path $PSScriptRoot 'vm.config.psd1'), + + [Parameter(ParameterSetName = 'List')] + [switch]$List, + + [Parameter(Mandatory, ParameterSetName = 'Restore')] + [switch]$Restore, + + [Parameter(Mandatory, ParameterSetName = 'Create')] + [switch]$CreateBaseline, + + [Parameter(ParameterSetName = 'Restore')] + [Parameter(ParameterSetName = 'Create')] + [string]$CheckpointName, + + [Parameter(ParameterSetName = 'Restore')] + [switch]$StartAfterRestore +) + +$ErrorActionPreference = 'Stop' + +if (-not (Test-Path $ConfigPath -PathType Leaf)) { + throw "Configuration was not found: $ConfigPath" +} +$configuration = Import-PowerShellDataFile $ConfigPath +$effectiveCheckpoint = if ([string]::IsNullOrWhiteSpace($CheckpointName)) { + $configuration.BaselineCheckpointName +} +else { + $CheckpointName +} + +try { + Import-Module Hyper-V -ErrorAction Stop + Get-VMHost -ErrorAction Stop | Out-Null +} +catch { + throw 'BLOCKED: Hyper-V is not accessible from this shell. Run from an elevated PowerShell 7 terminal, or add this account to the local "Hyper-V Administrators" group.' +} + +$vm = Get-VM -Name $configuration.VmName -ErrorAction SilentlyContinue +if ($null -eq $vm) { + throw "Virtual machine '$($configuration.VmName)' does not exist." +} + +if ($CreateBaseline) { + if ($PSCmdlet.ShouldProcess($vm.Name, "Create checkpoint '$effectiveCheckpoint'")) { + Get-VMCheckpoint -VMName $vm.Name -Name $effectiveCheckpoint -ErrorAction SilentlyContinue | + Remove-VMCheckpoint -Confirm:$false + Checkpoint-VM -Name $vm.Name -SnapshotName $effectiveCheckpoint + } +} +elseif ($Restore) { + $checkpoint = Get-VMCheckpoint -VMName $vm.Name -Name $effectiveCheckpoint -ErrorAction SilentlyContinue + if ($null -eq $checkpoint) { + throw "Checkpoint '$effectiveCheckpoint' does not exist for '$($vm.Name)'." + } + if ($PSCmdlet.ShouldProcess($vm.Name, "Restore checkpoint '$effectiveCheckpoint'")) { + if ($vm.State -eq 'Running') { + Stop-VM -Name $vm.Name -TurnOff -Force + } + Restore-VMCheckpoint -VMName $vm.Name -Name $effectiveCheckpoint -Confirm:$false + if ($StartAfterRestore) { + Start-VM -Name $vm.Name + } + } +} + +$vm = Get-VM -Name $configuration.VmName +[pscustomobject]@{ + VmName = $vm.Name + State = [string]$vm.State + BaselineCheckpointName = $configuration.BaselineCheckpointName + Checkpoints = @(Get-VMCheckpoint -VMName $vm.Name -ErrorAction SilentlyContinue | ForEach-Object { + [pscustomobject]@{ + Name = $_.Name + CreationTime = $_.CreationTime + ParentCheckpointName = $_.ParentCheckpointName + } + }) +} | ConvertTo-Json -Depth 4 diff --git a/.github/skills/ui-tests-local-vm/templates/vm/Start-LocalVm.ps1 b/.github/skills/ui-tests-local-vm/templates/vm/Start-LocalVm.ps1 new file mode 100644 index 0000000000..8c668a6c3b --- /dev/null +++ b/.github/skills/ui-tests-local-vm/templates/vm/Start-LocalVm.ps1 @@ -0,0 +1,170 @@ +# Copyright (c) Microsoft Corporation +# The Microsoft Corporation licenses this file to you under the MIT license. +# See the LICENSE file in the project root for more information. + +<# +.SYNOPSIS +Starts the persistent Hyper-V UI-test guest and optionally waits for PowerShell Direct. + +.EXAMPLE +pwsh ./Start-LocalVm.ps1 -Wait -TimeoutMinutes 20 +#> + +[CmdletBinding()] +param( + [string]$ConfigPath = (Join-Path $PSScriptRoot 'vm.config.psd1'), + [string]$CredentialPath = (Join-Path $env:LOCALAPPDATA 'PowerToysUiTestVm\admin.credential.xml'), + [switch]$Wait, + [ValidateRange(1, 720)] + [int]$TimeoutMinutes = 30, + [ValidateSet('Default', 'Constrained')] + [string]$ResourceProfile = 'Default', + [switch]$PlanOnly +) + +$ErrorActionPreference = 'Stop' + +if ($PSVersionTable.PSVersion.Major -lt 7) { + throw 'Run this script with PowerShell 7 (pwsh).' +} +if (-not (Test-Path $ConfigPath -PathType Leaf)) { + throw "Configuration was not found: $ConfigPath. Copy vm.config.example.psd1 to vm.config.psd1 first." +} +$configuration = Import-PowerShellDataFile $ConfigPath + +$memoryGB = if ($ResourceProfile -eq 'Constrained') { + if ($configuration.ContainsKey('ConstrainedMemoryStartupGB')) { $configuration.ConstrainedMemoryStartupGB } else { 4 } +} +else { + $configuration.MemoryStartupGB +} +$processorCount = if ($ResourceProfile -eq 'Constrained') { + if ($configuration.ContainsKey('ConstrainedProcessorCount')) { $configuration.ConstrainedProcessorCount } else { 1 } +} +else { + $configuration.ProcessorCount +} + +if ($PlanOnly) { + [pscustomobject]@{ + VmName = $configuration.VmName + ResourceProfile = $ResourceProfile + MemoryStartupGB = $memoryGB + ProcessorCount = $processorCount + } | ConvertTo-Json + return +} + +try { + Import-Module Hyper-V -ErrorAction Stop + Get-VMHost -ErrorAction Stop | Out-Null +} +catch { + throw 'BLOCKED: Hyper-V is not accessible from this shell. Run from an elevated PowerShell 7 terminal, or add this account to the local "Hyper-V Administrators" group.' +} + +$vm = Get-VM -Name $configuration.VmName -ErrorAction SilentlyContinue +if ($null -eq $vm) { + throw "Virtual machine '$($configuration.VmName)' does not exist. Create it with New-UiTestVm.ps1." +} + +if ($vm.State -eq 'Off') { + Set-VMMemory -VMName $vm.Name -StartupBytes ($memoryGB * 1GB) + Set-VMProcessor -VMName $vm.Name -Count $processorCount +} +elseif ($vm.MemoryStartup -ne ($memoryGB * 1GB) -or $vm.ProcessorCount -ne $processorCount) { + Write-Warning "The guest is $($vm.State); the $ResourceProfile profile will apply after the next stop." +} + +if ($vm.State -ne 'Running') { + Start-VM -Name $vm.Name +} + +if ($Wait) { + if (-not (Test-Path $CredentialPath -PathType Leaf)) { + throw "DPAPI credential file was not found: $CredentialPath" + } + $credential = Import-Clixml $CredentialPath + $deadline = [DateTime]::UtcNow.AddMinutes($TimeoutMinutes) + $session = $null + do { + try { + $session = New-PSSession -VMName $vm.Name -Credential $credential -ErrorAction Stop + break + } + catch { + if ([DateTime]::UtcNow -ge $deadline) { + throw "PowerShell Direct did not answer for '$($vm.Name)' within $TimeoutMinutes minute(s). The guest and its disk are preserved; watch the console with vmconnect.exe localhost $($vm.Name)." + } + Start-Sleep -Seconds 5 + } + } while ($true) + + try { + $standardUser = [string]$configuration.StandardUser + $desktopDeadline = [DateTime]::UtcNow.AddMinutes(2) + do { + $desktopReady = Invoke-Command -Session $session -ScriptBlock { + param($User) + @(Get-Process explorer -IncludeUserName -ErrorAction SilentlyContinue | + Where-Object { $_.UserName -like "*\$User" }).Count -gt 0 + } -ArgumentList $standardUser + if ($desktopReady -or [DateTime]::UtcNow -ge $desktopDeadline) { break } + Start-Sleep -Seconds 5 + } while ($true) + + if (-not $desktopReady) { + Write-Warning "No interactive Explorer session exists for '$standardUser'; repairing auto-logon and restarting once." + $autoLogonScript = Join-Path $PSScriptRoot 'oem\Set-UiTestAutoLogon.ps1' + if (-not (Test-Path $autoLogonScript -PathType Leaf)) { + $autoLogonScript = [IO.Path]::GetFullPath((Join-Path $PSScriptRoot '..\oem\Set-UiTestAutoLogon.ps1')) + } + if (-not (Test-Path $autoLogonScript -PathType Leaf)) { + throw "Auto-logon repair helper was not found: $autoLogonScript" + } + Invoke-Command -Session $session -FilePath $autoLogonScript -ArgumentList $standardUser | Out-Null + if ($null -ne $session) { Remove-PSSession $session -ErrorAction SilentlyContinue } + $session = $null + Restart-VM -Name $vm.Name -Force + + do { + try { + if ($null -eq $session) { + $session = New-PSSession -VMName $vm.Name -Credential $credential -ErrorAction Stop + } + $desktopReady = Invoke-Command -Session $session -ScriptBlock { + param($User) + @(Get-Process explorer -IncludeUserName -ErrorAction SilentlyContinue | + Where-Object { $_.UserName -like "*\$User" }).Count -gt 0 + } -ArgumentList $standardUser + if ($desktopReady) { break } + } + catch { + if ($null -ne $session) { Remove-PSSession $session -ErrorAction SilentlyContinue } + $session = $null + } + + if ([DateTime]::UtcNow -ge $deadline) { + throw "The '$standardUser' interactive desktop did not appear after auto-logon repair." + } + Start-Sleep -Seconds 5 + } while ($true) + } + } + finally { + if ($null -ne $session) { Remove-PSSession $session -ErrorAction SilentlyContinue } + } +} + +$vm = Get-VM -Name $configuration.VmName +[pscustomobject]@{ + VmName = $vm.Name + State = [string]$vm.State + ResourceProfile = $ResourceProfile + MemoryStartupGB = [math]::Round($vm.MemoryStartup / 1GB, 1) + ProcessorCount = $vm.ProcessorCount + Uptime = [string]$vm.Uptime + Checkpoints = @(Get-VMCheckpoint -VMName $vm.Name -ErrorAction SilentlyContinue | ForEach-Object { $_.Name }) + Console = "vmconnect.exe localhost `"$($vm.Name)`"" + ControlChannel = "vmbus://$($vm.Name)" +} | ConvertTo-Json diff --git a/.github/skills/ui-tests-local-vm/templates/vm/Stop-LocalVm.ps1 b/.github/skills/ui-tests-local-vm/templates/vm/Stop-LocalVm.ps1 new file mode 100644 index 0000000000..6756dcfd39 --- /dev/null +++ b/.github/skills/ui-tests-local-vm/templates/vm/Stop-LocalVm.ps1 @@ -0,0 +1,84 @@ +# Copyright (c) Microsoft Corporation +# The Microsoft Corporation licenses this file to you under the MIT license. +# See the LICENSE file in the project root for more information. + +<# +.SYNOPSIS +Stops the persistent Hyper-V UI-test guest while preserving its disk and checkpoints. + +.EXAMPLE +pwsh ./Stop-LocalVm.ps1 +#> + +[CmdletBinding()] +param( + [string]$ConfigPath = (Join-Path $PSScriptRoot 'vm.config.psd1'), + [string]$CredentialPath = (Join-Path $env:LOCALAPPDATA 'PowerToysUiTestVm\admin.credential.xml'), + # Saves the running state instead of shutting the guest down, so the next start resumes instantly. + [switch]$Save, + [switch]$TurnOff +) + +$ErrorActionPreference = 'Stop' + +if (-not (Test-Path $ConfigPath -PathType Leaf)) { + throw "Configuration was not found: $ConfigPath" +} +$configuration = Import-PowerShellDataFile $ConfigPath + +try { + Import-Module Hyper-V -ErrorAction Stop + Get-VMHost -ErrorAction Stop | Out-Null +} +catch { + throw 'BLOCKED: Hyper-V is not accessible from this shell. Run from an elevated PowerShell 7 terminal, or add this account to the local "Hyper-V Administrators" group.' +} + +$vm = Get-VM -Name $configuration.VmName -ErrorAction SilentlyContinue +if ($null -eq $vm) { + throw "Virtual machine '$($configuration.VmName)' does not exist." +} + +if ($vm.State -eq 'Running') { + if (-not $Save -and -not $TurnOff) { + if (-not (Test-Path $CredentialPath -PathType Leaf)) { + throw "DPAPI credential file was not found: $CredentialPath" + } + + $credential = Import-Clixml $CredentialPath + $session = New-PSSession -VMName $vm.Name -Credential $credential + try { + # Validate the protected guest-local credential; repair it only when it no longer authenticates. + $autoLogonScript = Join-Path $PSScriptRoot 'oem\Set-UiTestAutoLogon.ps1' + if (-not (Test-Path $autoLogonScript -PathType Leaf)) { + $autoLogonScript = [IO.Path]::GetFullPath((Join-Path $PSScriptRoot '..\oem\Set-UiTestAutoLogon.ps1')) + } + if (-not (Test-Path $autoLogonScript -PathType Leaf)) { + throw "Auto-logon persistence helper was not found: $autoLogonScript" + } + Invoke-Command ` + -Session $session ` + -FilePath $autoLogonScript ` + -ArgumentList ([string]$configuration.StandardUser) | Out-Null + } + finally { + Remove-PSSession $session -ErrorAction SilentlyContinue + } + } + + if ($Save) { + Save-VM -Name $vm.Name + } + elseif ($TurnOff) { + Stop-VM -Name $vm.Name -TurnOff -Force + } + else { + Stop-VM -Name $vm.Name -Force + } +} + +$vm = Get-VM -Name $configuration.VmName +[pscustomobject]@{ + VmName = $vm.Name + State = [string]$vm.State +} | ConvertTo-Json diff --git a/.github/skills/ui-tests-local-vm/templates/vm/unattend/autounattend.xml.template b/.github/skills/ui-tests-local-vm/templates/vm/unattend/autounattend.xml.template new file mode 100644 index 0000000000..3d549507e2 --- /dev/null +++ b/.github/skills/ui-tests-local-vm/templates/vm/unattend/autounattend.xml.template @@ -0,0 +1,184 @@ + + + + + + + {{LOCALE}} + + {{LOCALE}} + {{LOCALE}} + {{LOCALE}} + {{LOCALE}} + + + + true + Never + + + true + + + + + + OnError + + 0 + true + + + 1 + EFI + 300 + + + 2 + MSR + 128 + + + 3 + Primary + true + + + + + 1 + 1 + + FAT32 + + + 2 + 2 + + + 3 + 3 + + C + NTFS + + + + + + + + + /IMAGE/NAME + {{IMAGENAME}} + + + + 0 + 3 + + + + + + + + + {{COMPUTERNAME}} + {{TIMEZONE}} + + + true + + + + + 1 + Bypass the online account requirement + reg add "HKLM\Software\Microsoft\Windows\CurrentVersion\OOBE" /v BypassNRO /t REG_DWORD /d 1 /f + + + + + + + + {{LOCALE}} + {{LOCALE}} + {{LOCALE}} + {{LOCALE}} + + + true + + + 1 + + + + true + true + true + true + true + 3 + + + + + {{ADMINUSER}} + {{ADMINUSER}} + Administrators + Local UI-test VM control account + + {{ADMINPASSWORD}} + false</PlainText> + </Password> + </LocalAccount> + </LocalAccounts> + </UserAccounts> + <AutoLogon> + <Enabled>true</Enabled> + <LogonCount>999</LogonCount> + <Username>{{ADMINUSER}}</Username> + <Password> + <Value>{{ADMINPASSWORD}}</Value> + <PlainText>false</PlainText> + </Password> + </AutoLogon> + <FirstLogonCommands> + <SynchronousCommand wcm:action="add"> + <Order>1</Order> + <Description>Copy the OEM payload from the answer media</Description> + <CommandLine>cmd.exe /c for %i in (D E F G H I J) do @if exist %i:\OEM\Provision-UiTestVm.ps1 xcopy /e /i /y %i:\OEM C:\OEM</CommandLine> + </SynchronousCommand> + <SynchronousCommand wcm:action="add"> + <Order>2</Order> + <Description>Provision the UI-test guest</Description> + <CommandLine>powershell.exe -NoLogo -NoProfile -ExecutionPolicy Bypass -File C:\OEM\Provision-UiTestVm.ps1 {{PROVISIONARGUMENTS}}</CommandLine> + </SynchronousCommand> + <SynchronousCommand wcm:action="add"> + <Order>3</Order> + <Description>Restart into the standard-user desktop</Description> + <CommandLine>shutdown.exe /r /t 5 /c "PowerToys UI-test provisioning complete"</CommandLine> + </SynchronousCommand> + </FirstLogonCommands> + </component> + </settings> +</unattend> diff --git a/.github/skills/ui-tests-local-vm/templates/vm/vm.config.example.psd1 b/.github/skills/ui-tests-local-vm/templates/vm/vm.config.example.psd1 new file mode 100644 index 0000000000..5580c920d4 --- /dev/null +++ b/.github/skills/ui-tests-local-vm/templates/vm/vm.config.example.psd1 @@ -0,0 +1,37 @@ +@{ + # Copy this file to vm.config.psd1 in the same folder. Never commit vm.config.psd1. + # The administrator password is never stored here: it is imported from the DPAPI credential file. + + VmName = 'PowerToysUiTest-Win11' + ComputerName = 'PTUITEST' + + # Guest storage. Keep it outside the repository. + # Prefer NTFS. Keeping a VHDX on a Dev Drive has been observed to wedge the Hyper-V management + # service until vmms is restarted or the host is rebooted. Hyper-V on plain ReFS is supported, so + # New-UiTestVm.ps1 refuses ReFS only as a conservative proxy for Dev Drive; pass + # -AllowReFsVolume to override. The scaffold and shared exchange have no such restriction. + VmPath = 'D:\PowerToysUiTestVm\vm' + VhdPath = 'D:\PowerToysUiTestVm\vm\PowerToysUiTest.vhdx' + DiskSizeGB = 128 + + # Default resource profile. Lower to 1 vCPU / 4 GB only after the suite is green. + MemoryStartupGB = 8 + ProcessorCount = 4 + ConstrainedMemoryStartupGB = 4 + ConstrainedProcessorCount = 1 + + # Set to '' for a fully isolated guest. PowerShell Direct works without any network adapter. + SwitchName = 'Default Switch' + + # Accounts. The password comes from the DPAPI credential file, not from this file. + AdminUserName = 'PTAdmin' + StandardUser = 'PTUser' + + # arm64 or amd64. Must match the installation media and the guest payloads. + ProcessorArchitecture = 'amd64' + Locale = 'en-US' + TimeZone = 'UTC' + + # Standard checkpoints capture memory, so restoring returns to a logged-on desktop immediately. + BaselineCheckpointName = 'provisioned-baseline' +} diff --git a/.github/skills/ui-tests-migration/SKILL.md b/.github/skills/ui-tests-migration/SKILL.md index 632c8007d3..73415022e9 100644 --- a/.github/skills/ui-tests-migration/SKILL.md +++ b/.github/skills/ui-tests-migration/SKILL.md @@ -1,6 +1,6 @@ --- name: ui-tests-migration -description: "Migrate PowerToys module UI tests from the legacy WinAppDriver/Selenium harness (Microsoft.PowerToys.UITest) to the new winappcli-based harness (Microsoft.PowerToys.UITest.Next). Use when asked to port/convert/rewrite/modernize a module's UI tests to the .Next framework, create a new [Module].UITests.Next project alongside existing legacy tests, or stand up brand-new winappcli UI tests for a module that has none by reading its human test sign-off markdown. Covers the API mapping (By/Element/Session/UITestBase, KeyboardHelper/MouseHelper/ClipboardHelper), project/csproj scaffolding, naming rules, common PowerToys test recipes (toggle a module, read an activation shortcut, fire a global hotkey, inspect the clipboard, discover overlay/editor windows), build/run validation, and CI-stability hardening for fewer CI iterations. Keywords: UI test, UITests, UITestAutomation.Next, winappcli, WinAppDriver, Selenium, migrate, port, modernize, .Next, MSTest, CI stability, flaky test, stabilize on CI." +description: "Migrate and stabilize PowerToys UI tests from WinAppDriver/Selenium to Microsoft.PowerToys.UITest.Next and winappcli. Use for ports, new UITest projects, flaky CI tests, persistent local-VM validation on Hyper-V, resettable clean-baseline runs, Explorer/Shell selection, preview handlers, thumbnail providers, hotkey activation, stateful process lifecycle, composed WinUI/WebView visual baselines, or cross-window/foreground failures. Covers APIs, scaffolding, test design, diagnostics, agentic execution, and CI hardening. Keywords: UI test, UITests, UITestAutomation.Next, winappcli, WinAppDriver, Selenium, local VM, Hyper-V, checkpoint, migrate, port, flaky, CI stability, Explorer, Shell extension, WebView2." license: Complete terms in LICENSE.txt --- @@ -27,6 +27,9 @@ Use this skill when the task is to: - **Stand up brand-new** `.Next` UI tests for a module that has **no** UI tests at all, by reading the module's human test **sign-off markdown** (e.g. `ColorPickerUITest.md`) and turning each manual checklist item into an automated test. +- **Validate a new or migrated suite in a local Windows VM** through an unattended + build/package/deploy/run/TRX/diagnose loop. Use a retained VM for fast iteration and a restored + baseline checkpoint when clean-profile behavior matters. This skill is the *how*: the framework differences, the API mapping, the project scaffolding, the naming rules, the recurring PowerToys test recipes, and the build/validate loop. The *what* (which @@ -48,6 +51,16 @@ module, which tests) comes from the calling prompt. > `Session.FromProcess`, a DPI-aware `app.manifest`, cursor centering, and patient hotkey > activation are all there because real runs needed them (see > [references/patterns-and-pitfalls.md](references/patterns-and-pitfalls.md)). +> - **Stateful/visual reference (validated 15/15 across Win10 x64, Win11 x64, and ARM64)**: +> [PeekFilePreviewTests.cs](../../../src/modules/peek/Peek.UITests.Next/PeekFilePreviewTests.cs) +> demonstrates stable Explorer Shell selection, toggle-hotkey activation, process-preserving +> pinning tests, renderer readiness, and composed WinUI/WebView visual baselines. +> - **Explorer/Shell-extension reference (validated across x64 and ARM64 CI)**: +> [FileExplorerAddonsTests.cs](../../../src/modules/previewpane/PreviewPane.UITests/FileExplorerAddonsTests.cs) +> demonstrates class-scoped runner reuse, one-time Shell restart, state-aware Preview pane +> activation, exact Shell selection, deterministic icon sizes, provider-log readiness, and +> failure media captured before Explorer teardown. Read +> [references/explorer-shell-tests.md](references/explorer-shell-tests.md) before testing Explorer. ## Required reads (in order) @@ -70,12 +83,18 @@ module, which tests) comes from the calling prompt. for the recurring PowerToys patterns (toggle a module + verify its process, read the activation shortcut from a `ShortcutControl`, fire a global hotkey reliably, inspect the clipboard, discover overlay/editor windows) and the gotchas that bite during migration. -7. **[references/ci-stability.md](references/ci-stability.md)** — the CI-stability capstone: the - Win32-window vs UIA-element mental model, five design principles that keep a port green on a slow - CI agent (authoritative-signal retries over fixed sleeps, invoke-vs-physical-click, screen-capture - cold-start, toggle-state guards, on-screen/DPI/clean-profile hygiene), and a **pre-flight - checklist** to apply BEFORE the first CI push so the first run *validates* instead of *discovers*. - Read this to spend one CI iteration instead of six. +7. **[references/explorer-shell-tests.md](references/explorer-shell-tests.md)** — required for tests + involving Explorer, preview handlers, thumbnail providers, Shell selection, view modes, or Shell + restarts. Covers lifecycle boundaries, authoritative signals, and failure evidence. +8. **[references/ci-stability.md](references/ci-stability.md)** — the CI-stability capstone: the + Win32-window vs UIA-element mental model, state-boundary worksheet, stable-sample waits, retry + semantics, foreground/integrity constraints, process lifecycle, composed visual capture, and a + **pre-flight checklist** to apply BEFORE the first CI push so the first run *validates* instead of + *discovers*. Read this to spend one CI iteration instead of six. +9. **[ui-tests-local-vm](../ui-tests-local-vm/SKILL.md)** — the live desktop execution loop: + scaffold or reuse a persistent Hyper-V VM, run as a true standard user, refresh only + changed payloads, iterate through durable TRX/evidence, and restore or recreate the baseline for + clean-profile validation. ## Pick your scenario @@ -110,23 +129,37 @@ Create a TODO list and work top-to-bottom. Each step links to the reference that ```markdown - [ ] 1. Identify the module + scenario (A port / B greenfield) — this SKILL.md "Pick your scenario" +- [ ] 1a. Read the module's developer docs — `doc/devdocs/modules/<module>.md` (if the exact file is + missing, search `doc/devdocs/`, including `doc/devdocs/common/`) — to learn its + development-cycle specifics BEFORE writing tests: how its shell extensions / context menus + register, whether they need a **Release** build (`NDEBUG`) or a **signed** sparse MSIX package, + and any Explorer-restart or first-run needs. Skipping this produces opaque failures — e.g. a + context-menu entry never appears because a Debug build compiles registration out, or an + unsigned `.msix` fails to register (`0x800B0100`). - [ ] 2. Read the two reference examples (ColorPicker .Next + ScreenRuler legacy) end-to-end - [ ] 3. Inventory the source: • Scenario A → list every [TestMethod] + shared helper in the legacy project • Scenario B → read the module's sign-off .md; list each manual checklist item + • For each workflow → list every external boundary (runner, Explorer, HWND, renderer, + compositor, child process) and its authoritative ready signal — references/porting-workflow.md - [ ] 4. Internalize the deltas — references/framework-differences.md - [ ] 5. Scaffold the new project (csproj from template, name per the table, register in .slnx) — references/project-setup.md - [ ] 6. Re-implement tests, mapping each API as you go — references/api-mapping.md + recipes from references/patterns-and-pitfalls.md +- [ ] 6a. If Explorer/Shell is involved, apply references/explorer-shell-tests.md - [ ] 7. Apply the CI-stability checklist BEFORE building — references/ci-stability.md - (authoritative-signal retries not fixed sleeps, navigation via UIA invoke, Win32 window/overlay - detection, screen-capture cold-start handling, DPI manifest, single-module enable, first-run - suppression) + (stable authoritative signals, retry classification, foreground/integrity, lifecycle reset + scope, non-activating helper processes, composed capture, DPI manifest, single-module enable, + first-run suppression) - [ ] 8. Build the new project to exit code 0 — this SKILL.md "Build & validate" -- [ ] 9. (If a live desktop is available) run the tests; otherwise report that they build and are - ready to run, and summarize coverage vs. the source +- [ ] 9. Run one deterministic test in the local VM and diagnose the first failure + — ../ui-tests-local-vm/SKILL.md +- [ ] 10. Rerun the focused test after each fix, then widen to the complete module suite with bounded + timeouts; parse TRX and verify durable evidence export +- [ ] 11. If the local VM is unavailable or unsupported, run on another live desktop or report the exact + environmental blocker; do not silently stop at compile validation ``` ## Build & validate @@ -145,6 +178,9 @@ dotnet restore src\modules\<Module>\Tests\<Module>.UITests.Next\<Module>.UITests tools\build\build.cmd -Path src\modules\<Module>\Tests\<Module>.UITests.Next -Platform x64 -Configuration Debug # Exit code 0 = success; non-zero = failure. On failure read the errors log next to the project: # build.<Configuration>.<Platform>.errors.log +# Do not substitute `dotnet build` when UITestAutomation.Next's COM references are in the graph: +# .NET SDK MSBuild cannot run ResolveComReference and fails with MSB4803. Use the repo script or +# Visual Studio's full-framework MSBuild.exe; use `dotnet restore` only to create project.assets.json. # 2. Run (needs a live desktop). A .Next project is a Microsoft.Testing.Platform Exe — run the # produced exe directly with a TRX report; filter to one test/category for a tight loop. @@ -154,15 +190,30 @@ $exe = "<repo>\x64\Debug\tests\<Module>.UITests.Next\net10.0-windows10.0.26100.0 # Exit 0 = all passed. Parse the .trx for per-test outcomes + failure messages. ``` +- **Default to persistent local VM validation — + [ui-tests-local-vm](../ui-tests-local-vm/SKILL.md).** It keeps the interactive desktop and staged + tools, refreshes only changed archives, and returns durable status/TRX/evidence. Do not + modify stabilized tests merely to improve a VM-specific pass rate when the task only asks whether + the execution loop works. Finish clean-profile claims from a restored known baseline or a fresh + named VM volume. - **Design for CI stability up-front — [references/ci-stability.md](references/ci-stability.md).** Before the first push, walk its pre-flight checklist (authoritative-signal retries instead of fixed - sleeps, navigation via UIA invoke, Win32 window/overlay detection, screen-capture cold-start - handling, DPI manifest, single-module enable, first-run suppression). Most "passes local, fails CI" - loops come from skipping one of these; applying them proactively is how you spend one CI iteration - instead of six. + sleeps, navigation via UIA invoke, interaction-scoped foreground checks, non-activating helpers, + Win32 window/overlay detection, screen-capture cold-start handling, DPI manifest, single-module + enable, first-run suppression). Most "passes local, fails CI" loops come from skipping one of + these; applying them proactively is how you spend one CI iteration instead of six. - **Run it in a loop: write → build → run → diagnose → repeat.** UI tests surface environment-real failures (DPI scaling, cursor position, hotkey-arming races) that only a live run reveals. Start with one deterministic test (e.g. the activation/toggle test), get it green, then widen. +- **Diagnose from the artifacts, not from the assertion message.** Every failed test attaches a + desktop screenshot, and in pipeline mode an MP4 of the run. **Open them before forming any theory** + — especially before concluding the product is broken. An assertion can only say "found 0 rows"; the + screenshot says whether the list was empty or whether your selector was wrong. This is the single + highest-leverage habit in the agentic loop: skipping it cost ~8 iterations and a confident but + entirely wrong product-defect report on File Locksmith (see + [references/patterns-and-pitfalls.md](references/patterns-and-pitfalls.md) Pitfall 26). If there is + no video, find out why rather than proceeding blind — the harness now prints the reason (a clean + Windows image without the Visual C++ redistributable cannot load the native encoder). - **First, run the *legacy* suite once for a baseline — and run it ELEVATED.** The legacy harness launches PowerToys via `ProcessStartInfo { Verb = "runas" }` (elevated), so a **non-elevated** test host can't complete the launch and **every test fails at startup with a misleading `Win32Exception` @@ -188,10 +239,14 @@ $exe = "<repo>\x64\Debug\tests\<Module>.UITests.Next\net10.0-windows10.0.26100.0 - **Do NOT delete or edit the legacy `[Module].UITests` project** in Scenario A. The `.Next` project lives alongside it; removing the old one is a separate, explicit decision for the maintainers. -- **Do NOT touch product code.** This is a test-only migration. If a test needs a UIA hook that - doesn't exist (e.g. an `AutomationId` or a hidden automation-peer TextBlock), flag it for the user - rather than silently editing the module. (The ColorPicker example's `ColorHexAutomationPeer` hook - is a documented, pre-existing exception — see its class remarks.) +- **Do NOT change product behaviour.** This is a test-only migration. The one sanctioned product edit + is adding **`AutomationProperties.AutomationId`** to a control that is otherwise unaddressable — an + icon-only button whose label lives in a tooltip has no UIA Name at all, and the alternative is a + brittle coordinate click. Use `AutomationProperties.AutomationId`, never `x:Name` (which also emits + a code-behind field); see [references/patterns-and-pitfalls.md](references/patterns-and-pitfalls.md) + Recipe 16. Anything larger — a hidden automation-peer TextBlock, a new property, a state string — + must be flagged for the user instead. (ColorPicker's `ColorHexAutomationPeer` hook is a documented, + pre-existing exception — see its class remarks.) - **Do NOT port the legacy plumbing literally.** No Selenium `Actions`, no `WindowsDriver`/`WindowsElement`, no `By.XPath`/`By.CssSelector`, no `:4723`. Map them to the winappcli idioms in [references/api-mapping.md](references/api-mapping.md). @@ -202,7 +257,13 @@ $exe = "<repo>\x64\Debug\tests\<Module>.UITests.Next\net10.0-windows10.0.26100.0 (or skip with an explanation) rather than asserting on something you can't actually read. - **Do NOT introduce new third-party NuGet dependencies.** The `.Next` harness is intentionally dependency-free (MSTest only). Use the Win32-based helpers it already ships. +- **Do NOT retry a toggle hotkey blindly.** Once any target window appears, wait for initialization; + resending the chord may close a healthy window. Restart only after a terminal readiness failure. +- **Do NOT replace or weaken visual baselines before proving capture is correct.** Foreground HWND, + DWM z-order, composed WebView content, theme, and platform are separate failure sources. ## What is NICE to do -- **Improve the new UT Test framework if you see such opportunity**. The new framework works only with a few modules and may lack something other requires. If you see the old test uses something that we don't have in a new framework and it's handy, don't hesiate to port it to a new one. Or you may see the test uses a bunch of extra helpers ouside of test framework, which also may be a signal. \ No newline at end of file +- **Improve the framework when a helper is demonstrably reusable.** Prefer small composable APIs + (`WaitHelper`, `WindowControl`, `ExplorerShell`) over module-specific mega-helpers. Keep product + semantics such as Peek pin-state preservation in the module test. diff --git a/.github/skills/ui-tests-migration/references/api-mapping.md b/.github/skills/ui-tests-migration/references/api-mapping.md index 41b61dfbb5..ceb707d160 100644 --- a/.github/skills/ui-tests-migration/references/api-mapping.md +++ b/.github/skills/ui-tests-migration/references/api-mapping.md @@ -32,6 +32,8 @@ is the `Microsoft.PowerToys.UITest.Next` equivalent. "—" means no direct membe | `IsWindowOpen(name)` | `WindowsFinder.ListByApp(proc).Count > 0` | Or `SessionHelper.IsRunning(scope)` for a process check. | | `RestartScopeExe(enableModules?)` | `RestartScope(enableModules?)` | Returns the fresh `Session`. | | `ExitScopeExe()` | *(automatic)* `sessionHelper.StopIfStarted()` in `TestCleanup` | Rarely needed manually. | +| class-level manual launch/cache | `protected override bool ReuseScopeAcrossTests => true` | Keeps the runner/scope alive across a test class; each test still rebinds its `Session`. | +| capture before custom cleanup | `CaptureFailureArtifactsBeforeCleanupAsync(tail?)` | Call first in derived `[TestCleanup]` before closing diagnostic windows. No-op for passing tests. | ## `PowerToysModule` enum (values differ!) @@ -111,6 +113,7 @@ is the `Microsoft.PowerToys.UITest.Next` equivalent. "—" means no direct membe | — | `Inspect(depth, interactive, …)` → `JsonElement` | `winapp ui inspect --json` tree (the ColorPicker editor walk). | | — | `WaitForElement(by, t)`, `WaitFor(Func<bool>, t)` | Built-in waits. | | — | `Screenshot(path, element?, captureScreen?)` / `TryScreenshot(...)` | | +| — | `ScreenshotVisibleWindow(path)` | Captures composed WinUI/WebView content from DWM-visible desktop pixels; requires a window-scoped foreground session. | ### `MouseActionType` → `MouseHelper` @@ -135,6 +138,12 @@ is the `Microsoft.PowerToys.UITest.Next` equivalent. "—" means no direct membe | Clear clipboard | `ClipboardHelper.Clear()` | | Set clipboard | `ClipboardHelper.SetText("v")` | | Wait for clipboard to change | `ClipboardHelper.WaitForText(ignoredValue, timeoutMS)` | +| Wait for consecutive stable observations | `WaitHelper.WaitForStable(observe, isMatch, timeoutMS, requiredConsecutiveMatches, …)` | +| Wait for exact HWND foreground | `WindowControl.WaitForForeground(hwnd, timeoutMS, stableSamples)` | +| Diagnose current foreground owner | `WindowControl.GetForegroundWindowInfo()` | +| Stop an exact process tree and await exit | `WindowControl.TryKillProcessTreeByNameAndWait(name, timeoutMS)` | +| Set/read exact Explorer Shell selection | `ExplorerShell.SetSelectionAndWaitForStable(...)` / `TryGetSelection(hwnd)` | +| Set/read Explorer view mode + icon size | `ExplorerShell.SetViewModeAndIconSizeAndWait(hwnd, ViewMode.Icons, iconSize)` | Uses Shell automation, not a timing-sensitive keyboard shortcut. | | Seed module on/off baseline | `SettingsConfigHelper.ConfigureGlobalModuleSettings("ColorPicker", …)` | | Edit a module's own settings.json | `SettingsConfigHelper.UpdateModuleSettings(name, default, json => {…})` | diff --git a/.github/skills/ui-tests-migration/references/ci-stability.md b/.github/skills/ui-tests-migration/references/ci-stability.md index b762704c75..6f28879a6e 100644 --- a/.github/skills/ui-tests-migration/references/ci-stability.md +++ b/.github/skills/ui-tests-migration/references/ci-stability.md @@ -11,7 +11,7 @@ and pitfalls by number). The canonical worked example for everything below is th [ScreenRuler.UITests.Next/TestHelper.cs](../../../../src/modules/MeasureTool/Tests/ScreenRuler.UITests.Next/TestHelper.cs). > **Why this matters for iteration count.** Almost every "flaky on CI, fine locally" failure traces to -> one of five root causes below. A dev box hides all of them (higher-res display, warmed caches, a +> one of the root causes below. A dev box hides them (higher-res display, warmed caches, a > profile that already dismissed first-run windows, a human not touching the mouse). If you design for > them up-front, the first CI run tends to be green; if you don't, you rediscover them one push at a > time. @@ -43,6 +43,24 @@ The operating rules that fall out of this: empties the very next frame. For a capture module, detect windows with Win32 `EnumWindows`, not UIA (Pitfall 18). +### Model the workflow as owned state boundaries + +Before writing retries, make a table for every external boundary. Peek's stable workflow was: +`Explorer HWND → Shell selection/focus → hotkey → Peek HWND/title → renderer state → DWM pixels`. + +| Boundary | Owner | Authoritative signal | Stability / recovery | +|---|---|---|---| +| Top-level window | Win32 | Exact expected HWND exists and owns foreground | Retry foreground; diagnose foreground PID/title/elevation | +| Explorer selection | Shell view | Exact selected path set plus focused path | Require consecutive samples; repair through `ExplorerShell` | +| Explorer layout | Shell view | Exact view mode and icon size | Set through `ExplorerShell`; verify item geometry | +| Shell extension | Explorer + provider | Provider log plus visible content | Drive through Explorer in the user's context; avoid test-host-only COM probes | +| Toggle hotkey | Runner/module | Any target HWND appeared | Stop resending once a window exists; wait for initialization | +| Renderer | Product automation peer | Product state is `Loaded`; loading UI is gone | Restart the process tree only after a bounded terminal failure | +| Visible output | DWM/compositor | Captured pixels match baseline | Capture composed desktop pixels; do not rewrite baselines first | + +For each boundary, name: **action, owner, signal, stable-sample count, retry semantics, and reset +scope**. A wait without these fields usually becomes an arbitrary sleep or a destructive retry. + --- ## Principle 1 — Assert on an **authoritative signal**, retry until true (not a fixed sleep) @@ -66,6 +84,22 @@ the clipboard is empty. Both adapt to a slow agent for free. > Corollary: **fail with the signal in the message.** `Assert.Fail("overlay never appeared after N > attempts")` tells you *which* signal missed on CI; `Assert.IsTrue(x)` tells you nothing. +### Observed once is not necessarily stable + +Explorer selection, foreground, window bounds, and renderer state can briefly match and then regress +while deferred UI initializes. Use `WaitHelper.WaitForStable` when readiness must survive several +samples. A mismatch resets the count and may run a recovery action. Keep the observation structured +so timeout diagnostics can report the last state rather than only `false`. + +Classify every retry before implementing it: + +- **Idempotent**: setting text, selecting an exact Shell item, bringing a known HWND forward. Safe to + repeat while the signal is false. +- **Toggle**: activation hotkeys, pin buttons, toggle buttons. Re-read state before repeating; once + any target window appears, do not resend a show/hide chord. +- **Destructive/resetting**: killing a process, recreating WebView2, restarting capture. Use only after + patient in-place readiness has failed, because the reset discards progress and state. + --- ## Principle 2 — The input-method decision: UIA **invoke** vs physical **click** @@ -101,16 +135,33 @@ window holds the foreground, Windows' **foreground lock** puts it *behind* that and looks **exactly** like the interactivity race, but it's occlusion. This is a prime "passes local, flakes on CI" cause: on CI the Settings window used to enable the module is still foreground when the overlay appears. The harness guards against it — `Element.Click()` calls `Session.EnsureForeground()` -first, which raises the target with the foreground-lock-defeating `AttachThreadInput` dance -(`WindowControl.TryBringToForeground`) before the real click, and still falls back to `Invoke()` if the -raise doesn't take. Diagnose it via winappcli's `isForeground` flag on `list-windows`; UIA `invoke` is -immune because it never touches coordinates. +first. `WindowControl.TryBringToForeground` is best-effort; use `WaitForForeground` when exact +ownership is required and inspect `GetForegroundWindowInfo()` on failure. UIA `Invoke` is immune to +occlusion because it never touches coordinates. -**Elevation must match.** Injected input — a synthetic hotkey *or* a real click — from a process at a -*different* integrity level than the PowerToys runner is blocked by UIPI: a non-elevated host can't -drive an elevated runner, and an elevated host's foreground window blocks the non-elevated runner's -hook. Run the test host at the **same** elevation as the runner (the `.Next` harness launches the -runner non-elevated, so run the tests non-elevated too). +**Integrity boundaries can make foreground activation impossible.** `AttachThreadInput` does not +override UIPI. A visible elevated helper console can permanently block a non-elevated Explorer or +module window. Pipeline helpers must start hidden (the shared WinAppDriver uses `-WindowStyle Hidden`). +Log the foreground process, title, and elevation before adding more retries. Match the test host and +runner integrity where possible; modules configured to run non-elevated still require their own +foreground handoff. + +"Start hidden" means **hidden at process creation**, not enumerate-and-hide afterward. The latter is +a time-of-check/time-of-use race: a shell-launched console can be created after the hide pass and own +foreground just as the target opens. For same-integrity direct children, use `UseShellExecute=false` +plus `CreateNoWindow=true`. If an elevated host must ask Explorer to create a medium-integrity helper, +do not route it through `.cmd`/`start /b`; use a non-activating launcher such as +`WScript.Shell.Run(..., 0, False)` with an encoded command. Smoke-test the launcher independently: +the helper must establish its readiness precondition while exposing no main window and never becoming +the foreground PID. + +**Require foreground only when the interaction requires it.** Explorer context menus, SendInput, +coordinate clicks, and drags need stable ownership because focus or z-order changes the operation. +Coordinate-free UIA search/invoke does not. For those flows, an exact-HWND assertion can be a false +negative when WinUI recreates its top-level window or the scheduled interactive host observes +`GetForegroundWindow()==0`; use process/window presence plus the authoritative UIA-ready element, +while keeping foreground activation best-effort and diagnostic. Let the interaction boundary decide — +do not globally weaken strict Explorer or physical-input checks. --- @@ -146,9 +197,23 @@ to select" can *deselect* an already-engaged control — and an innocent retry c guard on `GetProperty("ToggleState")` yourself (as `SelectToolAndVerify` / `ReengageTool` do). This is also why a *retry loop* around a toggle is dangerous unless it re-reads state each pass. +The same state rule applies to global hotkeys that toggle a window. Revalidate the input source, +send the chord once, wait for any target HWND, then wait for expected title/content without +resending. If initialization reaches a terminal timeout, stop the full process tree and begin a +fresh attempt. + --- -## Principle 5 — Everything on-screen, DPI-correct, from a clean profile +## Principle 5 — Match process lifecycle to scenario state + +Closing a window, waiting for input idle, and terminating a process tree are different operations. +Some state lives only in a long-running process. Peek's pinned geometry must preserve that process, +while an explicitly unpinned reopen is safer with a fresh process. Encode this as a lifecycle matrix +per scenario; use `TryKillProcessTreeByNameAndWait` only where state should be discarded. + +--- + +## Principle 6 — Everything on-screen, DPI-correct, from a clean profile The whole "passes local, fails CI" cluster is environment differences a dev box papers over. Each has a one-time fix; do them all up-front: @@ -163,19 +228,80 @@ a one-time fix; do them all up-front: --- +## Principle 7 — Trace every action with a timestamp so a hang shows where it stuck + +An assertion failure gives you a stack trace; a **hang or CI timeout does not** — the process is +killed with no exception and the recording only shows a frozen window, so you cannot tell *which* step +blocked. Emit a **timestamped line before every meaningful UI action**: on CI the **last line before +the kill** names the stuck step, and the gap between two lines shows *which* step was slow (a classic +context menu that took 15 s is obvious from the timestamps, with no profiler). + +```csharp +// Last line before a CI timeout = the step that hung; gaps between lines = the slow step. +private void Step(string message) => + TestContext.WriteLine($"[{DateTime.UtcNow:HH:mm:ss.fff}] {message}"); +``` + +```csharp +Step($"Opening Explorer at '{folder}'"); +var explorer = OpenExplorer(folder); +Step("Selecting fixture"); +SelectFiles(explorer, fixture); +Step("Opening context menu"); +var menu = OpenContextMenu(explorer); // if this blocks, the trail ends on this line +Step($"Invoking '{ContextMenuCaption}'"); +``` + +- **Log *before* the blocking call, not after** — a line printed after the action can never appear for + the action that hung. +- **`TestContext.WriteLine`, not `Console.WriteLine`** — MTP captures it into the TRX + `<Output><StdOut>` attributed to the test, so it reaches the CI test log and the failure attachment. +- **UTC, millisecond precision** — read per-step durations straight from adjacent lines. +- **Name the target** (file, window, control, awaited signal), not just the verb. +- **One line per external interaction** (open / select / menu / invoke / wait-for-window), so the trail + reads as the workflow, not noise. + +This complements Principle 1 (a signal-bearing `Assert.Fail` says *what* was missing) and a rich +one-shot failure dump (Peek's `GetActivationDiagnostics`: foreground PID/title/elevation, process and +window inventory): the trail says *where* it stuck, the dump says *why*. + +--- + +## Composed visuals: HWND, renderer, and pixels are separate + +`PrintWindow` can omit WinUI/WebView2/compositor content. Use `Session.ScreenshotVisibleWindow`, which +requires exact foreground ownership and captures DWM extended-frame screen pixels. The capture helper +temporarily raises the target topmost and restores its prior state so another window cannot contaminate +the frame. `VisualAssert` retries pixel comparison because `Loaded` may precede the final composed +frame. Before changing a baseline or similarity threshold, verify title, renderer state, theme, +platform, foreground HWND, z-order, dimensions, and captured content. + +--- + ## Pre-flight CI-stability checklist Tick these **before** the first CI push. Each maps to a principle/recipe above; skipping one is a likely extra CI iteration. ```markdown -- [ ] app.manifest (PerMonitorV2) wired into the csproj — any coordinate-exact test (P5 / Pitfall 12) -- [ ] Base ctor enables ONLY the module under test (P5 / Recipe 9) -- [ ] First-run/what's-new suppression confirmed for capture & coordinate modules (P5 / Pitfall 17) -- [ ] Gestures anchored to ScreenCenter(), cursor moved in steps, never to the current cursor (P5 / Recipe 11) +- [ ] app.manifest (PerMonitorV2) wired into the csproj — any coordinate-exact test (P6 / Pitfall 12) +- [ ] Base ctor enables ONLY the module under test (P6 / Recipe 9) +- [ ] First-run/what's-new suppression confirmed for capture & coordinate modules (P6 / Pitfall 17) +- [ ] Gestures anchored to ScreenCenter(), cursor moved in steps, never to the current cursor (P6 / Recipe 11) - [ ] Navigation & the first interaction go through By.AccessibilityId(...).Click() (invoke under the hood) (P2 / Recipe 1) - [ ] Window/overlay presence via WindowControl/WindowsFinder (Win32) — never a UIA walk of a live-capture window (mental model / P3 / Pitfall 18) - [ ] Every wait polls an authoritative signal to a deadline — no bare Thread.Sleep standing in for "wait until ready" (P1) +- [ ] Multi-part readiness uses consecutive stable samples and reports the last structured observation (P1) +- [ ] Every meaningful UI action is preceded by a timestamped TestContext.WriteLine so a hang/timeout shows the stuck step (P7) +- [ ] Every retry is classified as idempotent, toggle, or destructive; toggle hotkeys stop after any target HWND appears +- [ ] Exact foreground requirements use `WaitForForeground`; failures record foreground PID/title/elevation +- [ ] Pipeline helper processes have no visible foreground-capable windows; detached consoles start hidden +- [ ] Process lifecycle is explicit per scenario: close/preserve/input-idle/process-tree restart +- [ ] Renderer readiness is separate from window/title readiness; composed visuals use visible DWM capture +- [ ] Explorer-driven tests verify exact selected paths and focused path via `ExplorerShell` (Recipe 13) +- [ ] Explorer view mode/icon size is set through `ExplorerShell`, then independently verified by item geometry +- [ ] Shell handlers are activated by Explorer; readiness requires provider logs plus visible output +- [ ] Derived cleanup captures failure artifacts before closing the window that explains the failure - [ ] Capture modules: in-place gesture retry + single re-engage; overlay detected via Win32 (P3 / Recipe 12) - [ ] Toggle/ToggleButton presses guarded on the current ToggleState (P4) - [ ] Clipboard via ClipboardHelper (STA + retry); no hand-rolled STA wrapper (Recipe 5) diff --git a/.github/skills/ui-tests-migration/references/explorer-shell-tests.md b/.github/skills/ui-tests-migration/references/explorer-shell-tests.md new file mode 100644 index 0000000000..257e1e20d4 --- /dev/null +++ b/.github/skills/ui-tests-migration/references/explorer-shell-tests.md @@ -0,0 +1,211 @@ +# Explorer and Shell-extension UI tests + +Use this reference for tests that open File Explorer, depend on Shell selection/focus, register a +preview or thumbnail handler, change Explorer's view, or restart the Explorer shell. The canonical +implementation is +[FileExplorerAddonsTests.cs](../../../../src/modules/previewpane/PreviewPane.UITests/FileExplorerAddonsTests.cs). + +## Model three independent lifetimes + +Do not treat "Explorer test" as one process lifecycle: + +| Lifetime | Typical policy | Why | +|---|---|---| +| PowerToys runner + Settings | One launch per test class (`ReuseScopeAcrossTests`) | Keeps module registration alive and avoids repeated cold startup | +| Explorer shell/taskbar | Restart at most once after registration changes | Shell caches associations; repeated restarts are expensive and disruptive | +| Explorer file window | Fresh window per test | Isolates folder, selection, view, and temporary files | + +```csharp +protected override bool ReuseScopeAcrossTests => true; + +[TestInitialize] +public void PrepareTest() => CloseExplorerFileWindows(); + +[TestCleanup] +public async Task CleanupTest() +{ + await CaptureFailureArtifactsBeforeCleanupAsync(TimeSpan.FromSeconds(2)); + CloseExplorerFileWindows(); +} +``` + +The base rebinds a lightweight `Session` on every test but does not relaunch a healthy shared scope. +If that scope dies, the next test relaunches it. The inherited class cleanup stops what the class +launched after the final test. + +## Restart Explorer without killing descendants + +If a Shell restart is required, terminate only `explorer.exe`, not its process tree: + +```csharp +foreach (var process in Process.GetProcessesByName("explorer")) +{ + process.Kill(); + process.WaitForExit(10_000); +} +``` + +`Kill(entireProcessTree: true)` also terminates processes launched from Explorer. In a validation VM +that included `msvsmon`; the apparent remote-debugger "auto stop" was caused by the test itself. +Guard the restart with a class-wide flag so it occurs once. + +## Use the Shell view as the selection authority + +A highlighted UIA row does not prove the selected path set or focused item that Shell extensions +consume. Establish and verify both through `ExplorerShell`: + +```csharp +var selection = ExplorerShell.SetSelectionAndWaitForStable( + new IntPtr(explorer.WindowHandle), + new[] { filePath }, + focusedPath: filePath, + timeoutMS: 30_000, + requiredConsecutiveMatches: 4); + +Assert.IsTrue(selection.Succeeded, + $"Selection did not settle; focus={selection.LastObservation?.FocusedPath ?? "<none>"}."); +``` + +Shell automation may transiently return a null `FolderItem` while a copied file is entering the +view. The framework treats that as not-ready and retries; module tests should not enumerate Shell COM +items themselves. + +## Harden menu- and selection-driving steps for slow agents + +CI agents are far slower than a local VM and ARM64 timing differs from x64, so races that never appear +locally - even on a 1-core guest - surface on CI, and you often cannot reproduce them. Reason from the +failure video/screenshot and make each step self-correcting instead of one-shot. + +**Re-establish the selection before every attempt.** A slow agent re-renders the Explorer view +asynchronously after a module toggles or the shell restarts and drops the selection, so the +right-click targets an unready view and no menu appears. Re-run `SetSelectionAndWaitForStable` inside +the retry loop, not once before it, and reopen a fresh window if it keeps failing: + +```csharp +while (DateTime.UtcNow < deadline) +{ + if (!TrySelectStable(explorer, filePaths)) // non-throwing SetSelectionAndWaitForStable + { + if (++failures >= 2) { explorer = OpenExplorer(folder); failures = 0; } // stale/empty window + continue; + } + + var menu = OpenContextMenu(explorer); + if (menu is not null && HasCommand(menu)) { break; } +} +``` + +**Treat transient popups as retryable.** A menu popup (for example "Show more options") can vanish +between finding it and invoking it, so a raw `Invoke()` throws. Catch it, return null, and let the +caller reopen the menu rather than failing the test. + +**Verify fixtures actually reached disk.** `Bitmap.Save` can lag on a slow/ARM64 agent; a genuinely +empty folder is not a slow-to-render view. Assert `File.Exists` (retry the save once) immediately +after creating a fixture, and prefer committed test assets (Peek's `TestAssets`) over runtime-generated +images when arch-portability matters. + +**Size timeouts for the slow path.** A tier-2 ("Show more options") menu can take ~15s to render under +CI load; use surface waits of >=25s and retry-loop deadlines of >=90s. On a fast agent these return +immediately, so there is no happy-path cost. + +## Set view mode and icon size directly + +Do not rely on `Ctrl+Shift+1/2/3` for thumbnail tests. Under CI load Explorer can drop the shortcut +while remaining foreground and stay in Details view. Set the authoritative Shell state: + +```csharp +var view = ExplorerShell.SetViewModeAndIconSizeAndWait( + new IntPtr(explorer.WindowHandle), + ExplorerShell.ViewMode.Icons, + iconSize: 256, + timeoutMS: 5_000); + +Assert.IsTrue(view.Succeeded, + $"View did not settle; mode={view.LastObservation?.Mode}, size={view.LastObservation?.IconSize}."); +``` + +Still assert on the visible layout. A Shell state match proves the setting, while tile geometry proves +Explorer laid it out. For example, extra-large tiles should be materially taller than a Details row; +then large and medium captures should have strictly descending heights. + +## Drive Shell extensions through Explorer + +Exercise the user workflow, not a shortcut from the test host. A direct +`IShellItemImageFactory.GetImage` call can run under a different integrity/registration context and +return `REGDB_E_CLASSNOTREG` even though non-elevated Explorer can activate the per-user handler. + +### Preview handler sequence + +1. Open a fresh Explorer file window. +2. Detect whether the Preview pane is already visible; its state persists across windows/runs. +3. If absent, foreground Explorer, send `Alt+P`, and require the empty-pane marker to appear. Retry + the guarded toggle only while the pane remains absent. +4. Capture an empty-pane baseline. +5. Set exact Shell selection/focus for the file. +6. Require the PowerToys provider log with no launch failure. +7. Require a visible pixel change in the preview region. + +### Thumbnail provider sequence + +1. Open an empty temporary folder in Explorer. +2. Clear the provider's old log and copy the fixture into the folder. +3. Refresh Explorer and establish exact Shell selection/focus. +4. Set `ViewMode.Icons` and the desired icon size (for example 256 px). +5. Require the provider log before accepting the rendered tile. +6. Capture the file item at each required size; assert non-generic visual detail and descending tile + geometry. + +Do not confuse the Preview pane with thumbnail output. Thumbnail tests assert the file tile/icon in +the main folder view; the Preview pane may remain empty and is irrelevant. + +## Use layered evidence + +One signal is not enough for Shell rendering: + +| Evidence | Proves | +|---|---| +| Effective extension association | Shell points the extension at the expected CLSID | +| Provider process log | PowerToys' handler was actually activated | +| Exact Shell selection/view state | Explorer consumed the intended file in the intended layout | +| Visible pixels/item capture | The user-visible output rendered and is not generic/blank | + +Capture both the empty/before state and rendered/after state for previews. For thumbnails, capture +the item rectangle at each requested size. A passing assertion should survive inspection of those +artifacts by a human. + +## Preserve failure evidence before cleanup + +Derived MSTest cleanup runs before the base cleanup. If it closes Explorer first, the recording ends +on Settings or the desktop and hides the failure. Begin derived cleanup with: + +```csharp +await CaptureFailureArtifactsBeforeCleanupAsync(TimeSpan.FromSeconds(2)); +``` + +The method is a no-op for passing tests, holds failed UI briefly when requested, captures a terminal +desktop PNG, finalizes the recording, and is idempotent with the base cleanup. + +## Failure classification + +| Symptom | Likely boundary | Response | +|---|---|---| +| Highlighted row but wrong file opens | Shell selection/focus | Use `SetSelectionAndWaitForStable`; inspect last snapshot | +| Details row instead of thumbnail tile | Shell view mode/icon size | Use `SetViewModeAndIconSizeAndWait`; verify tile geometry | +| `REGDB_E_CLASSNOTREG` only from test-host COM | Activation context | Remove direct COM probe; let Explorer activate the provider | +| Provider log exists, pixels unchanged | Renderer/compositor | Wait for visible output; attach before/after captures | +| Remote debugger dies during Shell restart | Process-tree teardown | Kill only Explorer, never its descendants | +| Video ends after Explorer disappears | Cleanup ordering | Capture failure artifacts before closing Explorer | +| No context menu after a module toggle on a slow agent | Dropped selection / async view render | Re-select before every attempt; widen surface waits; reopen a stale window | +| Fixture folder is genuinely empty (0 items) | Fixture not flushed to disk | Verify `File.Exists` + retry the save; prefer committed assets | + +## Pre-flight checklist + +- [ ] Runner lifetime, Shell restart count, and file-window lifetime are explicit. +- [ ] Exact selected paths and focused path come from `ExplorerShell`. +- [ ] View mode/icon size comes from `ExplorerShell`, not keyboard shortcuts. +- [ ] Shell extensions are activated by Explorer in the user context. +- [ ] Provider logs and visible output are both asserted. +- [ ] Preview-pane toggles are state-guarded and verified. +- [ ] Explorer restarts kill only Explorer, not the process tree. +- [ ] Failure artifacts are finalized before derived cleanup closes Explorer. +- [ ] Focused scenario passes first, then all scenarios pass on x64 and ARM64 CI-equivalent runs. diff --git a/.github/skills/ui-tests-migration/references/framework-differences.md b/.github/skills/ui-tests-migration/references/framework-differences.md index bd991adfff..7e0b614365 100644 --- a/.github/skills/ui-tests-migration/references/framework-differences.md +++ b/.github/skills/ui-tests-migration/references/framework-differences.md @@ -125,7 +125,14 @@ tests often did by hand: kills + relaunches, reapplies size, returns the fresh `Session`. - **Class-shared window:** override `protected bool ReuseScopeAcrossTests => true;` to launch once per class and reuse the window across `[TestMethod]`s (skips per-test hygiene/relaunch). Use for smoke - suites with many cheap cases against one window. Default is per-test isolation. + suites with many cheap cases against one window, or Shell-extension suites whose registration + belongs to one long-lived runner. Per-test setup may still close/recreate *secondary* windows such + as Explorer file windows. If the shared scope dies, the next test relaunches it. The inherited + class cleanup stops the scope after the final test. Default is per-test isolation. +- **Failure capture vs. derived cleanup:** MSTest runs a derived `[TestCleanup]` before the base + cleanup. If derived cleanup closes the window that explains a failure, call + `CaptureFailureArtifactsBeforeCleanupAsync(...)` first; otherwise the recording's final frame and + desktop screenshot show only the post-cleanup desktop. ## 6. Multi-window discovery diff --git a/.github/skills/ui-tests-migration/references/patterns-and-pitfalls.md b/.github/skills/ui-tests-migration/references/patterns-and-pitfalls.md index a8c805c33d..ff1fbb603a 100644 --- a/.github/skills/ui-tests-migration/references/patterns-and-pitfalls.md +++ b/.github/skills/ui-tests-migration/references/patterns-and-pitfalls.md @@ -315,6 +315,97 @@ string result = MeasureWithRetry(() => { MouseHelper.MoveTo(cx, cy); MouseHelper > Each test spawns its own module process = its own capture session = its own cold-start; there is no > cross-test warming, so every capture test must tolerate the first-frame delay on its own. +## Recipe 13 — Establish exact File Explorer selection + +Do not use UIA child discovery or timing-sensitive `Shift+Arrow` input for Explorer selection. The +Shell view is the authority consumed by Peek and similar file-driven tools: + +```csharp +var result = ExplorerShell.SetSelectionAndWaitForStable( + new IntPtr(explorerWindow.WindowHandle), + selectedPaths: new[] { firstPath, secondPath, focusedPath }, + focusedPath, + timeoutMS: 30_000, + requiredConsecutiveMatches: 4); + +Assert.IsTrue(result.Succeeded, + $"Explorer selection did not settle. Last focus: {result.LastObservation?.FocusedPath ?? "<none>"}"); +``` + +The helper normalizes paths, sets exact selection/focus through Shell COM, retries exact foreground +ownership, and requires consecutive matching snapshots. The focused item matters: multi-select tools +often open item zero/current, not an arbitrary member of the selected set. + +## Recipe 14 — Preserve or reset module process state intentionally + +Write a lifecycle matrix before implementing cleanup: + +| Scenario | Close window | Preserve process | Kill tree and wait | +|---|---:|---:|---:| +| Validate state retained in-process | yes | yes | no | +| Explicitly reset/unpin/reopen | yes | no | yes | +| Renderer terminal failure | best effort | no | yes | + +Use `WindowControl.TryKillProcessTreeByNameAndWait(exactName)` when a fresh process is required. It +waits for the parent and children (for example WebView2) to exit before the next activation. Do not +use it in scenarios whose assertion depends on in-process state. + +## Recipe 15 — Validate composed WinUI/WebView visuals + +Expose a product-owned ready signal first, then compare visible pixels: + +```csharp +var state = window.Find<Element>(By.AccessibilityId("PreviewStateAutomationPeer"), 15_000); +Assert.IsTrue(state.WaitForValue("Loaded", timeoutMS: 60_000)); +VisualAssert.AreEqual(TestContext, window, scenarioSubname: "image"); +``` + +`VisualAssert` uses `ScreenshotVisibleWindow`, DWM frame bounds, exact foreground ownership, and +bounded retries. Keep platform-specific embedded baselines. If a correctly rendered video disagrees +with a screenshot, diagnose capture/z-order before touching the baseline or 95% threshold. + +## Recipe 16 — Give an unaddressable control a test hook + +An icon-only button whose label lives in a `ToolTipService.ToolTip` has **no** UIA Name: the +automation peer builds the name from the content's plain text, and a `FontIcon` has none. There is +nothing for `By.Name` to match and nothing for `By.AccessibilityId` to match either, so the only +test-side option left is clicking raw coordinates derived from a neighbouring control — brittle, +DPI-sensitive, and silently wrong when the layout changes. + +The fix is a **one-attribute product edit**: add `AutomationProperties.AutomationId`. + +```xml +<Button + AutomationProperties.AutomationId="ReloadBtn" + Command="{Binding LoadProcessesCommand}" + Content="{ui:FontIcon Glyph=&#xe72c;, FontSize=16}" + Style="{StaticResource SubtleButtonStyle}"> + <ToolTipService.ToolTip> + <TextBlock x:Uid="Reload" /> + </ToolTipService.ToolTip> +</Button> +``` + +```csharp +ui.Find<Button>(By.AccessibilityId("ReloadBtn")).Click(); +``` + +Rules for using it: + +- **`AutomationProperties.AutomationId`, not `x:Name`.** `x:Name` does yield an AutomationId, but it + also generates a code-behind field and turns a pure markup change into something a developer can + bind to and depend on. `AutomationProperties.AutomationId` is inert: no field, no codegen, no + visual, no localization, no behaviour, and it never appears in the accessible name a screen reader + reads. +- **Only when the control is genuinely unaddressable.** Try `By.Name`, `By.AccessibilityId` on an + existing `x:Name`, and `GetValue()` (Recipe 8) first. Do not sprinkle ids over controls that already + resolve. +- **Add the id, not the behaviour.** Anything beyond an id — a hidden automation-peer TextBlock like + ColorPicker's `ColorHexAutomationPeer`, a new property, a state string — is a real product change: + describe it and let the maintainers decide. +- **Name it after the control, not the test**, and keep it stable; it is now part of the module's + automation contract. + --- ## Pitfalls @@ -408,3 +499,69 @@ string result = MeasureWithRetry(() => { MouseHelper.MoveTo(cx, cy); MouseHelper interaction: activate a `NavigationViewItem` with `By.AccessibilityId(...).Click()` (the harness routes it to a coordinate-free UIA invoke), not a raw `MouseHelper`/`MouseClick`. See [ci-stability.md](ci-stability.md) Principle 2. +20. **A condition observed once may be transient.** Deferred Explorer chrome, focus changes, and DWM + composition can invalidate an apparently ready state. Use `WaitHelper.WaitForStable` for exact + foreground/selection/bounds state and require consecutive samples. +21. **Blind retries can undo success.** Activation hotkeys and pin buttons toggle. Once any target + HWND exists, stop resending and wait for initialization. Retry the whole activation only after a + bounded terminal failure and explicit process reset. +22. **Window close is not process reset.** A hidden module process may ignore later show events, while + a pinned process may intentionally hold geometry. Choose preserve vs. + `TryKillProcessTreeByNameAndWait` per scenario (Recipe 14). +23. **Foreground activation is best-effort across integrity levels.** An elevated visible helper + console can permanently block a non-elevated target. Log `GetForegroundWindowInfo()` and fix the + environment (for example launch shared WinAppDriver hidden), rather than adding infinite retries. +24. **Explorer UIA is not the Shell selection authority.** Title readiness and visible file rows do + not prove the exact selected set or focused item. Use `ExplorerShell` (Recipe 13). +25. **`PrintWindow` is not a composed-content oracle.** WinUI/WebView2 can render correctly on video + while `PrintWindow` is blank or incomplete. Use visible DWM capture and verify z-order before + changing valid baselines (Recipe 15). +26. **Read the failure artifacts BEFORE theorising about the product.** Every failed test attaches a + desktop screenshot (and, in pipeline mode, an MP4). Open them first — they show what the UI + actually did, which is the one thing an assertion message cannot tell you. An assertion says + "found 0 rows"; the screenshot says whether the list was empty or whether your *counter* was + wrong. Skipping this step cost ~8 local-VM iterations on File Locksmith and produced a confident, + fully-argued, and entirely wrong "product defect" report — the window had ~10 rows on screen the + whole time while `FindAll<Button>(By.Name("End task"))` returned 0, because the button exposes no + UIA name and the `Button` wrapper filtered out the `Text` matches that winappcli did return. + + Concretely, when a test reports "the UI shows nothing": + + | Ask | Where to look | + |---|---| + | Did the UI really show nothing? | the failure PNG / MP4 | + | Is my selector matching the right control type? | `Session.Inspect()`, or `FindAll<Element>` and print `ControlType` | + | Did my fixture establish its precondition? | make the fixture assert it (Pitfall 27) | + | Is the product genuinely broken? | only after the three above | + + A product-defect claim needs artifact evidence, not inference from an assertion message. If you + catch yourself building a theory about product internals from a counter that returns 0, stop and + open the PNG. +27. **A fixture must prove its own precondition, per unit.** "At least one holder locked the file" + passes when 1 of 2 holders locked it, so the shortfall gets reported later as a product failure. + Assert the exact expected state (e.g. one ready-marker file per holder, written *after* the + operation succeeds) and include the fixture's own diagnostics in the assertion message. Equally, + expectations must track the lifecycle: a fixture that counts "total ever started" fails a test + that deliberately kills one of its processes — count what should be *alive now*. Marker files + outlive crashed/killed processes, so derive the ready count from markers whose PID is still live, + not from every marker ever written. +28. **A background fixture must be non-activating from process creation; hiding its window later is + racy.** `CreateNoWindow=true` is reliable for a direct child, but an elevated test host may need + Explorer to launch a medium-integrity fixture. Opening a generated `.cmd` through Explorer still + creates a console even when the batch uses `start /b`; that console can appear after the first + window enumeration, steal foreground from non-elevated Explorer, and make a strict foreground + assertion fail on only one CI runner. Do not weaken the target's foreground check or add retries. + Eliminate the competing surface: launch the helper hidden from creation. One proven Windows + pattern is an Explorer-opened VBScript using `WScript.Shell.Run(command, 0, False)` and an encoded + PowerShell command; a dedicated launcher using `CREATE_NO_WINDOW` under the intended token is + another. Verify the fixture's ready signal, `MainWindowHandle == 0`, and that its PID does not own + `GetForegroundWindow()`. +29. **Foreground is an interaction contract, not a universal window-readiness assertion.** Keep a + strict, stable foreground check for operations whose meaning depends on focus or coordinates — + Explorer selection/context menus, SendInput, drag, and physical clicks. Do not require an exact + launch-time HWND merely before coordinate-free UIA reads/invokes: WinUI can replace its top-level + HWND, and an interactive scheduled-task host can transiently observe `GetForegroundWindow()==0` + while the failure PNG shows the target visible and unobscured. In that case, attempt focus and log + `GetForegroundWindowInfo()`, but gate readiness on the owning process/window plus the authoritative + UIA element. Never apply this relaxation to Explorer context-menu tests; their focused Shell item + is part of the behavior under test. diff --git a/.github/skills/ui-tests-migration/references/porting-workflow.md b/.github/skills/ui-tests-migration/references/porting-workflow.md index c8d4f8e0ae..fc1501478c 100644 --- a/.github/skills/ui-tests-migration/references/porting-workflow.md +++ b/.github/skills/ui-tests-migration/references/porting-workflow.md @@ -164,6 +164,9 @@ displayed HEX, a canvas color). If an assertion needs a hook the product doesn't - First try the existing readouts: `GetValue()` (reads the Text binding even when `AutomationProperties.Name` overrides the UIA Name), `Inspect(...)` tree walks, clipboard, window geometry. +- If the control is simply unaddressable (an icon-only button whose only label is a tooltip), add + `AutomationProperties.AutomationId` to it — the one sanctioned product edit; see + [patterns-and-pitfalls.md](patterns-and-pitfalls.md) Recipe 16. - If there's truly no signal, **flag it to the user** that a small test-only UIA hook is needed (like ColorPicker's hidden `ColorHexAutomationPeer` TextBlock — `Visibility=Visible, Opacity=0`, bound to the same source). Do **not** add such a hook to product code yourself without sign-off; describe it @@ -184,4 +187,8 @@ that covers it, and explicitly call out any items left as manual-only (e.g. "che - [ ] (A) Every legacy `[TestMethod]` has a `.Next` counterpart; the legacy project is untouched. - [ ] (B) Every actionable sign-off item maps to a test or is explicitly noted as manual-only. - [ ] Toggles/settings the test changes are restored in a `finally`; spawned windows are closed. -- [ ] No product-code edits (or any needed UIA hook is flagged to the user, not silently added). +- [ ] No product-code edits beyond `AutomationProperties.AutomationId` hooks; anything larger was + flagged to the user, not silently added. +- [ ] One deterministic test and then the module suite were run through the local VM loop in + [ui-tests-local-vm](../../ui-tests-local-vm/SKILL.md), using a restored baseline or fresh volume + when clean-profile behavior matters, or the exact host prerequisite/environment blocker was reported. diff --git a/.github/skills/ui-tests-migration/references/project-setup.md b/.github/skills/ui-tests-migration/references/project-setup.md index e7e21f5242..57dcd20421 100644 --- a/.github/skills/ui-tests-migration/references/project-setup.md +++ b/.github/skills/ui-tests-migration/references/project-setup.md @@ -148,6 +148,33 @@ module's legacy UITests project) and reference it in the csproj: Tests that only assert on **format** (regex like `\d+ x \d+`) or never touch raw coordinates don't need the manifest — which is why ColorPicker/Settings `.Next` projects omit it. +## 4c. (Visual tests only) embed platform baselines + +Add baseline PNGs as embedded resources and use `VisualAssert.AreEqual`: + +```xml +<ItemGroup> + <EmbeddedResource Include="Baseline\*.png" /> +</ItemGroup> +``` + +Resource names must end with the scenario generated by `VisualAssert`: +`<Class>_<CallingMethod>[_<Subname>]_<platform>.png`. The pipeline `platform` values distinguish +targets such as `x64Win10`, `x64Win11`, and `arm64`. Keep separate valid baselines where rendering +really differs; do not regenerate them to hide capture, theme, DPI, or readiness defects. + +Visual comparison runs only when `EnvironmentConfig.IsInPipeline` is true (`TF_BUILD` or `platform` +is set). Set `TF_BUILD=true` and a representative `platform` locally when debugging pipeline capture. +`Session.ScreenshotVisibleWindow` is the correct API for composed WinUI/WebView content. + +## 4d. Explorer-driven tests need no project COM references + +Use `ExplorerShell` from `UITestAutomation.Next`. The framework embeds Shell32/SHDocVw interop and +does not expose COM types in its public API, so consuming test projects should not add their own +`COMReference` items. Use `SetSelectionAndWaitForStable` for selected/focused paths and +`SetViewModeAndIconSizeAndWait` for deterministic icon/list layout; do not duplicate Shell COM +interop in the test project. + ## 5. Build & run ```pwsh diff --git a/.pipelines/signSparsePackages.ps1 b/.pipelines/signSparsePackages.ps1 new file mode 100644 index 0000000000..f2b3fc3c57 --- /dev/null +++ b/.pipelines/signSparsePackages.ps1 @@ -0,0 +1,334 @@ +<# +.SYNOPSIS +Self-sign PowerToys sparse MSIX shell-extension packages with a machine-trusted TEST certificate so +they register on unsigned CI builds, letting UI tests exercise the real end-user workflow (the modern +Windows 11 context menu) instead of signing-free fallbacks. + +.DESCRIPTION +CI PR-validation builds are produced with codeSign:false, so every sparse-MSIX shell extension +(ImageResizer / PowerRename / FileLocksmith / NewPlus context menus, the CmdPal PowerToysSparse +package) ships UNSIGNED. PowerToys registers these at module-enable time via +PackageManager.AddPackageByUriAsync, which requires a signature that chains to a trusted root, so on +CI they fail with 0x800B0100 (TRUST_E_NOSIGNATURE) and the modern context menu never appears. + +Run this on the test agent AFTER the build is downloaded/installed and BEFORE PowerToys enables the +module. For every package it: + 1. reads the manifest Publisher subject, + 2. ensures a self-signed code-signing certificate with that exact subject exists, + 3. force-trusts that certificate (LocalMachine + CurrentUser Root and TrustedPeople), and + 4. signs the package with signtool. + +This asserts NO security -- it is a test-only trust anchor for validating normal app usage. It only +signs packages that are not already validly signed (unless -Force), so real framework packages +(VCLibs, WindowsAppSDK) are left untouched. + +.PARAMETER PackageRoot +One or more folders to search recursively for sparse packages. Missing folders are skipped, so you +can pass both the run-in-place build tree and the installed location: + -PackageRoot "$(Pipeline.Workspace)\build-x64-Release", "$env:ProgramFiles\PowerToys" + +.PARAMETER Include +Filename patterns to sign. Defaults to *.msix and *.appx. + +.PARAMETER RequiredPackage +Filename patterns that must be found and end with a Valid signature. Missing, unsigned, or untrusted +matches make the script fail after attempting all packages. + +.PARAMETER Force +Re-sign even packages that already carry a valid signature. + +.PARAMETER SkipLocalTrust +Sign without importing the test certificate into this machine's trust stores. Use when signing on a +build host and registering the package somewhere else (for example packaging a UI-test payload on the +host and running it in a VM), so the build machine never gains a test trust anchor. + +.PARAMETER ExportCertificatePath +Write the public certificate to this path so the machine that registers the package can trust it. + +.EXAMPLE +.\signSparsePackages.ps1 -PackageRoot "$env:ProgramFiles\PowerToys" ` + -RequiredPackage ImageResizerContextMenuPackage.msix + +.EXAMPLE +# Local sideloading into a UI-test VM runtime: +.\signSparsePackages.ps1 -PackageRoot "C:\PowerToysUiTestRun\PowerToys" + +.EXAMPLE +# Sign a payload on the host, trust it only inside the VM that will register it: +.\signSparsePackages.ps1 -PackageRoot "X:\payload\product" -SkipLocalTrust ` + -ExportCertificatePath "X:\payload\pt-test-signer.cer" +#> +param( + [Parameter(Mandatory = $true)] + [string[]]$PackageRoot, + + [Parameter()] + [string[]]$Include = @('*.msix', '*.appx'), + + [Parameter()] + [string[]]$RequiredPackage = @(), + + [switch]$Force, + + [switch]$SkipLocalTrust, + + [Parameter()] + [string]$ExportCertificatePath +) + +$ErrorActionPreference = 'Stop' +Add-Type -AssemblyName System.IO.Compression.FileSystem + +function Select-SignToolByArch { + param([string[]]$Paths) + + $paths = @($Paths | Where-Object { $_ } | Select-Object -Unique) + if (-not $paths) { return $null } + $archPref = @($env:PROCESSOR_ARCHITECTURE, 'x64', 'x86', 'arm64') | + ForEach-Object { $_.ToLower() } | Select-Object -Unique + foreach ($arch in $archPref) { + $match = $paths | Where-Object { $_ -match "\\$arch\\" } | Select-Object -First 1 + if ($match) { return $match } + } + return $paths[0] +} + +# Locate signtool.exe on the agent: PATH, then any Windows Kits install (all versions/layouts, +# including the App Certification Kit), then a restored SDK BuildTools NuGet package. +function Find-SignTool { + $cmd = Get-Command signtool.exe -ErrorAction SilentlyContinue + if ($cmd) { return $cmd.Source } + + $found = @() + $kitRoots = @( + "${env:ProgramFiles(x86)}\Windows Kits", + "$env:ProgramFiles\Windows Kits", + "$env:ProgramW6432\Windows Kits" + ) | Where-Object { $_ -and (Test-Path $_) } | Select-Object -Unique + foreach ($root in $kitRoots) { + # Scope to bin\ and the App Certification Kit so the huge Include\ / Lib\ trees are skipped. + $scopes = Get-ChildItem -Path $root -Directory -Recurse -Depth 1 -ErrorAction SilentlyContinue | + Where-Object { $_.Name -eq 'bin' -or $_.Name -eq 'App Certification Kit' } | + Select-Object -ExpandProperty FullName + foreach ($scope in $scopes) { + $found += Get-ChildItem -Path $scope -Recurse -Filter 'signtool.exe' -File -ErrorAction SilentlyContinue | + Select-Object -ExpandProperty FullName + } + } + + $nugetRoots = @($env:NUGET_PACKAGES, (Join-Path $env:USERPROFILE '.nuget\packages')) | + Where-Object { $_ } | + ForEach-Object { Join-Path $_ 'microsoft.windows.sdk.buildtools' } | + Where-Object { Test-Path $_ } | Select-Object -Unique + foreach ($root in $nugetRoots) { + $found += Get-ChildItem -Path $root -Recurse -Filter 'signtool.exe' -File -ErrorAction SilentlyContinue | + Select-Object -ExpandProperty FullName + } + + return Select-SignToolByArch -Paths $found +} + +# Last resort when the agent has no Windows SDK: fetch signtool from the public +# Microsoft.Windows.SDK.BuildTools NuGet package (cached in TEMP across runs). Best-effort. +function Get-SignToolFromNuget { + try { + $index = Invoke-RestMethod 'https://api.nuget.org/v3-flatcontainer/microsoft.windows.sdk.buildtools/index.json' -UseBasicParsing + $version = @($index.versions | Where-Object { $_ -match '^\d+\.\d+\.\d+\.\d+$' })[-1] + if (-not $version) { return $null } + + $dest = Join-Path $env:TEMP "pt-sdk-buildtools-$version" + if (-not (Get-ChildItem -Path $dest -Recurse -Filter 'signtool.exe' -File -ErrorAction SilentlyContinue)) { + Write-Host "signtool not found on the agent; fetching Windows SDK BuildTools $version from NuGet." + $nupkg = Join-Path $env:TEMP "sdk-buildtools-$version.zip" + Invoke-WebRequest "https://api.nuget.org/v3-flatcontainer/microsoft.windows.sdk.buildtools/$version/microsoft.windows.sdk.buildtools.$version.nupkg" -OutFile $nupkg -UseBasicParsing + Expand-Archive -Path $nupkg -DestinationPath $dest -Force + Remove-Item $nupkg -Force -ErrorAction SilentlyContinue + } + $paths = Get-ChildItem -Path $dest -Recurse -Filter 'signtool.exe' -File -ErrorAction SilentlyContinue | + Select-Object -ExpandProperty FullName + return Select-SignToolByArch -Paths $paths + } + catch { + Write-Warning "Could not obtain signtool from NuGet: $($_.Exception.Message)" + return $null + } +} + +# Read <Identity Publisher="..."> straight out of the .msix/.appx (a zip) without extracting it. +function Get-PackagePublisher { + param([string]$PackagePath) + + $zip = [System.IO.Compression.ZipFile]::OpenRead($PackagePath) + try { + $entry = $zip.GetEntry('AppxManifest.xml') + if (-not $entry) { return $null } + $reader = New-Object System.IO.StreamReader($entry.Open()) + try { $xml = [xml]$reader.ReadToEnd() } finally { $reader.Dispose() } + return $xml.Package.Identity.Publisher + } + finally { + $zip.Dispose() + } +} + +function Import-CertTrust { + param( + [string]$CerPath, + [string]$Thumbprint, + [string]$StorePath, + [switch]$Optional + ) + + if (Get-ChildItem $StorePath -ErrorAction SilentlyContinue | Where-Object { $_.Thumbprint -eq $Thumbprint }) { + return $true + } + try { + Import-Certificate -FilePath $CerPath -CertStoreLocation $StorePath -ErrorAction Stop | Out-Null + return $true + } + catch { + if ($Optional) { + Write-Warning "Could not import test cert into $StorePath (admin may be required): $($_.Exception.Message)" + return $false + } + throw + } +} + +$certCache = @{} +function Get-TrustedSigningCert { + param([string]$Subject) + + if ($certCache.ContainsKey($Subject)) { return $certCache[$Subject] } + + $cert = Get-ChildItem Cert:\CurrentUser\My | + Where-Object { $_.Subject -eq $Subject -and $_.HasPrivateKey } | + Sort-Object NotAfter -Descending | Select-Object -First 1 + + if (-not $cert) { + Write-Host "Creating self-signed test certificate for: $Subject" + $cert = New-SelfSignedCertificate -Subject $Subject ` + -CertStoreLocation Cert:\CurrentUser\My ` + -KeyAlgorithm RSA -KeyLength 2048 ` + -Type CodeSigningCert -HashAlgorithm SHA256 ` + -NotAfter (Get-Date).AddYears(1) + } + + # Force-trust so AddPackageByUriAsync accepts the signature. A self-signed cert is its own root, + # so it must live in a Root store (chain) and TrustedPeople (AppX sideload allow-list). Use the + # LocalMachine stores: they import silently and the elevated CI test agent can write them. + # CurrentUser\Root is deliberately NOT used -- importing into the user Root store raises a CryptoAPI + # consent dialog that fails non-interactively ("UI is not allowed in this operation"), even elevated. + $cerPath = Join-Path $env:TEMP ("pt-test-signer-{0}.cer" -f $cert.Thumbprint) + Export-Certificate -Cert $cert -FilePath $cerPath -Force | Out-Null + + if ($ExportCertificatePath) { + $exportParent = Split-Path $ExportCertificatePath -Parent + if ($exportParent -and -not (Test-Path $exportParent)) { + New-Item $exportParent -ItemType Directory -Force | Out-Null + } + Copy-Item $cerPath $ExportCertificatePath -Force + Write-Host "Exported public certificate to: $ExportCertificatePath" + } + + if ($SkipLocalTrust) { + Write-Host "Skipping local trust for '$Subject'; trust the exported certificate where the package is registered." + $certCache[$Subject] = $cert + return $cert + } + + $rootTrusted = Import-CertTrust -CerPath $cerPath -Thumbprint $cert.Thumbprint -StorePath 'Cert:\LocalMachine\Root' -Optional + Import-CertTrust -CerPath $cerPath -Thumbprint $cert.Thumbprint -StorePath 'Cert:\LocalMachine\TrustedPeople' -Optional | Out-Null + Import-CertTrust -CerPath $cerPath -Thumbprint $cert.Thumbprint -StorePath 'Cert:\CurrentUser\TrustedPeople' -Optional | Out-Null + if (-not $rootTrusted) { + Write-Warning "Could not establish machine root trust for '$Subject' (run elevated). Signed packages may not register." + } + + $certCache[$Subject] = $cert + return $cert +} + +$packages = @() +foreach ($root in $PackageRoot) { + if (-not (Test-Path $root)) { + Write-Host "Skipping missing package root: $root" + continue + } + $packages += Get-ChildItem -Path $root -Recurse -File -Include $Include -ErrorAction SilentlyContinue +} +$packages = $packages | Sort-Object FullName -Unique + +if (-not $packages) { + if ($RequiredPackage.Count -gt 0) { + throw "No packages found under '$($PackageRoot -join ', ')' while requiring: $($RequiredPackage -join ', ')." + } + + Write-Host "No packages found under: $($PackageRoot -join ', ')" + return +} + +$requiredPackages = @() +foreach ($pattern in ($RequiredPackage | Where-Object { $_ } | Select-Object -Unique)) { + $matches = @($packages | Where-Object { $_.Name -like $pattern }) + if ($matches.Count -eq 0) { + throw "Required sparse package '$pattern' was not found under: $($PackageRoot -join ', ')." + } + + $requiredPackages += $matches +} +$requiredPackages = @($requiredPackages | Sort-Object FullName -Unique) + +$signed = 0 +$signtool = $null +foreach ($pkg in $packages) { + if (-not $Force) { + $existing = Get-AuthenticodeSignature -FilePath $pkg.FullName + if ($existing.Status -eq 'Valid') { + Write-Host "Already validly signed, skipping: $($pkg.Name)" + continue + } + } + + $publisher = $null + try { $publisher = Get-PackagePublisher -PackagePath $pkg.FullName } catch { } + if (-not $publisher) { + Write-Host "No manifest publisher, skipping: $($pkg.Name)" + continue + } + + if (-not $signtool) { + $signtool = Find-SignTool + if (-not $signtool) { $signtool = Get-SignToolFromNuget } + if (-not $signtool) { throw 'signtool.exe not found and could not be fetched from NuGet. Install the Windows SDK.' } + Write-Host "Using signtool: $signtool" + } + + $cert = Get-TrustedSigningCert -Subject $publisher + Write-Host "Signing $($pkg.Name) (Publisher: $publisher)" + & $signtool sign /fd SHA256 /sha1 $cert.Thumbprint $pkg.FullName + if ($LASTEXITCODE -ne 0) { + Write-Warning "signtool failed for $($pkg.Name) (exit $LASTEXITCODE)" + continue + } + + $verify = Get-AuthenticodeSignature -FilePath $pkg.FullName + if ($verify.Status -eq 'Valid') { + $signed++ + } + else { + Write-Warning "Signature not Valid after signing $($pkg.Name): $($verify.Status)" + } +} + +if ($requiredPackages.Count -gt 0) { + $invalidRequiredPackages = @($requiredPackages | Where-Object { + (Get-AuthenticodeSignature -FilePath $_.FullName).Status -ne 'Valid' + }) + if ($invalidRequiredPackages.Count -gt 0) { + throw "Required sparse package(s) are not validly signed and trusted: $($invalidRequiredPackages.FullName -join ', ')." + } + + Write-Host "Verified required sparse package(s): $($requiredPackages.FullName -join ', ')" +} + +Write-Host "Signed $signed package(s) with a trusted test certificate." diff --git a/.pipelines/v2/templates/job-test-project.yml b/.pipelines/v2/templates/job-test-project.yml index fb79b47c7a..bc590f2f32 100644 --- a/.pipelines/v2/templates/job-test-project.yml +++ b/.pipelines/v2/templates/job-test-project.yml @@ -177,17 +177,47 @@ jobs: inputs: displaySettings: 'optimal' + # Sign the sparse shell-extension MSIX packages with a machine-trusted TEST certificate so they + # register on unsigned PR builds and the UI tests can drive the real modern (Win11 tier-1) context + # menu instead of the signing-free fallback. Test-only trust anchor; asserts no security. All roots + # are searched recursively (buildNow run-in-place tree + complete machine/per-user installs). + # Image Resizer has no Windows 11 classic-menu fallback, so its focused and all-module jobs require + # the signed/trusted package; unrelated jobs keep this setup best-effort. + - pwsh: | + $packageRoots = @( + "$(Pipeline.Workspace)\$(TestArtifactsName)", + "$env:ProgramFiles\PowerToys", + "$env:LOCALAPPDATA\PowerToys") + $modulesRaw = '${{ join(';', parameters.uiTestModules) }}' + $requiresImageResizer = '$(TestPlatform)' -ne 'x64Win10' -and ( + [string]::IsNullOrWhiteSpace($modulesRaw) -or + @($modulesRaw -split ';' | Where-Object { $_ -match 'ImageResizer' }).Count -gt 0) + + if ($requiresImageResizer) { + & "$(build.sourcesdirectory)\.pipelines\signSparsePackages.ps1" ` + -PackageRoot $packageRoots ` + -RequiredPackage 'ImageResizerContextMenuPackage.msix' + } else { + try { + & "$(build.sourcesdirectory)\.pipelines\signSparsePackages.ps1" -PackageRoot $packageRoots + } catch { + Write-Host "##vso[task.logissue type=warning]Sparse MSIX signing skipped: $($_.Exception.Message)" + } + } + displayName: "Sign sparse MSIX packages (test trust)" + # Start WinAppDriver once for the whole job — WinAppDriver's documented CI pattern # (https://github.com/microsoft/WinAppDriver/blob/master/Docs/CI_AzureDevOps.md). Launching it - # detached gives it its own console whose stdin blocks, so it stays alive for the run instead of - # reading EOF and exiting the moment it starts listening (the failure mode when a test host launches - # it as a child). The legacy UITest harness reuses an already-listening instance rather than + # detached gives it its own hidden console whose stdin blocks, so it stays alive for the run without + # stealing foreground from non-elevated apps under test. This also avoids reading EOF and exiting the + # moment it starts listening (the failure mode when a test host launches it as a child). The legacy + # UITest harness reuses an already-listening instance rather than # relaunching it per test, so this removes the per-assembly launch cost. The winappcli-based .Next # tests don't use WinAppDriver. Best-effort: if the pre-start fails, each assembly still launches its own. - pwsh: | $winapp = "C:\Program Files (x86)\Windows Application Driver\WinAppDriver.exe" if (Test-Path $winapp) { - Start-Process -FilePath $winapp + Start-Process -FilePath $winapp -WindowStyle Hidden $deadline = (Get-Date).AddSeconds(30) $ready = $false diff --git a/PowerToys.slnx b/PowerToys.slnx index d28e9f8ef3..2d375dd426 100644 --- a/PowerToys.slnx +++ b/PowerToys.slnx @@ -58,6 +58,10 @@ <Platform Solution="*|ARM64" Project="ARM64" /> <Platform Solution="*|x64" Project="x64" /> </Project> + <Project Path="src/common/UITestAutomation.Next.UnitTests/UITestAutomation.Next.UnitTests.csproj"> + <Platform Solution="*|ARM64" Project="ARM64" /> + <Platform Solution="*|x64" Project="x64" /> + </Project> <Project Path="src/common/UnitTests-CommonLib/UnitTests-CommonLib.vcxproj" Id="1a066c63-64b3-45f8-92fe-664e1cce8077" /> <Project Path="src/common/UnitTests-CommonUtils/UnitTests-CommonUtils.vcxproj" Id="8b5cfb38-ccba-40a8-ad7a-89c57b070884" /> <Project Path="src/common/updating/UnitTests/UpdatingUnitTests.vcxproj" Id="a1b2c3d4-e5f6-7890-abcd-ef1234567890" /> @@ -479,6 +483,10 @@ </Folder> <Folder Name="/modules/FileLocksmith/Tests/"> <Project Path="src/modules/FileLocksmith/FileLocksmithCLI/tests/FileLocksmithCLIUnitTests.vcxproj" Id="a1b2c3d4-e5f6-7890-1234-567890abcdef" /> + <Project Path="src/modules/FileLocksmith/Tests/FileLocksmith.UITests/FileLocksmith.UITests.csproj"> + <Platform Solution="*|ARM64" Project="ARM64" /> + <Platform Solution="*|x64" Project="x64" /> + </Project> </Folder> <Folder Name="/modules/Hosts/"> <Project Path="src/modules/Hosts/Hosts/Hosts.csproj"> @@ -520,6 +528,10 @@ <Platform Solution="*|ARM64" Project="ARM64" /> <Platform Solution="*|x64" Project="x64" /> </Project> + <Project Path="src/modules/imageresizer/tests/ImageResizer.UITests/ImageResizer.UITests.csproj"> + <Platform Solution="*|ARM64" Project="ARM64" /> + <Platform Solution="*|x64" Project="x64" /> + </Project> </Folder> <Folder Name="/modules/interface/"> <File Path="src/modules/interface/powertoy_module_interface.h" /> @@ -885,6 +897,10 @@ <Platform Solution="*|ARM64" Project="ARM64" /> <Platform Solution="*|x64" Project="x64" /> </Project> + <Project Path="src/modules/peek/Peek.UITests.Next/Peek.UITests.Next.csproj"> + <Platform Solution="*|ARM64" Project="ARM64" /> + <Platform Solution="*|x64" Project="x64" /> + </Project> <Project Path="src/modules/peek/peek/peek.vcxproj" Id="a1425b53-3d61-4679-8623-e64a0d3d0a48" /> </Folder> <Folder Name="/modules/PowerAccent/"> @@ -1021,6 +1037,10 @@ <Project Path="src/modules/previewpane/SvgThumbnailProviderCpp/SvgThumbnailProviderCpp.vcxproj" Id="2bbc9e33-21ec-401c-84da-bb6590a9b2aa" /> </Folder> <Folder Name="/modules/previewpane/Tests/"> + <Project Path="src/modules/previewpane/PreviewPane.UITests/PreviewPane.UITests.csproj"> + <Platform Solution="*|ARM64" Project="ARM64" /> + <Platform Solution="*|x64" Project="x64" /> + </Project> <Project Path="src/modules/previewpane/UnitTests-BgcodePreviewHandler/Preview.BgcodePreviewHandler.UnitTests.csproj"> <Platform Solution="*|ARM64" Project="ARM64" /> <Platform Solution="*|x64" Project="x64" /> diff --git a/doc/devdocs/development/ui-tests.md b/doc/devdocs/development/ui-tests.md index 941f9dacd4..443873a778 100644 --- a/doc/devdocs/development/ui-tests.md +++ b/doc/devdocs/development/ui-tests.md @@ -1,8 +1,38 @@ # UI tests framework - A specialized UI test framework for PowerToys that makes it easy to write UI tests for PowerToys modules or settings. Let's start writing UI tests! +PowerToys provides UI-test frameworks for modules and Settings. New tests should use +`Microsoft.PowerToys.UITest.Next`, which drives Windows UI Automation through `winappcli` and runs as +a Microsoft.Testing.Platform executable. The legacy `Microsoft.PowerToys.UITest` framework uses +WinAppDriver/Selenium and remains documented for existing suites and migration baselines. -## Before running tests +## Agent-assisted workflows + +Two repository skills cover the complete implementation and validation loop: + +- [UI-tests migration skill](../../../.github/skills/ui-tests-migration/SKILL.md): create new + `.Next` test projects, port legacy WinAppDriver tests, design stable selectors/waits/lifecycle, and + prepare tests for CI. +- [Local-VM UI-tests skill](../../../.github/skills/ui-tests-local-vm/SKILL.md): create persistent + Windows 10 and Windows 11 Hyper-V guests, stage current build/test artifacts, execute tests in a + standard-user interactive desktop, and collect durable TRX/log/screenshot/video evidence. + +For new or migrated tests, use both skills. Build first, then use the local VMs as the default live +agentic loop: run one deterministic test, diagnose and fix it, and finally widen to the complete +module suite on both supported Windows versions. + +## Before running tests + +### `.Next` tests + +- Build the PowerToys runtime and `.UITests.Next` test executable. +- Install the pinned `winappcli` runtime or set `WINAPP_CLI_PATH`. The pipeline helper is + `.pipelines/InstallWinAppCli.ps1`. +- Use a live interactive desktop. UIA, foreground input, Explorer, hotkeys, and rendering do not work + in session 0. +- Exit an existing PowerToys instance before a host-desktop run. The harness owns the runner and + module lifecycle. + +### Legacy tests - Install Windows Application Driver v1.2.1 from https://github.com/microsoft/WinAppDriver/releases/tag/v1.2.1 to the default directory (`C:\Program Files (x86)\Windows Application Driver`) @@ -10,12 +40,101 @@ ## Running tests +### `.Next` tests + +Build the focused project with the repository script, then run the produced Microsoft.Testing.Platform +executable directly: + +```pwsh +tools\build\build.cmd ` + -Path src\modules\<Module>\Tests\<Module>.UITests.Next ` + -Platform x64 ` + -Configuration Debug + +$exe = 'x64\Debug\tests\<Module>.UITests.Next\net10.0-windows10.0.26100.0\<Module>.UITests.Next.exe' +& $exe ` + --filter 'TestCategory=<Module>' ` + --report-trx ` + --report-trx-filename module.trx ` + --results-directory .\TestResults\<Module> ` + --timeout 7m +``` + +Use explicit filter properties such as `Name=`, `Name~`, `FullyQualifiedName~`, or `TestCategory=`. +A bare display name can select zero tests. The `7m` timeout above is a focused-filter example; choose +a larger value for a module or project-wide run. + +### Legacy tests + - Exit PowerToys if it's running. - Open `PowerToys.slnx` in Visual Studio and build the solution. - Run tests in the Test Explorer (`Test > Test Explorer` or `Ctrl+E, T`). +## Running `.Next` tests in persistent local VMs + +The supported local backend is a pair of persistent Hyper-V guests driven through PowerShell Direct: +Windows 10 and Windows 11, each with an already logged-on standard-user desktop. The VMs reveal +first-run, profile, Explorer, WebView2, foreground, and lifecycle assumptions without modifying the +host profile, while retaining staged payloads for a fast edit/build/rerun loop. + +### One-time host setup + +Scaffold a VM root outside the repository, then follow the generated next steps to create the +untracked configuration: + +```pwsh +pwsh .github\skills\ui-tests-local-vm\scripts\Initialize-LocalVm.ps1 ` + -DestinationRoot C:\PowerToysUiTestVm + +pwsh .github\skills\ui-tests-local-vm\scripts\Initialize-LocalVmHost.ps1 ` + -VmRoot C:\PowerToysUiTestVm ` + -CheckOnly +``` + +If `-CheckOnly` reports `IsReady=false`, a human must run the elevated setup command it prints. +Hyper-V group membership, the DPAPI-protected guest administrator credential, and guest creation +cannot be completed by an agent. See the [setup reference](../../../.github/skills/ui-tests-local-vm/references/setup.md) +for install media, `vm.config.psd1`, Windows 10/11 guest creation, and baseline checkpoints. + +### Run the agentic loop + +Create a module exchange containing `ui-tests.zip`, `powertoys-runtime.zip`, `winappcli.zip`, and +`dotnet-runtime.zip` as described in the +[agentic-loop reference](../../../.github/skills/ui-tests-local-vm/references/agentic-loop.md). Payloads +are extracted to guest-local storage; tests are never run directly from a host share. + +```pwsh +$vmRoot = 'C:\PowerToysUiTestVm' +$exchange = "$vmRoot\shared\PowerToysUiTests\<Module>" + +pwsh .github\skills\ui-tests-local-vm\scripts\Invoke-LocalVmUiTest.ps1 ` + -VmName PowerToysUiTest-Win11 ` + -ConfigurationPath "$vmRoot\vm.config.psd1" ` + -VmRoot $vmRoot ` + -ExchangeRoot $exchange ` + -TestExecutable '<Module>.UITests.Next.exe' ` + -Filter 'Name=<Module>.FocusedTest' ` + -Platform x64Win11 ` + -BuildLabel (git rev-parse HEAD) ` + -SuiteTimeout 15m ` + -TimeoutMinutes 25 ` + -ReuseStagedPayload +``` + +The controller starts the guest if needed, validates the standard-user token, Explorer session, and +desktop size, then runs the test through a limited interactive scheduled task. It streams progress +and returns `status.json`, TRX counters, per-test failures, logs, screenshots, and retained failure +recordings under `<ExchangeRoot>\LocalVmResults\<runId>`. + +After each source change, rebuild and replace only the changed archive, then rerun the same focused +filter with `-ReuseStagedPayload`. Widen only after that behavior is understood. A module is complete +only after the full category filter passes with `executed == total` on both Windows 10 and Windows 11; +restore the baseline checkpoint for the final clean-profile confirmation. See the local-VM +[troubleshooting guide](../../../.github/skills/ui-tests-local-vm/references/troubleshooting.md) for +desktop, PowerShell Direct, payload, shell-extension signing, and evidence failures. + ## Running tests in pipeline The PowerToys UI test pipeline provides flexible options for building and testing: @@ -68,6 +187,14 @@ The PowerToys UI test pipeline provides flexible options for building and testin - Pipeline: https://microsoft.visualstudio.com/Dart/_build?definitionId=161438&_a=summary ## How to add the first UI tests for your modules + +Use the [UI-tests migration skill](../../../.github/skills/ui-tests-migration/SKILL.md) for new +`.Next` projects and ports. It contains the current executable project scaffold, API mapping, naming, +CI-stability checklist, and validated examples. + +The project sample below describes the **legacy WinAppDriver framework** and is retained for existing +legacy suites. Do not use it as the starting point for a new `.Next` project. + - Follow the naming convention: ![{ModuleFolder}/Tests/{ModuleName}-{TestType(Fuzz/UI/Unit)}Tests](images/uitests/naming.png) - Create a new project and add the following references to the project file. Change the OutputPath to your own module's path. ``` diff --git a/src/common/UITestAutomation.Next.UnitTests/SettingsConfigHelperTests.cs b/src/common/UITestAutomation.Next.UnitTests/SettingsConfigHelperTests.cs new file mode 100644 index 0000000000..88648e8916 --- /dev/null +++ b/src/common/UITestAutomation.Next.UnitTests/SettingsConfigHelperTests.cs @@ -0,0 +1,138 @@ +// Copyright (c) Microsoft Corporation +// The Microsoft Corporation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Text.Json.Nodes; +using Microsoft.PowerToys.UITest.Next; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Microsoft.PowerToys.UITestAutomationNext.UnitTests; + +[TestClass] +public class SettingsConfigHelperTests +{ + private static readonly string[] ExpectedModuleNames = + [ + "AdvancedPaste", + "AlwaysOnTop", + "Awake", + "CmdNotFound", + "CmdPal", + "ColorPicker", + "CropAndLock", + "CursorWrap", + "EnvironmentVariables", + "FancyZones", + "File Explorer Preview", + "File Locksmith", + "FindMyMouse", + "GrabAndMove", + "Hosts", + "Image Resizer", + "Keyboard Manager", + "LightSwitch", + "Measure Tool", + "MouseHighlighter", + "MouseJump", + "MousePointerCrosshairs", + "MouseWithoutBorders", + "NewPlus", + "Peek", + "PowerDisplay", + "PowerRename", + "PowerToys Run", + "QuickAccent", + "RegistryPreview", + "Shortcut Guide", + "TextExtractor", + "Workspaces", + "ZoomIt", + ]; + + [TestMethod] + public void ConfigureGlobalModuleSettingsSeedsExactFreshProfileBaseline() + { + var root = new JsonObject(); + + SettingsConfigHelper.ConfigureGlobalModuleSettings(root, "Image Resizer"); + + var enabled = root["enabled"]!.AsObject(); + CollectionAssert.AreEquivalent(ExpectedModuleNames, enabled.Select(property => property.Key).ToArray()); + foreach (var moduleName in ExpectedModuleNames) + { + Assert.AreEqual(moduleName == "Image Resizer", enabled[moduleName]!.GetValue<bool>(), moduleName); + } + } + + [TestMethod] + public void ConfigureGlobalModuleSettingsHandlesUnknownModuleKeys() + { + var root = new JsonObject + { + ["enabled"] = new JsonObject + { + ["ExistingFutureModule"] = true, + }, + }; + + SettingsConfigHelper.ConfigureGlobalModuleSettings(root, "RequestedFutureModule"); + + var enabled = root["enabled"]!.AsObject(); + Assert.IsFalse(enabled["ExistingFutureModule"]!.GetValue<bool>()); + Assert.IsTrue(enabled["RequestedFutureModule"]!.GetValue<bool>()); + } + + [TestMethod] + public void PreserveFileRestoresExistingBytes() + { + var root = CreateTemporaryDirectory(); + var path = Path.Combine(root, "module", "settings.json"); + var original = new byte[] { 0xEF, 0xBB, 0xBF, 0x7B, 0x7D }; + + try + { + Directory.CreateDirectory(Path.GetDirectoryName(path)!); + File.WriteAllBytes(path, original); + + using (SettingsConfigHelper.PreserveFile(path)) + { + File.WriteAllText(path, "changed"); + } + + CollectionAssert.AreEqual(original, File.ReadAllBytes(path)); + } + finally + { + Directory.Delete(root, recursive: true); + } + } + + [TestMethod] + public void PreserveFileDeletesFileCreatedInsideScope() + { + var root = CreateTemporaryDirectory(); + var path = Path.Combine(root, "module", "settings.json"); + + try + { + using (SettingsConfigHelper.PreserveFile(path)) + { + Directory.CreateDirectory(Path.GetDirectoryName(path)!); + File.WriteAllText(path, "created by test"); + } + + Assert.IsFalse(File.Exists(path)); + } + finally + { + Directory.Delete(root, recursive: true); + } + } + + private static string CreateTemporaryDirectory() + { + var path = Path.Combine(Path.GetTempPath(), "PowerToys-UITestAutomationNext-UnitTests", Guid.NewGuid().ToString("N")); + Directory.CreateDirectory(path); + return path; + } +} diff --git a/src/common/UITestAutomation.Next.UnitTests/UITestAutomation.Next.UnitTests.csproj b/src/common/UITestAutomation.Next.UnitTests/UITestAutomation.Next.UnitTests.csproj new file mode 100644 index 0000000000..6ab0f6176b --- /dev/null +++ b/src/common/UITestAutomation.Next.UnitTests/UITestAutomation.Next.UnitTests.csproj @@ -0,0 +1,25 @@ +<Project Sdk="Microsoft.NET.Sdk"> + <!-- Look at Directory.Build.props in root for common stuff as well --> + <Import Project="$(RepoRoot)src\Common.Dotnet.CsWinRT.props" /> + + <PropertyGroup> + <SelfContained>true</SelfContained> + <RuntimeIdentifier Condition="'$(Platform)' == 'x64'">win-x64</RuntimeIdentifier> + <RuntimeIdentifier Condition="'$(Platform)' == 'ARM64'">win-arm64</RuntimeIdentifier> + <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath> + <IsPackable>false</IsPackable> + <ImplicitUsings>enable</ImplicitUsings> + <Nullable>enable</Nullable> + <OutputType>Exe</OutputType> + <RootNamespace>Microsoft.PowerToys.UITestAutomationNext.UnitTests</RootNamespace> + <OutputPath>$(RepoRoot)$(Platform)\$(Configuration)\tests\UITestAutomation.Next.UnitTests\</OutputPath> + </PropertyGroup> + + <ItemGroup> + <PackageReference Include="MSTest" /> + </ItemGroup> + + <ItemGroup> + <ProjectReference Include="..\UITestAutomation.Next\UITestAutomation.Next.csproj" /> + </ItemGroup> +</Project> \ No newline at end of file diff --git a/src/common/UITestAutomation.Next.UnitTests/WaitHelperTests.cs b/src/common/UITestAutomation.Next.UnitTests/WaitHelperTests.cs new file mode 100644 index 0000000000..fe5cbdc8cc --- /dev/null +++ b/src/common/UITestAutomation.Next.UnitTests/WaitHelperTests.cs @@ -0,0 +1,96 @@ +// Copyright (c) Microsoft Corporation +// The Microsoft Corporation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using Microsoft.PowerToys.UITest.Next; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Microsoft.PowerToys.UITestAutomationNext.UnitTests; + +[TestClass] +public class WaitHelperTests +{ + private static readonly int[] ExpectedRecoveredValues = [1, 2]; + + [TestMethod] + public void WaitForStableRequiresConsecutiveMatches() + { + var observations = new Queue<bool>([true, false, true, true, true]); + var observationCount = 0; + + var result = WaitHelper.WaitForStable( + observe: () => + { + observationCount++; + return observations.Dequeue(); + }, + isMatch: value => value, + timeoutMS: 1_000, + requiredConsecutiveMatches: 3, + pollIntervalMS: 1); + + Assert.IsTrue(result.Succeeded); + Assert.AreEqual(5, observationCount); + Assert.AreEqual(3, result.ConsecutiveMatches); + } + + [TestMethod] + public void WaitForStableRunsRecoveryOnMismatch() + { + var observations = new Queue<int>([1, 2, 3]); + var recoveredValues = new List<int>(); + + var result = WaitHelper.WaitForStable( + observe: observations.Dequeue, + isMatch: value => value == 3, + timeoutMS: 1_000, + pollIntervalMS: 1, + recover: value => recoveredValues.Add(value)); + + Assert.IsTrue(result.Succeeded); + CollectionAssert.AreEqual(ExpectedRecoveredValues, recoveredValues); + } + + [TestMethod] + public void WaitForStableReturnsLastObservationOnTimeout() + { + var observation = 0; + + var result = WaitHelper.WaitForStable( + observe: () => ++observation, + isMatch: _ => false, + timeoutMS: 20, + pollIntervalMS: 1); + + Assert.IsFalse(result.Succeeded); + Assert.AreEqual(observation, result.LastObservation); + Assert.IsTrue(observation > 0); + } + + [TestMethod] + public void WaitForStableRetriesOnlyClassifiedExceptions() + { + var attempts = 0; + var transient = new InvalidOperationException("Transient"); + + var result = WaitHelper.WaitForStable<int>( + observe: () => + { + attempts++; + if (attempts == 1) + { + throw transient; + } + + return 42; + }, + isMatch: value => value == 42, + timeoutMS: 1_000, + pollIntervalMS: 1, + shouldRetryException: exception => ReferenceEquals(exception, transient)); + + Assert.IsTrue(result.Succeeded); + Assert.AreEqual(2, attempts); + Assert.IsNull(result.LastException); + } +} diff --git a/src/common/UITestAutomation.Next.UnitTests/WinappCliTests.cs b/src/common/UITestAutomation.Next.UnitTests/WinappCliTests.cs new file mode 100644 index 0000000000..5c038df143 --- /dev/null +++ b/src/common/UITestAutomation.Next.UnitTests/WinappCliTests.cs @@ -0,0 +1,56 @@ +// Copyright (c) Microsoft Corporation +// The Microsoft Corporation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using Microsoft.PowerToys.UITest.Next; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Microsoft.PowerToys.UITestAutomationNext.UnitTests; + +[TestClass] +[DoNotParallelize] +public sealed class WinappCliTests +{ + private string? originalInvokeTimeout; + + [TestInitialize] + public void SaveEnvironment() + { + originalInvokeTimeout = Environment.GetEnvironmentVariable(WinappCli.InvokeTimeoutSecondsEnvironmentVariable); + } + + [TestCleanup] + public void RestoreEnvironment() + { + Environment.SetEnvironmentVariable(WinappCli.InvokeTimeoutSecondsEnvironmentVariable, originalInvokeTimeout); + } + + [TestMethod] + public void ResolveInvokeTimeoutHonorsEnvironmentOverride() + { + Environment.SetEnvironmentVariable(WinappCli.InvokeTimeoutSecondsEnvironmentVariable, "180"); + + Assert.AreEqual(TimeSpan.FromSeconds(180), WinappCli.ResolveInvokeTimeout([])); + } + + [TestMethod] + [DataRow("invalid")] + [DataRow("0")] + [DataRow("3601")] + public void ResolveInvokeTimeoutRejectsInvalidEnvironmentOverride(string value) + { + Environment.SetEnvironmentVariable(WinappCli.InvokeTimeoutSecondsEnvironmentVariable, value); + + Assert.AreEqual(TimeSpan.FromSeconds(60), WinappCli.ResolveInvokeTimeout([])); + } + + [TestMethod] + public void ResolveInvokeTimeoutExtendsPastLongerCommandTimeout() + { + Environment.SetEnvironmentVariable(WinappCli.InvokeTimeoutSecondsEnvironmentVariable, "180"); + + Assert.AreEqual( + TimeSpan.FromSeconds(230), + WinappCli.ResolveInvokeTimeout(["wait-for", "target", "--timeout", "200000"])); + } +} diff --git a/src/common/UITestAutomation.Next/ExplorerShell.cs b/src/common/UITestAutomation.Next/ExplorerShell.cs new file mode 100644 index 0000000000..bb67a8163d --- /dev/null +++ b/src/common/UITestAutomation.Next/ExplorerShell.cs @@ -0,0 +1,471 @@ +// Copyright (c) Microsoft Corporation +// The Microsoft Corporation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Runtime.InteropServices; +using SHDocVw; + +namespace Microsoft.PowerToys.UITest.Next; + +/// <summary>File Explorer selection helpers backed by the Shell COM view used by Explorer itself.</summary> +public static class ExplorerShell +{ + private static readonly Guid ShellApplicationClassId = new("13709620-C279-11CE-A49E-444553540000"); + private const int ShellViewSelect = 0x1; + private const int ShellViewDeselectOthers = 0x4; + private const int ShellViewEnsureVisible = 0x8; + private const int ShellViewFocused = 0x10; + + public enum ViewMode : uint + { + Icons = 1, + Details = 4, + } + + public sealed record SelectionSnapshot(IReadOnlySet<string> SelectedPaths, string? FocusedPath); + + public sealed record ViewSnapshot(ViewMode Mode, int IconSize); + + private sealed record ReadinessSnapshot(bool IsForeground, SelectionSnapshot? Selection); + + /// <summary> + /// Set the exact selected path set and focused item, then require both selection and foreground + /// ownership to remain stable across consecutive Shell snapshots. + /// </summary> + public static WaitHelper.StableWaitResult<SelectionSnapshot> SetSelectionAndWaitForStable( + IntPtr explorerWindow, + IReadOnlyCollection<string> selectedPaths, + string focusedPath, + int timeoutMS = 30_000, + int requiredConsecutiveMatches = 4, + int pollIntervalMS = 250) + { + ArgumentNullException.ThrowIfNull(selectedPaths); + ArgumentException.ThrowIfNullOrWhiteSpace(focusedPath); + if (explorerWindow == IntPtr.Zero) + { + throw new ArgumentException("Explorer HWND must not be zero.", nameof(explorerWindow)); + } + + var normalizedPaths = selectedPaths + .Select(NormalizePath) + .ToHashSet(StringComparer.OrdinalIgnoreCase); + var normalizedFocusedPath = NormalizePath(focusedPath); + if (normalizedPaths.Count == 0 || !normalizedPaths.Contains(normalizedFocusedPath)) + { + throw new ArgumentException("The selected paths must contain the focused path.", nameof(selectedPaths)); + } + + var result = WaitHelper.WaitForStable( + observe: () => new ReadinessSnapshot( + WindowControl.GetForegroundWindowHandle() == explorerWindow, + TryGetSelection(explorerWindow)), + isMatch: snapshot => snapshot is not null && + snapshot.IsForeground && + snapshot.Selection is not null && + snapshot.Selection.SelectedPaths.SetEquals(normalizedPaths) && + string.Equals(snapshot.Selection.FocusedPath, normalizedFocusedPath, StringComparison.OrdinalIgnoreCase), + timeoutMS: timeoutMS, + requiredConsecutiveMatches: requiredConsecutiveMatches, + pollIntervalMS: pollIntervalMS, + recover: snapshot => + { + if (snapshot?.IsForeground != true) + { + WindowControl.TryBringToForeground(explorerWindow); + } + else + { + TrySetSelection(explorerWindow, normalizedPaths, normalizedFocusedPath); + } + }); + + return new WaitHelper.StableWaitResult<SelectionSnapshot>( + result.Succeeded, + result.LastObservation?.Selection, + result.ConsecutiveMatches, + result.LastException); + } + + /// <summary> + /// Set an Explorer folder view's mode and icon size through the Shell automation object, then + /// require both values to remain stable across consecutive observations. + /// </summary> + public static WaitHelper.StableWaitResult<ViewSnapshot> SetViewModeAndIconSizeAndWait( + IntPtr explorerWindow, + ViewMode mode, + int iconSize, + int timeoutMS = 15_000, + int requiredConsecutiveMatches = 3, + int pollIntervalMS = 250) + { + if (explorerWindow == IntPtr.Zero) + { + throw new ArgumentException("Explorer HWND must not be zero.", nameof(explorerWindow)); + } + + ArgumentOutOfRangeException.ThrowIfNegativeOrZero(iconSize); + + return WaitHelper.WaitForStable( + observe: () => TryGetView(explorerWindow), + isMatch: snapshot => snapshot is not null && + snapshot.Mode == mode && + snapshot.IconSize == iconSize, + timeoutMS: timeoutMS, + requiredConsecutiveMatches: requiredConsecutiveMatches, + pollIntervalMS: pollIntervalMS, + recover: _ => TrySetView(explorerWindow, mode, iconSize)); + } + + /// <summary>Read the current selected path set and focused path from an Explorer window.</summary> + public static SelectionSnapshot? TryGetSelection(IntPtr explorerWindow) + { + object? shellObject = null; + ShellWindows? shellWindows = null; + + try + { + var shellType = Type.GetTypeFromCLSID(ShellApplicationClassId, throwOnError: true)!; + shellObject = Activator.CreateInstance(shellType); + var shell = (Shell32.IShellDispatch2)shellObject!; + shellWindows = shell.Windows(); + foreach (IWebBrowserApp browser in shellWindows) + { + object? document = null; + try + { + if (browser.HWND != explorerWindow.ToInt64()) + { + continue; + } + + document = browser.Document; + if (document is not Shell32.IShellFolderViewDual2 folderView) + { + continue; + } + + var selectedPaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase); + var selectedItems = folderView.SelectedItems(); + if (selectedItems is null) + { + return null; + } + + try + { + for (var index = 0; index < selectedItems.Count; index++) + { + var item = selectedItems.Item(index); + if (item is null) + { + continue; + } + + try + { + if (TryNormalizePath(item.Path, out var selectedPath)) + { + selectedPaths.Add(selectedPath); + } + } + finally + { + Marshal.ReleaseComObject(item); + } + } + } + finally + { + Marshal.ReleaseComObject(selectedItems); + } + + var focusedItem = folderView.FocusedItem; + if (focusedItem is null) + { + return new SelectionSnapshot(selectedPaths, null); + } + + try + { + return new SelectionSnapshot( + selectedPaths, + TryNormalizePath(focusedItem.Path, out var focusedPath) ? focusedPath : null); + } + finally + { + Marshal.ReleaseComObject(focusedItem); + } + } + finally + { + ReleaseComObject(document); + ReleaseComObject(browser); + } + } + } + catch (COMException) + { + } + finally + { + ReleaseComObject(shellWindows); + ReleaseComObject(shellObject); + } + + return null; + } + + private static ViewSnapshot? TryGetView(IntPtr explorerWindow) + { + object? shellObject = null; + ShellWindows? shellWindows = null; + + try + { + var shellType = Type.GetTypeFromCLSID(ShellApplicationClassId, throwOnError: true)!; + shellObject = Activator.CreateInstance(shellType); + var shell = (Shell32.IShellDispatch2)shellObject!; + shellWindows = shell.Windows(); + foreach (IWebBrowserApp browser in shellWindows) + { + object? document = null; + try + { + if (browser.HWND != explorerWindow.ToInt64()) + { + continue; + } + + document = browser.Document; + if (document is Shell32.IShellFolderViewDual3 folderView) + { + return new ViewSnapshot((ViewMode)folderView.CurrentViewMode, folderView.IconSize); + } + } + finally + { + ReleaseComObject(document); + ReleaseComObject(browser); + } + } + } + catch (COMException) + { + } + finally + { + ReleaseComObject(shellWindows); + ReleaseComObject(shellObject); + } + + return null; + } + + private static bool TrySetView(IntPtr explorerWindow, ViewMode mode, int iconSize) + { + object? shellObject = null; + ShellWindows? shellWindows = null; + + try + { + var shellType = Type.GetTypeFromCLSID(ShellApplicationClassId, throwOnError: true)!; + shellObject = Activator.CreateInstance(shellType); + var shell = (Shell32.IShellDispatch2)shellObject!; + shellWindows = shell.Windows(); + foreach (IWebBrowserApp browser in shellWindows) + { + object? document = null; + try + { + if (browser.HWND != explorerWindow.ToInt64()) + { + continue; + } + + document = browser.Document; + if (document is not Shell32.IShellFolderViewDual3 folderView) + { + continue; + } + + folderView.CurrentViewMode = (uint)mode; + folderView.IconSize = iconSize; + return true; + } + finally + { + ReleaseComObject(document); + ReleaseComObject(browser); + } + } + } + catch (COMException) + { + } + finally + { + ReleaseComObject(shellWindows); + ReleaseComObject(shellObject); + } + + return false; + } + + private static bool TrySetSelection(IntPtr explorerWindow, IReadOnlySet<string> selectedPaths, string focusedPath) + { + object? shellObject = null; + ShellWindows? shellWindows = null; + + try + { + var shellType = Type.GetTypeFromCLSID(ShellApplicationClassId, throwOnError: true)!; + shellObject = Activator.CreateInstance(shellType); + var shell = (Shell32.IShellDispatch2)shellObject!; + shellWindows = shell.Windows(); + foreach (IWebBrowserApp browser in shellWindows) + { + object? document = null; + try + { + if (browser.HWND != explorerWindow.ToInt64()) + { + continue; + } + + document = browser.Document; + if (document is not Shell32.IShellFolderViewDual2 folderView) + { + continue; + } + + var folder = folderView.Folder; + if (folder is null) + { + return false; + } + + var folderItems = folder.Items(); + if (folderItems is null) + { + Marshal.ReleaseComObject(folder); + return false; + } + + var retainedItems = new List<Shell32.FolderItem>(); + try + { + var itemsByPath = new Dictionary<string, Shell32.FolderItem>(StringComparer.OrdinalIgnoreCase); + for (var index = 0; index < folderItems.Count; index++) + { + var item = folderItems.Item(index); + if (item is null) + { + continue; + } + + if (!TryNormalizePath(item.Path, out var normalizedPath)) + { + Marshal.ReleaseComObject(item); + continue; + } + + if (selectedPaths.Contains(normalizedPath)) + { + itemsByPath[normalizedPath] = item; + retainedItems.Add(item); + } + else + { + Marshal.ReleaseComObject(item); + } + } + + if (itemsByPath.Count != selectedPaths.Count) + { + return false; + } + + var orderedPaths = selectedPaths + .Where(path => !string.Equals(path, focusedPath, StringComparison.OrdinalIgnoreCase)) + .Append(focusedPath) + .ToList(); + + for (var index = 0; index < orderedPaths.Count; index++) + { + var path = orderedPaths[index]; + var flags = ShellViewSelect | ShellViewEnsureVisible; + if (index == 0) + { + flags |= ShellViewDeselectOthers; + } + + if (string.Equals(path, focusedPath, StringComparison.OrdinalIgnoreCase)) + { + flags |= ShellViewFocused; + } + + folderView.SelectItem(itemsByPath[path], flags); + } + + return true; + } + finally + { + foreach (var item in retainedItems) + { + Marshal.ReleaseComObject(item); + } + + Marshal.ReleaseComObject(folderItems); + Marshal.ReleaseComObject(folder); + } + } + finally + { + ReleaseComObject(document); + ReleaseComObject(browser); + } + } + } + catch (COMException) + { + } + finally + { + ReleaseComObject(shellWindows); + ReleaseComObject(shellObject); + } + + return false; + } + + private static string NormalizePath(string path) => Path.TrimEndingDirectorySeparator(Path.GetFullPath(path)); + + private static bool TryNormalizePath(string? path, out string normalizedPath) + { + normalizedPath = string.Empty; + if (string.IsNullOrWhiteSpace(path)) + { + return false; + } + + try + { + normalizedPath = NormalizePath(path); + return true; + } + catch (Exception ex) when (ex is ArgumentException or NotSupportedException or PathTooLongException) + { + return false; + } + } + + private static void ReleaseComObject(object? value) + { + if (value is not null && Marshal.IsComObject(value)) + { + Marshal.ReleaseComObject(value); + } + } +} diff --git a/src/common/UITestAutomation.Next/ScreenRecording.cs b/src/common/UITestAutomation.Next/ScreenRecording.cs index 8fc8c7e2cb..e3adfd6b81 100644 --- a/src/common/UITestAutomation.Next/ScreenRecording.cs +++ b/src/common/UITestAutomation.Next/ScreenRecording.cs @@ -3,6 +3,7 @@ // See the LICENSE file in the project root for more information. using System.Globalization; +using System.Runtime.CompilerServices; using ScreenRecorderLib; namespace Microsoft.PowerToys.UITest.Next; @@ -43,11 +44,33 @@ internal sealed class ScreenRecording : IDisposable } /// <summary> - /// True when recording can be attempted. ScreenRecorderLib ships its native encoder in-package, - /// so there is nothing to locate at runtime; a missing prerequisite (e.g. Media Foundation on a - /// Windows N/Server SKU) is reported through <c>OnRecordingFailed</c> rather than here. + /// True when recording can be attempted, i.e. the native encoder assembly actually loads. + /// ScreenRecorderLib is a mixed-mode assembly importing VCRUNTIME140/MSVCP140, so a clean Windows + /// image without the Visual C++ redistributable cannot load it at all. /// </summary> - public bool IsAvailable => true; + public bool IsAvailable => UnavailableReason is null; + + /// <summary>Null when the native encoder can load; otherwise why it cannot.</summary> + public static string? UnavailableReason + { + get + { + try + { + ProbeNativeEncoder(); + return null; + } + catch (Exception ex) + { + return $"{ex.GetType().Name}: {ex.Message}"; + } + } + } + + // Kept out of line so the JIT resolves ScreenRecorderLib when this is called rather than when the + // caller is compiled - otherwise a missing native dependency throws past the caller's try/catch. + [MethodImpl(MethodImplOptions.NoInlining)] + private static void ProbeNativeEncoder() => _ = new RecorderOptions(); /// <summary>Path the encoded MP4 will be written to.</summary> public string OutputFilePath => outputFilePath; diff --git a/src/common/UITestAutomation.Next/Session.cs b/src/common/UITestAutomation.Next/Session.cs index 64b7623554..c61b6e837b 100644 --- a/src/common/UITestAutomation.Next/Session.cs +++ b/src/common/UITestAutomation.Next/Session.cs @@ -212,7 +212,19 @@ public sealed class Session while (true) { - var matches = ExecuteSearch(by); + List<SearchHit> matches; + try + { + matches = ExecuteSearch(by); + } + catch (AssertFailedException ex) when ( + DateTime.UtcNow < deadline && + ex.Message.Contains("stale_element", StringComparison.OrdinalIgnoreCase)) + { + Thread.Sleep(200); + continue; + } + var typed = new List<T>(matches.Count); foreach (var m in matches) { @@ -303,6 +315,21 @@ public sealed class Session return outputPath; } + /// <summary> + /// Capture the session's visible DWM frame from the desktop, including composed content while + /// excluding the invisible resize border around top-level windows. + /// </summary> + public string ScreenshotVisibleWindow(string outputPath) + { + Assert.IsTrue(Scope == TargetScope.Window && WindowHandle != 0, "Visible-frame capture requires a window-scoped session."); + var windowHandle = new IntPtr(WindowHandle); + var foregroundFailure = $"HWND {WindowHandle} did not become foreground before screenshot capture. " + + $"Current foreground: {WindowControl.GetForegroundWindowInfo()}"; + Assert.IsTrue(WindowControl.WaitForForeground(windowHandle, timeoutMS: 5_000), foregroundFailure); + WindowHelper.CaptureVisibleWindow(windowHandle, outputPath); + return outputPath; + } + /// <summary>Non-asserting screenshot for cleanup / failure-artifact paths. Returns false on error.</summary> public bool TryScreenshot(string outputPath, Element? element = null, bool captureScreen = false) { diff --git a/src/common/UITestAutomation.Next/SettingsConfigHelper.cs b/src/common/UITestAutomation.Next/SettingsConfigHelper.cs index 228cdd5a43..56272d8758 100644 --- a/src/common/UITestAutomation.Next/SettingsConfigHelper.cs +++ b/src/common/UITestAutomation.Next/SettingsConfigHelper.cs @@ -15,6 +15,43 @@ namespace Microsoft.PowerToys.UITest.Next; public static class SettingsConfigHelper { private static readonly JsonSerializerOptions Indented = new() { WriteIndented = true }; + private static readonly string[] KnownModuleNames = + [ + "AdvancedPaste", + "AlwaysOnTop", + "Awake", + "CmdNotFound", + "CmdPal", + "ColorPicker", + "CropAndLock", + "CursorWrap", + "EnvironmentVariables", + "FancyZones", + "File Explorer Preview", + "File Locksmith", + "FindMyMouse", + "GrabAndMove", + "Hosts", + "Image Resizer", + "Keyboard Manager", + "LightSwitch", + "Measure Tool", + "MouseHighlighter", + "MouseJump", + "MousePointerCrosshairs", + "MouseWithoutBorders", + "NewPlus", + "Peek", + "PowerDisplay", + "PowerRename", + "PowerToys Run", + "QuickAccent", + "RegistryPreview", + "Shortcut Guide", + "TextExtractor", + "Workspaces", + "ZoomIt", + ]; /// <summary>Root of the per-user PowerToys settings: <c>%LocalAppData%\Microsoft\PowerToys</c>.</summary> public static string PowerToysSettingsRoot => Path.Combine( @@ -24,10 +61,26 @@ public static class SettingsConfigHelper private static string GlobalSettingsPath => Path.Combine(PowerToysSettingsRoot, "settings.json"); + /// <summary> + /// Snapshot a module's <c>settings.json</c> and restore its exact bytes on disposal, deleting the + /// file instead when the test created it. Use before a suite mutates persistent profile settings. + /// </summary> + public static IDisposable PreserveModuleSettings(string moduleName) + { + ArgumentException.ThrowIfNullOrWhiteSpace(moduleName); + return PreserveFile(Path.Combine(PowerToysSettingsRoot, moduleName, "settings.json")); + } + + internal static IDisposable PreserveFile(string path) + { + ArgumentException.ThrowIfNullOrWhiteSpace(path); + return new FileSnapshot(path); + } + /// <summary> /// Enable exactly the named modules in the global <c>settings.json</c> and disable every other - /// module already listed. Module names are the keys under <c>"enabled"</c> (e.g. "FancyZones", - /// "ColorPicker", "Peek"). Creates the file and keys when missing. + /// known or already-listed module. Module names are the keys under <c>"enabled"</c> + /// (e.g. "FancyZones", "ColorPicker", "Peek"). Creates the file and keys when missing. /// </summary> public static void ConfigureGlobalModuleSettings(params string[]? modulesToEnable) { @@ -38,25 +91,34 @@ public static class SettingsConfigHelper ? (JsonNode.Parse(File.ReadAllText(GlobalSettingsPath)) as JsonObject) ?? new JsonObject() : new JsonObject(); + ConfigureGlobalModuleSettings(root, modulesToEnable); + File.WriteAllText(GlobalSettingsPath, root.ToJsonString(Indented)); + } + + internal static void ConfigureGlobalModuleSettings(JsonObject root, params string[] modulesToEnable) + { if (root["enabled"] is not JsonObject enabled) { enabled = new JsonObject(); root["enabled"] = enabled; } - // Flip every already-listed module based on membership (disables the rest). + var requestedModules = modulesToEnable.ToHashSet(StringComparer.Ordinal); + foreach (var key in enabled.Select(kv => kv.Key).ToList()) { - enabled[key] = modulesToEnable.Any(m => string.Equals(m, key, StringComparison.Ordinal)); + enabled[key] = requestedModules.Contains(key); } - // Ensure the requested modules are present and enabled even if not previously listed. - foreach (var module in modulesToEnable) + foreach (var module in KnownModuleNames) + { + enabled[module] = requestedModules.Contains(module); + } + + foreach (var module in requestedModules) { enabled[module] = true; } - - File.WriteAllText(GlobalSettingsPath, root.ToJsonString(Indented)); } /// <summary> @@ -135,4 +197,38 @@ public static class SettingsConfigHelper File.WriteAllText(settingsPath, settings.ToJsonString(Indented)); } + + private sealed class FileSnapshot : IDisposable + { + private readonly string path; + private readonly bool existed; + private readonly byte[]? content; + private bool disposed; + + public FileSnapshot(string path) + { + this.path = path; + existed = File.Exists(path); + content = existed ? File.ReadAllBytes(path) : null; + } + + public void Dispose() + { + if (disposed) + { + return; + } + + disposed = true; + if (existed) + { + Directory.CreateDirectory(Path.GetDirectoryName(path)!); + File.WriteAllBytes(path, content!); + } + else + { + File.Delete(path); + } + } + } } diff --git a/src/common/UITestAutomation.Next/UITestAutomation.Next.csproj b/src/common/UITestAutomation.Next/UITestAutomation.Next.csproj index fd7277cd73..ab0f62f238 100644 --- a/src/common/UITestAutomation.Next/UITestAutomation.Next.csproj +++ b/src/common/UITestAutomation.Next/UITestAutomation.Next.csproj @@ -21,9 +21,11 @@ <!-- Engine is winappcli (Microsoft.WinAppCli) — installed once per machine via `winget install Microsoft.winappcli`. We shell out to winapp.exe and parse its - JSON output. No managed dependency on the engine — only MSTest's attribute surface. + JSON output. There is no managed dependency on the engine. --> <PackageReference Include="MSTest.TestFramework" /> + <!-- Keep visual baseline comparison byte-for-byte compatible with the legacy UI-test harness. --> + <PackageReference Include="CoenM.ImageSharp.ImageHash" /> <!-- ScreenRecorderLib encodes the optional pipeline screen recording (ScreenRecording.cs) in realtime via native Media Foundation. Pipeline-only diagnostic; no PATH/FFmpeg setup. @@ -35,6 +37,31 @@ <PackageReference Include="ScreenRecorderLib" GeneratePathProperty="true" /> </ItemGroup> + <ItemGroup> + <InternalsVisibleTo Include="UITestAutomation.Next.UnitTests" /> + </ItemGroup> + + <ItemGroup> + <COMReference Include="Shell32"> + <VersionMinor>0</VersionMinor> + <VersionMajor>1</VersionMajor> + <Guid>50a7e9b0-70ef-11d1-b75a-00a0c90564fe</Guid> + <Lcid>0</Lcid> + <WrapperTool>tlbimp</WrapperTool> + <Isolated>false</Isolated> + <EmbedInteropTypes>true</EmbedInteropTypes> + </COMReference> + <COMReference Include="SHDocVw"> + <VersionMinor>1</VersionMinor> + <VersionMajor>1</VersionMajor> + <Guid>eab22ac0-30c1-11cf-a7eb-0000c05bae0b</Guid> + <Lcid>0</Lcid> + <WrapperTool>tlbimp</WrapperTool> + <Isolated>false</Isolated> + <EmbedInteropTypes>true</EmbedInteropTypes> + </COMReference> + </ItemGroup> + <!-- Map the build platform to ScreenRecorderLib's per-architecture folder (Win32 -> x86; x64, ARM64 and x86 match by name) and copy the resolved mixed-mode assembly to output as a diff --git a/src/common/UITestAutomation.Next/UITestBase.cs b/src/common/UITestAutomation.Next/UITestBase.cs index 789d5dd69f..c2f420dbbf 100644 --- a/src/common/UITestAutomation.Next/UITestBase.cs +++ b/src/common/UITestAutomation.Next/UITestBase.cs @@ -213,7 +213,7 @@ public class UITestBase : IDisposable /// the PowerToys log files. Idempotent and fully tolerant — runs from both the <see cref="TestInit"/> /// failure path (where <c>[TestCleanup]</c> won't fire) and <see cref="TestCleanup"/>. /// </summary> - private async Task CaptureFailureArtifactsAsync() + protected async Task CaptureFailureArtifactsAsync() { if (artifactsCaptured) { @@ -222,6 +222,20 @@ public class UITestBase : IDisposable artifactsCaptured = true; + try + { + var screenshotPath = Path.Combine( + TestContext.TestResultsDirectory ?? Path.GetTempPath(), + $"failure-{Guid.NewGuid():N}.png"); + if (ScreenCapture.TryCaptureDesktop(screenshotPath)) + { + TestContext.AddResultFile(screenshotPath); + } + } + catch + { + } + if (isInPipeline) { try @@ -246,6 +260,32 @@ public class UITestBase : IDisposable } } + /// <summary> + /// Preserve and capture a failed test's terminal UI before derived cleanup closes its windows. + /// Call this at the beginning of a derived <c>[TestCleanup]</c>; passing tests return immediately. + /// </summary> + /// <param name="failureStateTail"> + /// Optional time to keep the failed UI visible in the recording before finalizing artifacts. + /// </param> + protected async Task CaptureFailureArtifactsBeforeCleanupAsync(TimeSpan failureStateTail = default) + { + ArgumentOutOfRangeException.ThrowIfLessThan(failureStateTail, TimeSpan.Zero); + + var failed = TestContext.CurrentTestOutcome is + UnitTestOutcome.Failed or UnitTestOutcome.Error or UnitTestOutcome.Unknown; + if (!failed) + { + return; + } + + if (failureStateTail > TimeSpan.Zero) + { + await Task.Delay(failureStateTail); + } + + await CaptureFailureArtifactsAsync(); + } + /// <summary> /// Bring the desktop to a known state before launching: minimize every window, dismiss any /// lingering popup with <c>Esc</c>, kill the stale PowerToys processes in @@ -327,7 +367,7 @@ public class UITestBase : IDisposable // ----- Pipeline diagnostics (CI only) --------------------------------------------------- - /// <summary>Start the FFmpeg screen recording. Best-effort.</summary> + /// <summary>Start the screen recording. Best-effort.</summary> private void StartPipelineCapture() { try @@ -339,17 +379,26 @@ public class UITestBase : IDisposable try { screenRecording = new ScreenRecording(recordingDirectory); - if (screenRecording.IsAvailable) + + // Say why there is no video: an empty recordings folder otherwise looks like a lost + // artifact, and the usual cause (no Visual C++ redistributable on a clean image) is + // invisible from the test output. + var unavailable = ScreenRecording.UnavailableReason; + if (unavailable is null) { _ = screenRecording.StartRecordingAsync(); } else { + TestContext.WriteLine( + $"Screen recording disabled - the native encoder could not load ({unavailable}). " + + "Install the Visual C++ redistributable on this machine to capture video."); screenRecording = null; } } - catch + catch (Exception ex) { + TestContext.WriteLine($"Screen recording could not start: {ex.Message}"); screenRecording = null; } } diff --git a/src/common/UITestAutomation.Next/VisualAssert.cs b/src/common/UITestAutomation.Next/VisualAssert.cs new file mode 100644 index 0000000000..d6a437897a --- /dev/null +++ b/src/common/UITestAutomation.Next/VisualAssert.cs @@ -0,0 +1,119 @@ +// Copyright (c) Microsoft Corporation +// The Microsoft Corporation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Drawing; +using CoenM.ImageHash; +using CoenM.ImageHash.HashAlgorithms; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Microsoft.PowerToys.UITest.Next; + +public static class VisualAssert +{ + private const int SimilarityThreshold = 95; + private const int VisualRetryTimeoutMS = 15_000; + private const int VisualRetryIntervalMS = 500; + + /// <summary> + /// Asserts that the current visual state of a session matches its embedded baseline image. + /// Visual validation runs only in the pipeline, matching the legacy harness behavior. + /// </summary> + [RequiresUnreferencedCode("This method uses reflection which may not be compatible with trimming.")] + public static void AreEqual(TestContext? testContext, Session session, string scenarioSubname = "") + { + if (!EnvironmentConfig.IsInPipeline) + { + Console.WriteLine("Skip visual validation in the local run."); + return; + } + + var callerMethod = new StackTrace().GetFrame(1)?.GetMethod(); + var callerName = callerMethod?.Name; + var callerClassName = callerMethod?.DeclaringType?.Name; + + if (string.IsNullOrEmpty(callerName) || string.IsNullOrEmpty(callerClassName)) + { + Assert.Fail("Unable to determine the caller method and class name."); + } + + scenarioSubname = string.IsNullOrWhiteSpace(scenarioSubname) + ? string.Join("_", callerClassName, callerName, EnvironmentConfig.Platform) + : string.Join("_", callerClassName, callerName, scenarioSubname.Trim(), EnvironmentConfig.Platform); + + var assembly = callerMethod!.DeclaringType!.Assembly; + var baselineImageResourceName = assembly.GetManifestResourceNames() + .FirstOrDefault(name => Path.GetFileNameWithoutExtension(name).EndsWith(scenarioSubname, StringComparison.Ordinal)); + var testImagePath = GetTempFilePath(scenarioSubname, "test", ".png"); + + if (string.IsNullOrEmpty(baselineImageResourceName)) + { + session.ScreenshotVisibleWindow(testImagePath); + testContext?.AddResultFile(testImagePath); + Assert.Fail($"Baseline image for scenario {scenarioSubname} can't be found; test image saved to {testImagePath}."); + } + + var baselineImagePath = GetTempFilePath(scenarioSubname, "baseline", Path.GetExtension(baselineImageResourceName)); + using var stream = assembly.GetManifestResourceStream(baselineImageResourceName); + if (stream is null) + { + Assert.Fail($"Resource stream '{baselineImageResourceName}' is null."); + } + + using var baselineImage = new Bitmap(stream!); + var deadline = DateTime.UtcNow + TimeSpan.FromMilliseconds(VisualRetryTimeoutMS); + var similarity = 0d; + do + { + session.ScreenshotVisibleWindow(testImagePath); + using var testImage = new Bitmap(testImagePath); + similarity = CalculateSimilarity(baselineImage, testImage); + if (similarity >= SimilarityThreshold) + { + return; + } + + if (DateTime.UtcNow < deadline) + { + Thread.Sleep(VisualRetryIntervalMS); + } + } + while (DateTime.UtcNow < deadline); + + baselineImage.Save(baselineImagePath); + testContext?.AddResultFile(baselineImagePath); + testContext?.AddResultFile(testImagePath); + Assert.Fail( + $"Visual result for scenario {scenarioSubname} did not reach {SimilarityThreshold}% similarity " + + $"within {VisualRetryTimeoutMS / 1_000}s (last similarity: {similarity:F2}%). " + + $"Baseline: {baselineImagePath}; test image: {testImagePath}."); + } + + private static string GetTempFilePath(string scenario, string imageType, string extension) + { + var fileName = $"{scenario}_{imageType}{extension}"; + foreach (var invalidCharacter in Path.GetInvalidFileNameChars()) + { + fileName = fileName.Replace(invalidCharacter, '-'); + } + + return Path.Combine(Path.GetTempPath(), fileName); + } + + private static double CalculateSimilarity(Bitmap baselineImage, Bitmap testImage) + { + var hashAlgorithm = new AverageHash(); + using var baselineStream = new MemoryStream(); + using var testStream = new MemoryStream(); + baselineImage.Save(baselineStream, System.Drawing.Imaging.ImageFormat.Png); + testImage.Save(testStream, System.Drawing.Imaging.ImageFormat.Png); + baselineStream.Position = 0; + testStream.Position = 0; + + var baselineHash = hashAlgorithm.Hash(baselineStream); + var testHash = hashAlgorithm.Hash(testStream); + return CompareHash.Similarity(baselineHash, testHash); + } +} \ No newline at end of file diff --git a/src/common/UITestAutomation.Next/WaitHelper.cs b/src/common/UITestAutomation.Next/WaitHelper.cs new file mode 100644 index 0000000000..cbd3736cf2 --- /dev/null +++ b/src/common/UITestAutomation.Next/WaitHelper.cs @@ -0,0 +1,71 @@ +// Copyright (c) Microsoft Corporation +// The Microsoft Corporation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +namespace Microsoft.PowerToys.UITest.Next; + +/// <summary>Polling helpers for UI state that must remain true across consecutive observations.</summary> +public static class WaitHelper +{ + /// <summary>The final state of a stable wait, including its last observation or retryable exception.</summary> + public readonly record struct StableWaitResult<T>(bool Succeeded, T? LastObservation, int ConsecutiveMatches, Exception? LastException = null); + + /// <summary> + /// Poll <paramref name="observe"/> until <paramref name="isMatch"/> is true for + /// <paramref name="requiredConsecutiveMatches"/> consecutive samples. A mismatch resets the + /// sample count and invokes the optional recovery action. Exceptions propagate unless + /// <paramref name="shouldRetryException"/> explicitly classifies them as transient. + /// </summary> + public static StableWaitResult<T> WaitForStable<T>( + Func<T?> observe, + Func<T?, bool> isMatch, + int timeoutMS, + int requiredConsecutiveMatches = 1, + int pollIntervalMS = 100, + Action<T?>? recover = null, + Func<Exception, bool>? shouldRetryException = null) + { + ArgumentNullException.ThrowIfNull(observe); + ArgumentNullException.ThrowIfNull(isMatch); + ArgumentOutOfRangeException.ThrowIfNegativeOrZero(timeoutMS); + ArgumentOutOfRangeException.ThrowIfNegativeOrZero(requiredConsecutiveMatches); + ArgumentOutOfRangeException.ThrowIfNegativeOrZero(pollIntervalMS); + + var stopwatch = System.Diagnostics.Stopwatch.StartNew(); + var consecutiveMatches = 0; + T? lastObservation = default; + Exception? lastException = null; + + while (stopwatch.ElapsedMilliseconds < timeoutMS) + { + try + { + lastObservation = observe(); + if (isMatch(lastObservation)) + { + consecutiveMatches++; + if (consecutiveMatches >= requiredConsecutiveMatches) + { + return new StableWaitResult<T>(true, lastObservation, consecutiveMatches); + } + } + else + { + consecutiveMatches = 0; + recover?.Invoke(lastObservation); + } + + lastException = null; + } + catch (Exception ex) when (shouldRetryException?.Invoke(ex) == true) + { + consecutiveMatches = 0; + lastException = ex; + } + + Thread.Sleep(pollIntervalMS); + } + + return new StableWaitResult<T>(false, lastObservation, consecutiveMatches, lastException); + } +} diff --git a/src/common/UITestAutomation.Next/WinappCli.cs b/src/common/UITestAutomation.Next/WinappCli.cs index b21114e48f..5e48b52f9b 100644 --- a/src/common/UITestAutomation.Next/WinappCli.cs +++ b/src/common/UITestAutomation.Next/WinappCli.cs @@ -28,6 +28,8 @@ namespace Microsoft.PowerToys.UITest.Next; /// </remarks> public static class WinappCli { + internal const string InvokeTimeoutSecondsEnvironmentVariable = "WINAPP_CLI_INVOKE_TIMEOUT_SECONDS"; + /// <summary>Stable hint surfaced when the CLI is missing or fails — used in all error paths.</summary> public const string InstallHint = "winapp.exe not found. Install once with: winget install Microsoft.winappcli " + @@ -254,9 +256,17 @@ public static class WinappCli /// command carries its own <c>-t</c>/<c>--timeout</c> wait in milliseconds (e.g. <c>wait-for</c>), the /// guard is extended past that wait plus a grace margin so a legitimate long wait isn't killed early. /// </summary> - private static TimeSpan ResolveInvokeTimeout(string[] args) + internal static TimeSpan ResolveInvokeTimeout(string[] args) { - var budget = DefaultInvokeTimeout; + var configuredSeconds = Environment.GetEnvironmentVariable(InvokeTimeoutSecondsEnvironmentVariable); + var budget = int.TryParse( + configuredSeconds, + NumberStyles.Integer, + CultureInfo.InvariantCulture, + out var seconds) && + seconds is > 0 and <= 3_600 + ? TimeSpan.FromSeconds(seconds) + : DefaultInvokeTimeout; for (var i = 0; i < args.Length - 1; i++) { if ((string.Equals(args[i], "-t", StringComparison.Ordinal) || diff --git a/src/common/UITestAutomation.Next/WindowControl.cs b/src/common/UITestAutomation.Next/WindowControl.cs index 546b0f1efe..d99094efa5 100644 --- a/src/common/UITestAutomation.Next/WindowControl.cs +++ b/src/common/UITestAutomation.Next/WindowControl.cs @@ -42,6 +42,10 @@ public static class WindowControl [DllImport("user32.dll", SetLastError = true)] private static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId); + [DllImport("user32.dll", SetLastError = true)] + [return: MarshalAs(UnmanagedType.Bool)] + private static extern bool GetGUIThreadInfo(uint idThread, ref GUITHREADINFO lpgui); + [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Unicode)] private static extern int GetClassNameW(IntPtr hWnd, [Out] char[] lpClassName, int nMaxCount); @@ -77,6 +81,7 @@ public static class WindowControl private delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam); private const uint WM_CLOSE = 0x0010; + private const uint WM_CONTEXTMENU = 0x007B; private const int SW_RESTORE = 9; [StructLayout(LayoutKind.Sequential)] @@ -88,12 +93,29 @@ public static class WindowControl public int Bottom; } + [StructLayout(LayoutKind.Sequential)] + private struct GUITHREADINFO + { + public int Size; + public uint Flags; + public IntPtr ActiveWindow; + public IntPtr FocusedWindow; + public IntPtr CaptureWindow; + public IntPtr MenuOwnerWindow; + public IntPtr MoveSizeWindow; + public IntPtr CaretWindow; + public RECT CaretRectangle; + } + /// <summary> /// A top-level window discovered by <see cref="EnumerateProcessWindows"/> / <see cref="EnumerateAllWindows"/>: /// its native handle, owning process id, window class, title, size in physical pixels, and visibility. /// </summary> public readonly record struct ProcessWindow(IntPtr Hwnd, int ProcessId, string ClassName, string Title, int Width, int Height, bool IsVisible); + /// <summary>Diagnostic details for the current foreground window.</summary> + public readonly record struct ForegroundWindowInfo(IntPtr Hwnd, int ProcessId, string ProcessName, string ClassName, string Title, bool? IsElevated); + /// <summary> /// Enumerate the top-level windows owned by any process in <paramref name="processIds"/> using the /// pure Win32 <c>EnumWindows</c> API. Unlike winappcli's UI-Automation-backed <c>list-windows</c>, @@ -319,6 +341,83 @@ public static class WindowControl } } + /// <summary>Return the current foreground window handle.</summary> + public static IntPtr GetForegroundWindowHandle() => GetForegroundWindow(); + + /// <summary>Open the context menu owned by the control that currently has focus in a foreground window.</summary> + public static bool TryOpenContextMenuForFocusedControl(IntPtr ownerWindow) + { + if (ownerWindow == IntPtr.Zero || !IsWindow(ownerWindow) || !TryBringToForeground(ownerWindow)) + { + return false; + } + + var threadId = GetWindowThreadProcessId(ownerWindow, out _); + var threadInfo = new GUITHREADINFO { Size = Marshal.SizeOf<GUITHREADINFO>() }; + var targetWindow = GetGUIThreadInfo(threadId, ref threadInfo) && threadInfo.FocusedWindow != IntPtr.Zero + ? threadInfo.FocusedWindow + : ownerWindow; + return PostMessageW(targetWindow, WM_CONTEXTMENU, targetWindow, new IntPtr(-1)); + } + + /// <summary>Return process, class, title, and elevation details for the current foreground HWND.</summary> + public static ForegroundWindowInfo GetForegroundWindowInfo() + { + var hwnd = GetForegroundWindow(); + if (hwnd == IntPtr.Zero) + { + return new ForegroundWindowInfo(IntPtr.Zero, 0, string.Empty, string.Empty, string.Empty, null); + } + + var foregroundThreadId = GetWindowThreadProcessId(hwnd, out var processId); + if (foregroundThreadId == 0) + { + processId = 0; + } + + var processName = string.Empty; + if (processId != 0) + { + try + { + using var process = Process.GetProcessById((int)processId); + processName = process.ProcessName; + } + catch + { + } + } + + return new ForegroundWindowInfo( + hwnd, + (int)processId, + processName, + GetWindowClassName(hwnd), + GetWindowTitle(hwnd), + processId == 0 ? null : ElevationHelper.IsProcessElevated((int)processId)); + } + + /// <summary>Bring an HWND forward until it owns foreground for the requested consecutive samples.</summary> + public static bool WaitForForeground( + IntPtr hwnd, + int timeoutMS = 5_000, + int requiredConsecutiveMatches = 1, + int pollIntervalMS = 100) + { + if (hwnd == IntPtr.Zero) + { + return false; + } + + return WaitHelper.WaitForStable( + observe: GetForegroundWindow, + isMatch: foreground => foreground == hwnd, + timeoutMS: timeoutMS, + requiredConsecutiveMatches: requiredConsecutiveMatches, + pollIntervalMS: pollIntervalMS, + recover: _ => TryBringToForeground(hwnd)).Succeeded; + } + public static bool TryFocusByApp(string appNameOrPid) { try @@ -432,6 +531,79 @@ public static class WindowControl } } + /// <summary> + /// Force-terminate every exact-name process tree and wait until no matching process remains. + /// Unlike <see cref="TryKillProcessByName"/>, this also treats an already-absent process as success. + /// </summary> + public static bool TryKillProcessTreeByNameAndWait(string exactProcessName, int timeoutMS = 10_000) + { + ArgumentException.ThrowIfNullOrWhiteSpace(exactProcessName); + ArgumentOutOfRangeException.ThrowIfNegativeOrZero(timeoutMS); + + var deadline = DateTime.UtcNow + TimeSpan.FromMilliseconds(timeoutMS); + while (DateTime.UtcNow < deadline) + { + var processes = Process.GetProcessesByName(exactProcessName); + if (processes.Length == 0) + { + return true; + } + + try + { + foreach (var process in processes) + { + try + { + if (!process.HasExited) + { + process.Kill(entireProcessTree: true); + } + } + catch + { + } + } + + foreach (var process in processes) + { + try + { + var remainingMS = Math.Max(0, (int)(deadline - DateTime.UtcNow).TotalMilliseconds); + if (!process.WaitForExit(remainingMS)) + { + return false; + } + } + catch + { + return false; + } + } + } + finally + { + foreach (var process in processes) + { + process.Dispose(); + } + } + } + + var remainingProcesses = Process.GetProcessesByName(exactProcessName); + try + { + return remainingProcesses.Length == 0; + } + finally + { + foreach (var process in remainingProcesses) + { + process.Dispose(); + } + } + } + private static void TryCloseHwnd(long hwnd) { try diff --git a/src/common/UITestAutomation.Next/WindowHelper.cs b/src/common/UITestAutomation.Next/WindowHelper.cs index e192261e7a..088648e46a 100644 --- a/src/common/UITestAutomation.Next/WindowHelper.cs +++ b/src/common/UITestAutomation.Next/WindowHelper.cs @@ -49,11 +49,15 @@ public static class WindowHelper } private const uint SWP_NOMOVE = 0x0002; + private const uint SWP_NOSIZE = 0x0001; private const uint SWP_NOZORDER = 0x0004; private const uint SWP_NOACTIVATE = 0x0010; + private const int GWL_EXSTYLE = -20; + private const long WS_EX_TOPMOST = 0x00000008L; private const int SM_CXSCREEN = 0; private const int SM_CYSCREEN = 1; private const int SW_MAXIMIZE = 3; + private const int DwmExtendedFrameBoundsAttribute = 9; [DllImport("user32.dll", SetLastError = true)] [return: MarshalAs(UnmanagedType.Bool)] @@ -63,6 +67,9 @@ public static class WindowHelper [return: MarshalAs(UnmanagedType.Bool)] private static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int x, int y, int cx, int cy, uint uFlags); + [DllImport("user32.dll", EntryPoint = "GetWindowLongPtrW", SetLastError = true)] + private static extern IntPtr GetWindowLongPtr(IntPtr hWnd, int nIndex); + [DllImport("user32.dll")] [return: MarshalAs(UnmanagedType.Bool)] private static extern bool ShowWindow(IntPtr hWnd, int nCmdShow); @@ -79,6 +86,12 @@ public static class WindowHelper [DllImport("gdi32.dll")] private static extern uint GetPixel(IntPtr hdc, int x, int y); + [DllImport("dwmapi.dll")] + private static extern int DwmGetWindowAttribute(IntPtr hWnd, int dwAttribute, out RECT pvAttribute, int cbAttribute); + + [DllImport("dwmapi.dll")] + private static extern int DwmFlush(); + /// <summary>True when any UIA-visible window's title contains <paramref name="titleContains"/> (CLI-based).</summary> public static bool IsWindowOpen(string titleContains) => WindowsFinder.ListAll().Any(w => w.Title.Contains(titleContains, StringComparison.OrdinalIgnoreCase)); @@ -115,6 +128,10 @@ public static class WindowHelper public static void SetMainWindowSize(IntPtr hWnd, int width, int height) => SetWindowPos(hWnd, IntPtr.Zero, 0, 0, width, height, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE); + /// <summary>Move a window to explicit screen coordinates while preserving its current size.</summary> + public static void MoveWindow(IntPtr hWnd, int x, int y) => + SetWindowPos(hWnd, IntPtr.Zero, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE); + /// <summary> /// Maximize a window so it fills the monitor work area and is fully on-screen. Used as the default /// window state for tests so a module's restored (possibly small or off-screen) last window rect @@ -133,6 +150,53 @@ public static class WindowHelper return (0, 0, 0, 0); } + /// <summary> + /// Capture the visible DWM frame from the screen. Unlike PrintWindow, this includes composed + /// WinUI/WebView content; unlike a raw GetWindowRect capture, it excludes invisible resize borders. + /// </summary> + public static void CaptureVisibleWindow(IntPtr hWnd, string outputPath) + { + var result = DwmGetWindowAttribute( + hWnd, + DwmExtendedFrameBoundsAttribute, + out var bounds, + Marshal.SizeOf<RECT>()); + if (result != 0 || bounds.Right <= bounds.Left || bounds.Bottom <= bounds.Top) + { + throw new InvalidOperationException($"Unable to read visible frame bounds for HWND {hWnd} (HRESULT 0x{result:X8})."); + } + + var wasTopmost = (GetWindowLongPtr(hWnd, GWL_EXSTYLE).ToInt64() & WS_EX_TOPMOST) != 0; + var noMoveOrResize = SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE; + var topmost = new IntPtr(-1); + var notTopmost = new IntPtr(-2); + + try + { + SetWindowPos(hWnd, topmost, 0, 0, 0, 0, noMoveOrResize); + DwmFlush(); + + using var bitmap = new Bitmap(bounds.Right - bounds.Left, bounds.Bottom - bounds.Top); + using var graphics = Graphics.FromImage(bitmap); + graphics.CopyFromScreen( + bounds.Left, + bounds.Top, + 0, + 0, + bitmap.Size, + CopyPixelOperation.SourceCopy); + bitmap.Save(outputPath, System.Drawing.Imaging.ImageFormat.Png); + } + finally + { + if (!wasTopmost) + { + SetWindowPos(hWnd, notTopmost, 0, 0, 0, 0, noMoveOrResize); + DwmFlush(); + } + } + } + /// <summary>Center point of the window in screen pixels.</summary> public static (int CenterX, int CenterY) GetWindowCenter(IntPtr hWnd) { diff --git a/src/modules/FileLocksmith/FileLocksmithUI/FileLocksmithXAML/Views/MainPage.xaml b/src/modules/FileLocksmith/FileLocksmithUI/FileLocksmithXAML/Views/MainPage.xaml index 1959eaf820..3dffe8c46c 100644 --- a/src/modules/FileLocksmith/FileLocksmithUI/FileLocksmithXAML/Views/MainPage.xaml +++ b/src/modules/FileLocksmith/FileLocksmithUI/FileLocksmithXAML/Views/MainPage.xaml @@ -61,6 +61,7 @@ Orientation="Horizontal" Spacing="8"> <Button + AutomationProperties.AutomationId="ReloadBtn" Command="{Binding LoadProcessesCommand}" Content="{ui:FontIcon Glyph=&#xe72c;, FontSize=16}" diff --git a/src/modules/FileLocksmith/Tests/FileLocksmith.UITests/ExplorerHelper.cs b/src/modules/FileLocksmith/Tests/FileLocksmith.UITests/ExplorerHelper.cs new file mode 100644 index 0000000000..91338a625d --- /dev/null +++ b/src/modules/FileLocksmith/Tests/FileLocksmith.UITests/ExplorerHelper.cs @@ -0,0 +1,398 @@ +// Copyright (c) Microsoft Corporation +// The Microsoft Corporation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Diagnostics; +using Microsoft.PowerToys.UITest.Next; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Microsoft.PowerToys.FileLocksmith.UITests; + +/// <summary>Which Explorer context-menu surface a probe should drive.</summary> +internal enum ContextMenuTier +{ + /// <summary>Whatever the OS shows on a plain right-click: tier-1 on Windows 11, classic on Windows 10.</summary> + Default, + + /// <summary>The classic <c>#32768</c> menu, reached through "Show more options" on Windows 11.</summary> + Classic, +} + +/// <summary>One stable look at an open context menu.</summary> +internal sealed record MenuObservation(bool IsOpen, bool HasCommand, bool HasSibling); + +/// <summary> +/// Opens Explorer, establishes an exact Shell selection, and drives either context-menu tier. The +/// selection is re-established on every attempt because a slow agent re-renders the view +/// asynchronously after a module toggles or the shell restarts. +/// </summary> +internal static class ExplorerHelper +{ + public const string ClassicMenuClassName = "#32768"; + public const string ModernMenuClassName = "Microsoft.UI.Content.PopupWindowSiteBridge"; + + private const string ExplorerProcessName = "explorer"; + private const string ShowMoreOptionsCaption = "Show more options"; + private const int ExplorerTimeoutMS = 30_000; + private const int MenuSurfaceTimeoutMS = 25_000; + + private static bool shellRestarted; + + public static bool IsWindows11OrNewer => Environment.OSVersion.Version.Build >= 22_000; + + public static Session OpenFolder(string folderPath) => OpenLocation($"/n,\"{folderPath}\"", folderPath); + + /// <summary>Open "This PC", the only view that exposes drive roots as selectable Shell items.</summary> + public static Session OpenThisPc() => OpenLocation("shell:MyComputerFolder", "This PC"); + + public static bool CloseFileWindows() => + WindowControl.TryCloseByApp(ExplorerProcessName, IsExplorerFileWindow, timeoutMS: 10_000); + + /// <summary> + /// Both handlers register at module-enable time — the classic registry-COM one always, the modern + /// sparse-MSIX package on signed builds. An Explorer that was already running only surfaces them + /// after the shell restarts, so do it exactly once per test run. + /// </summary> + public static void EnsureShellRestartedOnce() + { + if (shellRestarted) + { + return; + } + + shellRestarted = true; + Thread.Sleep(3_000); + + var previousProcessIds = Process.GetProcessesByName(ExplorerProcessName) + .Select(process => + { + var id = process.Id; + process.Dispose(); + return id; + }) + .ToHashSet(); + + // Only explorer.exe: Kill(entireProcessTree) would also take down anything launched from it. + WindowControl.TryKillProcessByName(ExplorerProcessName); + + var deadline = DateTime.UtcNow + TimeSpan.FromSeconds(30); + while (DateTime.UtcNow < deadline) + { + var current = Process.GetProcessesByName(ExplorerProcessName); + var hasFreshShell = current.Any(process => !previousProcessIds.Contains(process.Id)); + foreach (var process in current) + { + process.Dispose(); + } + + if (hasFreshShell) + { + break; + } + + Thread.Sleep(500); + } + + Thread.Sleep(2_000); + } + + /// <summary> + /// Poll the requested menu tier until it reports <paramref name="expectedCommand"/> across + /// consecutive samples, re-selecting (and if needed reopening) the view on every attempt. + /// </summary> + public static (bool Succeeded, MenuObservation Last, Session Explorer) ProbeCommand( + Session explorer, + Func<Session> reopenExplorer, + string[] selection, + ContextMenuTier tier, + string commandCaption, + bool expectedCommand, + string? siblingCaption, + TestContext testContext, + int deadlineSeconds = 120) + { + var deadline = DateTime.UtcNow + TimeSpan.FromSeconds(deadlineSeconds); + var last = new MenuObservation(false, false, false); + var selectionFailures = 0; + + do + { + KeyboardHelper.SendKeys(Key.Esc); + + var selected = TrySelectStable(explorer, selection, timeoutMS: 12_000); + if (selected is null) + { + testContext.WriteLine( + $"Explorer selection did not settle for [{string.Join(", ", selection)}]. " + + $"Current foreground: {WindowControl.GetForegroundWindowInfo()}."); + if (++selectionFailures >= 2) + { + selectionFailures = 0; + explorer = reopenExplorer(); + } + + Thread.Sleep(300); + continue; + } + + selectionFailures = 0; + explorer = selected; + + var menu = OpenMenu(explorer, tier); + if (menu is null) + { + Thread.Sleep(300); + continue; + } + + var stable = WaitHelper.WaitForStable( + observe: () => Observe(menu, commandCaption, siblingCaption), + isMatch: observation => observation is not null && + observation.IsOpen && + observation.HasCommand == expectedCommand && + (siblingCaption is null || observation.HasSibling), + timeoutMS: 8_000, + requiredConsecutiveMatches: 4, + pollIntervalMS: 250); + last = stable.LastObservation ?? last; + KeyboardHelper.SendKeys(Key.Esc); + + if (stable.Succeeded) + { + return (true, last, explorer); + } + + Thread.Sleep(300); + } + while (DateTime.UtcNow < deadline); + + return (false, last, explorer); + } + + /// <summary>Open the requested tier and invoke <paramref name="commandCaption"/> on it.</summary> + public static Session InvokeCommand( + Session explorer, + Func<Session> reopenExplorer, + string[] selection, + ContextMenuTier tier, + string commandCaption, + int deadlineSeconds = 120) + { + var deadline = DateTime.UtcNow + TimeSpan.FromSeconds(deadlineSeconds); + Session? menu = null; + Element? command = null; + var selectionFailures = 0; + + do + { + var selected = TrySelectStable(explorer, selection, timeoutMS: 12_000); + if (selected is null) + { + if (++selectionFailures >= 2) + { + selectionFailures = 0; + explorer = reopenExplorer(); + } + + Thread.Sleep(300); + continue; + } + + selectionFailures = 0; + explorer = selected; + + menu = OpenMenu(explorer, tier); + if (menu is not null) + { + command = FindVisibleMenuItem(menu, commandCaption, timeoutMS: 5_000); + if (command is not null) + { + break; + } + } + + KeyboardHelper.SendKeys(Key.Esc); + Thread.Sleep(300); + } + while (DateTime.UtcNow < deadline); + + Assert.IsNotNull(menu, "Explorer did not open the expected context-menu surface."); + Assert.IsNotNull( + command, + $"Explorer did not show the '{commandCaption}' command for [{string.Join(", ", selection)}]."); + command!.Invoke(msPostAction: 300); + return explorer; + } + + /// <summary> + /// Non-throwing selection: re-establishes an exact, stable Shell selection and returns the live + /// session, handling an Explorer window that was replaced mid-render. + /// </summary> + public static Session? TrySelectStable(Session explorer, string[] paths, int timeoutMS) + { + if (ExplorerShell.SetSelectionAndWaitForStable( + new IntPtr(explorer.WindowHandle), paths, paths[0], timeoutMS, requiredConsecutiveMatches: 4).Succeeded) + { + return explorer; + } + + var replacement = FindReplacementExplorer(explorer); + if (replacement is not null && + ExplorerShell.SetSelectionAndWaitForStable( + new IntPtr(replacement.WindowHandle), paths, paths[0], timeoutMS, requiredConsecutiveMatches: 4).Succeeded) + { + return replacement; + } + + return null; + } + + public static Element? FindVisibleMenuItem(Session menu, string caption, int timeoutMS) + { + var deadline = DateTime.UtcNow + TimeSpan.FromMilliseconds(timeoutMS); + do + { + var item = menu.FindAll<Element>(By.Name(caption), timeoutMS: 250) + .FirstOrDefault(element => + element.Name.Contains(caption, StringComparison.OrdinalIgnoreCase) && + element.ControlType.Equals("MenuItem", StringComparison.OrdinalIgnoreCase) && + element.Width > 0 && + element.Height > 0); + if (item is not null) + { + return item; + } + + Thread.Sleep(100); + } + while (DateTime.UtcNow < deadline); + + return null; + } + + private static Session OpenLocation(string arguments, string diagnosticName) + { + EnsureShellRestartedOnce(); + CloseFileWindows(); + + var existingHandles = WindowsFinder.ListByApp(ExplorerProcessName) + .Where(IsExplorerFileWindow) + .Select(window => window.Hwnd) + .ToHashSet(); + + using var explorerLaunch = Process.Start(new ProcessStartInfo + { + FileName = "explorer.exe", + Arguments = arguments, + UseShellExecute = true, + }); + + var explorer = WindowsFinder.WaitForWindowByApp( + ExplorerProcessName, + window => IsExplorerFileWindow(window) && !existingHandles.Contains(window.Hwnd), + timeoutMS: ExplorerTimeoutMS); + Assert.IsNotNull(explorer, $"Explorer did not open '{diagnosticName}'."); + + EnsureForeground(explorer!); + return explorer!; + } + + private static Session? OpenMenu(Session explorer, ContextMenuTier tier) + { + EnsureForeground(explorer); + KeyboardHelper.SendKeys(Key.Esc); + + if (!WindowControl.TryOpenContextMenuForFocusedControl(new IntPtr(explorer.WindowHandle))) + { + return null; + } + + var firstSurface = WaitForMenuSurface( + IsWindows11OrNewer ? ModernMenuClassName : ClassicMenuClassName, + MenuSurfaceTimeoutMS); + if (firstSurface is null || tier == ContextMenuTier.Default || !IsWindows11OrNewer) + { + return firstSurface; + } + + // Windows 11 only: the classic menu lives one level down, behind "Show more options". + var showMoreOptions = FindVisibleMenuItem(firstSurface, ShowMoreOptionsCaption, timeoutMS: 5_000); + if (showMoreOptions is null) + { + return null; + } + + try + { + showMoreOptions.Invoke(msPostAction: 300); + } + catch (Exception) + { + // The popup can vanish between finding and invoking it; let the caller reopen the menu. + return null; + } + + return WaitForMenuSurface(ClassicMenuClassName, MenuSurfaceTimeoutMS); + } + + private static Session? WaitForMenuSurface(string className, int timeoutMS) => + WindowsFinder.WaitForWindow( + window => className == ClassicMenuClassName + ? window.ClassName.Equals(className, StringComparison.OrdinalIgnoreCase) + : window.ClassName.Contains(className, StringComparison.OrdinalIgnoreCase), + timeoutMS: timeoutMS, + pollIntervalMS: 100); + + private static MenuObservation Observe(Session menu, string commandCaption, string? siblingCaption) + { + var menuReady = menu.WindowHandle != 0 && + WindowsFinder.ListAll().Any(window => window.Hwnd == menu.WindowHandle); + if (!menuReady) + { + return new MenuObservation(false, false, false); + } + + try + { + return new MenuObservation( + true, + FindVisibleMenuItem(menu, commandCaption, timeoutMS: 250) is not null, + siblingCaption is null || FindVisibleMenuItem(menu, siblingCaption, timeoutMS: 250) is not null); + } + catch (Exception) + { + // winappcli reports the popup's HWND as gone mid-query; treat it as not-yet-stable. + return new MenuObservation(false, false, false); + } + } + + private static Session? FindReplacementExplorer(Session explorer) + { + var foregroundWindow = WindowControl.GetForegroundWindowHandle().ToInt64(); + var replacement = WindowsFinder.ListByApp(ExplorerProcessName) + .Where(IsExplorerFileWindow) + .Where(window => window.Hwnd != explorer.WindowHandle) + .OrderByDescending(window => window.Hwnd == foregroundWindow) + .FirstOrDefault(); + if (replacement is null) + { + return null; + } + + return WindowsFinder.WaitForWindow( + window => window.Hwnd == replacement.Hwnd, + timeoutMS: 2_000, + pollIntervalMS: 100); + } + + private static void EnsureForeground(Session explorer) => Assert.IsTrue( + WindowControl.WaitForForeground( + new IntPtr(explorer.WindowHandle), + ExplorerTimeoutMS, + requiredConsecutiveMatches: 3), + $"Explorer HWND {explorer.WindowHandle} was not the stable foreground window. " + + $"Current foreground: {WindowControl.GetForegroundWindowInfo()}."); + + private static bool IsExplorerFileWindow(WindowsFinder.WindowInfo window) => + window.ClassName.Equals("CabinetWClass", StringComparison.OrdinalIgnoreCase); +} diff --git a/src/modules/FileLocksmith/Tests/FileLocksmith.UITests/FileLocksmith.UITests.csproj b/src/modules/FileLocksmith/Tests/FileLocksmith.UITests/FileLocksmith.UITests.csproj new file mode 100644 index 0000000000..6ce8f6496e --- /dev/null +++ b/src/modules/FileLocksmith/Tests/FileLocksmith.UITests/FileLocksmith.UITests.csproj @@ -0,0 +1,33 @@ +<Project Sdk="Microsoft.NET.Sdk"> + <!-- Look at Directory.Build.props in root for common stuff as well --> + <Import Project="$(RepoRoot)src\Common.Dotnet.CsWinRT.props" /> + + <PropertyGroup> + <OutputType>Exe</OutputType> + <TargetFramework>net10.0-windows10.0.26100.0</TargetFramework> + <ImplicitUsings>enable</ImplicitUsings> + <Nullable>enable</Nullable> + <IsPackable>false</IsPackable> + <TreatWarningsAsErrors>false</TreatWarningsAsErrors> + <RootNamespace>Microsoft.PowerToys.FileLocksmith.UITests</RootNamespace> + <AssemblyName>FileLocksmith.UITests</AssemblyName> + <ApplicationManifest>app.manifest</ApplicationManifest> + + <IsTestingPlatformApplication>true</IsTestingPlatformApplication> + <EnableMSTestRunner>true</EnableMSTestRunner> + <GenerateDocumentationFile>false</GenerateDocumentationFile> + <RunVSTest>false</RunVSTest> + </PropertyGroup> + + <PropertyGroup> + <OutputPath>$(RepoRoot)$(Platform)\$(Configuration)\tests\FileLocksmith.UITests\</OutputPath> + </PropertyGroup> + + <ItemGroup> + <PackageReference Include="MSTest" /> + </ItemGroup> + + <ItemGroup> + <ProjectReference Include="..\..\..\..\common\UITestAutomation.Next\UITestAutomation.Next.csproj" /> + </ItemGroup> +</Project> diff --git a/src/modules/FileLocksmith/Tests/FileLocksmith.UITests/FileLocksmithContextMenuTests.cs b/src/modules/FileLocksmith/Tests/FileLocksmith.UITests/FileLocksmithContextMenuTests.cs new file mode 100644 index 0000000000..5cd678be0e --- /dev/null +++ b/src/modules/FileLocksmith/Tests/FileLocksmith.UITests/FileLocksmithContextMenuTests.cs @@ -0,0 +1,384 @@ +// Copyright (c) Microsoft Corporation +// The Microsoft Corporation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using Microsoft.PowerToys.UITest.Next; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Microsoft.Win32; + +namespace Microsoft.PowerToys.FileLocksmith.UITests; + +/// <summary> +/// Explorer-driven coverage of the File Locksmith release checklist: the +/// "Unlock with File Locksmith" command on a file, a folder and a drive, and the fact that the +/// Settings toggle gates it out of both context-menu tiers without breaking the menu itself. +/// </summary> +[TestClass] +[DoNotParallelize] +public sealed class FileLocksmithContextMenuTests : UITestBase +{ + private const string ClassicHandlerKeyPath = + @"Software\Classes\AllFileSystemObjects\ShellEx\ContextMenuHandlers\FileLocksmithExt"; + + private const string ModernPackageName = "FileLocksmithContextMenu"; + + private static readonly string[] ShellIntegrationModules = + { + FileLocksmithConstants.ModuleName, + FileLocksmithConstants.PowerRenameModuleName, + }; + + private readonly List<LockingProcessFixture> fixtures = new(); + + public FileLocksmithContextMenuTests() + : base(PowerToysModule.PowerToysSettings, enableModules: ShellIntegrationModules) + { + } + + protected override bool ReuseScopeAcrossTests => true; + + protected override IReadOnlyList<string> StaleProcessNames { get; } = new[] + { + "PowerToys", + "PowerToys.Settings", + FileLocksmithConstants.UiProcessName, + }; + + [TestInitialize] + public void PrepareTest() + { + Assert.IsTrue(FileLocksmithUi.Close(), "A stale File Locksmith window could not be closed before the test."); + Assert.IsTrue(ExplorerHelper.CloseFileWindows(), "Stale Explorer file windows could not be closed before the test."); + + // Both handlers register when the runner enables the module; give that a moment to land. + WaitUntil(() => DefaultTierRegistered() || ClassicHandlerRegistered(), timeoutMS: 30_000); + } + + [TestCleanup] + public async Task CleanupTest() + { + await CaptureFailureArtifactsBeforeCleanupAsync(TimeSpan.FromSeconds(2)); + FileLocksmithUi.Close(); + ExplorerHelper.CloseFileWindows(); + + foreach (var fixture in fixtures) + { + fixture.Dispose(); + } + + fixtures.Clear(); + } + + /// <summary> + /// Checklist: right-click an executable that is currently running twice, confirm + /// "Unlock with File Locksmith" is present, and that invoking it opens the File Locksmith window + /// listing one row (with an "End task" button) per process holding the file. + /// </summary> + [TestMethod("FileLocksmith.ContextMenu.LaunchOnLockedFile")] + [TestCategory("File Locksmith")] + public void ContextMenuLaunchesFileLocksmithForLockedFile() + { + RequireDefaultTier(); + var fixture = CreateFixture(); + fixture.Start(count: 2); + + var explorer = ExplorerHelper.OpenFolder(fixture.TargetFolder); + ExplorerHelper.InvokeCommand( + explorer, + () => ExplorerHelper.OpenFolder(fixture.TargetFolder), + new[] { fixture.TargetPath }, + ContextMenuTier.Default, + FileLocksmithConstants.ContextMenuCaption); + + var ui = FileLocksmithUi.WaitForWindow(loadTimeoutMS: 60_000); + Assert.AreEqual( + FileLocksmithConstants.WindowTitle, + FileLocksmithUi.CurrentWindowTitle(), + "File Locksmith launched from the context menu was not the expected non-elevated window."); + Assert.IsTrue( + FileLocksmithUi.WaitForRowCount(ui, expected: 2, timeoutMS: 30_000), + $"File Locksmith listed {FileLocksmithUi.CountRows(ui)} row(s) for a file locked by 2 processes."); + Assert.IsTrue( + FileLocksmithUi.HasProcessRow(ui, LockingProcessFixture.LockerFileName), + $"The listed rows were not headed by '{LockingProcessFixture.LockerFileName}'."); + Assert.AreEqual( + 2, + FileLocksmithUi.CountRows(ui), + "Each listed process must offer its own End task button."); + } + + /// <summary> + /// Checklist: right-click the directory containing the executable and confirm the command is + /// present and lists the process(es) found recursively inside that directory tree. + /// </summary> + [TestMethod("FileLocksmith.ContextMenu.Directory")] + [TestCategory("File Locksmith")] + public void ContextMenuScansDirectoryRecursively() + { + RequireDefaultTier(); + + // The locked file lives one level below the folder under test, so only a recursive scan finds it. + var fixture = CreateFixture(targetSubFolder: "nested"); + fixture.Start(); + + var parentFolder = Path.GetDirectoryName(Path.TrimEndingDirectorySeparator(fixture.RootFolder))!; + var explorer = ExplorerHelper.OpenFolder(parentFolder); + ExplorerHelper.InvokeCommand( + explorer, + () => ExplorerHelper.OpenFolder(parentFolder), + new[] { fixture.RootFolder }, + ContextMenuTier.Default, + FileLocksmithConstants.ContextMenuCaption); + + var ui = FileLocksmithUi.WaitForWindow(loadTimeoutMS: 60_000); + Assert.IsTrue( + FileLocksmithUi.WaitForRowCount(ui, expected: 1, timeoutMS: 30_000), + "File Locksmith did not report the process locking a file nested inside the selected directory."); + Assert.IsTrue( + FileLocksmithUi.HasProcessRow(ui, LockingProcessFixture.LockerFileName), + $"The listed row was not headed by '{LockingProcessFixture.LockerFileName}'."); + } + + /// <summary> + /// Checklist: right-click the drive holding the executable and confirm the command is present. + /// The sparse package only registers <c>Directory</c> and <c>*</c> item types, so on Windows 11 + /// the drive command lives in the classic ("Show more options") menu. + /// </summary> + [TestMethod("FileLocksmith.ContextMenu.DriveRoot")] + [TestCategory("File Locksmith")] + public void ContextMenuIsAvailableOnDriveRoot() + { + RequireClassicTier(); + var fixture = CreateFixture(); + fixture.Start(); + + var explorer = ExplorerHelper.OpenThisPc(); + var probe = ExplorerHelper.ProbeCommand( + explorer, + ExplorerHelper.OpenThisPc, + new[] { fixture.DriveRoot }, + ContextMenuTier.Classic, + FileLocksmithConstants.ContextMenuCaption, + expectedCommand: true, + siblingCaption: null, + TestContext); + + Assert.IsTrue(probe.Last.IsOpen, "The classic context menu for the drive did not become ready."); + Assert.IsTrue( + probe.Succeeded, + $"The classic context menu for drive '{fixture.DriveRoot}' did not show " + + $"'{FileLocksmithConstants.ContextMenuCaption}'."); + } + + /// <summary> + /// Checklist: disabling File Locksmith removes its command from the tier-1 menu and from + /// "Show more options", while a sibling PowerToys command stays put — proving the menu still + /// renders and only File Locksmith was gated out. Re-enabling brings it back in both menus. + /// </summary> + [TestMethod("FileLocksmith.ContextMenu.EnabledState")] + [TestCategory("File Locksmith")] + public void ContextMenuTracksModuleEnabledState() + { + RequireDefaultTier(); + var settings = NavigateToFileLocksmithSettings(); + var toggle = settings.Find<ToggleSwitch>(By.Name(FileLocksmithConstants.ModuleName)); + Assert.IsTrue(toggle.IsOn, "File Locksmith did not start from the deterministic enabled baseline."); + + var fixture = CreateFixture(); + var folder = fixture.TargetFolder; + var selection = new[] { fixture.TargetPath }; + var tiers = ClassicHandlerRegistered() && ExplorerHelper.IsWindows11OrNewer + ? new[] { ContextMenuTier.Default, ContextMenuTier.Classic } + : new[] { ContextMenuTier.Default }; + + try + { + foreach (var tier in tiers) + { + AssertCommandPresence(folder, selection, tier, expected: true); + } + + toggle = SetModuleEnabled(toggle, false); + foreach (var tier in tiers) + { + AssertCommandPresence(folder, selection, tier, expected: false); + } + + toggle = SetModuleEnabled(toggle, true); + foreach (var tier in tiers) + { + AssertCommandPresence(folder, selection, tier, expected: true); + } + } + finally + { + try + { + SetModuleEnabled(toggle, true); + } + catch (Exception ex) + { + TestContext.WriteLine($"Restoring the File Locksmith toggle failed; restarting the scope. {ex.Message}"); + RestartScope(ShellIntegrationModules); + } + } + } + + private static bool ClassicHandlerRegistered() + { + using var key = Registry.CurrentUser.OpenSubKey(ClassicHandlerKeyPath); + return key is not null; + } + + /// <summary>The surface a plain right-click shows: tier-1 on Windows 11, classic on Windows 10.</summary> + private static bool DefaultTierRegistered() => + ExplorerHelper.IsWindows11OrNewer ? ModernPackageRegistered() : ClassicHandlerRegistered(); + + private static void RequireDefaultTier() + { + if (DefaultTierRegistered()) + { + return; + } + + Assert.Inconclusive( + ExplorerHelper.IsWindows11OrNewer + ? "The FileLocksmithContextMenu sparse package is not registered, so no Windows 11 tier-1 " + + "command can appear. Unsigned builds fail to register it (0x800B0100) — sign the .msix and " + + "trust the signer (see .pipelines/signSparsePackages.ps1)." + : "The classic File Locksmith context-menu handler is not registered. It is compiled out of " + + "Debug builds — build Release, or define ENABLE_REGISTRATION for FileLocksmithExt."); + } + + private static void RequireClassicTier() + { + if (ClassicHandlerRegistered()) + { + return; + } + + Assert.Inconclusive( + "The classic (registry-COM) File Locksmith handler is not registered, so no drive command can " + + "exist. It is compiled out of Debug builds — build Release, or define ENABLE_REGISTRATION."); + } + + private static bool WaitUntil(Func<bool> condition, int timeoutMS, int pollIntervalMS = 1_000) + { + var deadline = DateTime.UtcNow + TimeSpan.FromMilliseconds(timeoutMS); + do + { + if (condition()) + { + return true; + } + + Thread.Sleep(pollIntervalMS); + } + while (DateTime.UtcNow < deadline); + + return false; + } + + private static bool ModernPackageRegistered() + { + try + { + return new Windows.Management.Deployment.PackageManager() + .FindPackagesForUser(string.Empty) + .Any(package => package.Id.Name.Contains(ModernPackageName, StringComparison.OrdinalIgnoreCase)); + } + catch (Exception) + { + return false; + } + } + + private static bool WaitForElementSearch(Session session, By by, int timeoutMS) => + session.WaitFor( + () => session.Has(by, timeoutMS: 500), + timeoutMS: timeoutMS, + pollIntervalMS: 200); + + private static Session NavigateToFileLocksmithSettings() + { + var settings = Session.FromProcess( + "PowerToys.Settings", + PowerToysModule.PowerToysSettings, + timeoutMS: 15_000); + if (WaitForElementSearch(settings, By.AccessibilityId("FileLocksmithEnableFileLocksmith"), timeoutMS: 5_000)) + { + return settings; + } + + if (!WaitForElementSearch(settings, By.AccessibilityId("FileLocksmithNavItem"), timeoutMS: 5_000)) + { + settings.Find<NavigationViewItem>(By.AccessibilityId("FileManagementNavItem")).Click(msPostAction: 500); + Assert.IsTrue( + WaitForElementSearch(settings, By.AccessibilityId("FileLocksmithNavItem"), timeoutMS: 5_000), + "The File Management navigation group did not expose File Locksmith."); + } + + settings.Find<NavigationViewItem>(By.AccessibilityId("FileLocksmithNavItem")).Click(msPostAction: 500); + Assert.IsTrue( + WaitForElementSearch(settings, By.AccessibilityId("FileLocksmithEnableFileLocksmith"), timeoutMS: 60_000), + "The File Locksmith settings page did not become ready."); + return settings; + } + + private static ToggleSwitch SetModuleEnabled(ToggleSwitch toggle, bool enabled) + { + for (var attempt = 1; attempt <= 2; attempt++) + { + try + { + toggle.Toggle(enabled); + Assert.IsTrue( + toggle.WaitForProperty("ToggleState", enabled ? "On" : "Off", timeoutMS: 5_000), + $"The File Locksmith enable switch did not settle to {(enabled ? "On" : "Off")}."); + return toggle; + } + catch (TimeoutException) when (attempt < 2) + { + var settings = Session.FromProcess( + "PowerToys.Settings", + PowerToysModule.PowerToysSettings, + timeoutMS: 15_000); + toggle = settings.Find<ToggleSwitch>(By.Name(FileLocksmithConstants.ModuleName), timeoutMS: 15_000); + } + } + + return toggle; + } + + private void AssertCommandPresence(string folder, string[] selection, ContextMenuTier tier, bool expected) + { + var probe = ExplorerHelper.ProbeCommand( + ExplorerHelper.OpenFolder(folder), + () => ExplorerHelper.OpenFolder(folder), + selection, + tier, + FileLocksmithConstants.ContextMenuCaption, + expected, + siblingCaption: FileLocksmithConstants.PowerRenameContextMenuCaption, + TestContext); + + var surface = tier == ContextMenuTier.Classic ? "classic" : "default"; + Assert.IsTrue(probe.Last.IsOpen, $"The {surface} Explorer context menu did not become ready."); + Assert.IsTrue( + probe.Last.HasSibling, + $"The {surface} Explorer context menu did not render the sibling PowerRename command, so its " + + $"'{FileLocksmithConstants.ContextMenuCaption}' state cannot be trusted."); + Assert.AreEqual( + expected, + probe.Last.HasCommand, + $"The {surface} Explorer context menu did {(expected ? "not show" : "show")} " + + $"'{FileLocksmithConstants.ContextMenuCaption}'."); + } + + private LockingProcessFixture CreateFixture(string? targetSubFolder = null) + { + var fixture = new LockingProcessFixture(targetSubFolder); + fixtures.Add(fixture); + return fixture; + } +} diff --git a/src/modules/FileLocksmith/Tests/FileLocksmith.UITests/FileLocksmithProcessListTests.cs b/src/modules/FileLocksmith/Tests/FileLocksmith.UITests/FileLocksmithProcessListTests.cs new file mode 100644 index 0000000000..b787666723 --- /dev/null +++ b/src/modules/FileLocksmith/Tests/FileLocksmith.UITests/FileLocksmithProcessListTests.cs @@ -0,0 +1,280 @@ +// Copyright (c) Microsoft Corporation +// The Microsoft Corporation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Diagnostics; +using Microsoft.PowerToys.UITest.Next; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Microsoft.PowerToys.FileLocksmith.UITests; + +/// <summary> +/// Coverage of what the File Locksmith window does once it is open: End task, Reload, automatic +/// delisting, recursive drive scans, and the elevation boundary. +/// </summary> +/// <remarks> +/// These tests start <c>PowerToys.FileLocksmithUI.exe</c> through the product's own paths-file IPC +/// instead of Explorer, so a failure points at the window rather than at the shell. +/// <see cref="FileLocksmithContextMenuTests"/> owns the context-menu surface. +/// </remarks> +[TestClass] +[DoNotParallelize] +public sealed class FileLocksmithProcessListTests : UITestBase +{ + private const int DriveScanTimeoutMS = 180_000; + + private static readonly string[] FileLocksmithModule = { FileLocksmithConstants.ModuleName }; + + private readonly List<LockingProcessFixture> fixtures = new(); + + public FileLocksmithProcessListTests() + : base(PowerToysModule.PowerToysSettings, enableModules: FileLocksmithModule) + { + } + + protected override bool ReuseScopeAcrossTests => true; + + protected override IReadOnlyList<string> StaleProcessNames { get; } = new[] + { + "PowerToys", + "PowerToys.Settings", + FileLocksmithConstants.UiProcessName, + }; + + [TestInitialize] + public void PrepareTest() => Assert.IsTrue( + FileLocksmithUi.Close(), + "A stale File Locksmith window could not be closed before the test."); + + [TestCleanup] + public async Task CleanupTest() + { + await CaptureFailureArtifactsBeforeCleanupAsync(TimeSpan.FromSeconds(2)); + FileLocksmithUi.Close(); + + foreach (var fixture in fixtures) + { + fixture.Dispose(); + } + + fixtures.Clear(); + } + + /// <summary> + /// Checklist: End task on each listed process terminates it and removes its row, leaving the + /// empty-list state behind. + /// </summary> + [TestMethod("FileLocksmith.List.EndTask")] + [TestCategory("File Locksmith")] + public void EndTaskTerminatesEachProcessAndRemovesItsRow() + { + var fixture = CreateFixture(); + fixture.Start(count: 2); + + var ui = FileLocksmithUi.Launch(fixture.TargetPath); + AssertRowCount(ui, expected: 2, timeoutMS: 30_000, "File Locksmith did not list both locking processes."); + + for (var remaining = 2; remaining > 0; remaining--) + { + var endTaskLabels = FileLocksmithUi.EndTaskLabels(ui); + Assert.AreEqual(remaining, endTaskLabels.Count, "Every listed process must offer its own End task button."); + endTaskLabels[0].Click(); + + Assert.IsTrue( + fixture.WaitForRunningCount(remaining - 1, timeoutMS: 15_000), + "End task did not terminate the process it was pressed for."); + AssertRowCount( + ui, + expected: remaining - 1, + timeoutMS: 15_000, + "The row of the ended process was not removed from the list."); + } + + Assert.IsTrue( + ui.Has(By.Name(FileLocksmithConstants.EmptyListCaption), timeoutMS: 10_000), + "File Locksmith did not fall back to its empty-list state after every process was ended."); + } + + /// <summary> + /// Checklist: a process started after the scan is only picked up once Reload is pressed. + /// </summary> + [TestMethod("FileLocksmith.List.Reload")] + [TestCategory("File Locksmith")] + public void ReloadRediscoversRestartedProcess() + { + var fixture = CreateFixture(); + fixture.Start(); + + var ui = FileLocksmithUi.Launch(fixture.TargetPath); + AssertRowCount(ui, expected: 1, timeoutMS: 30_000, "File Locksmith did not list the locking process."); + + fixture.KillOne(); + AssertRowCount(ui, expected: 0, timeoutMS: 15_000, "The exited process was not delisted."); + + fixture.Start(); + Assert.AreEqual( + 0, + FileLocksmithUi.CountRows(ui, timeoutMS: 2_000), + "File Locksmith listed a newly started process without being asked to rescan."); + + FileLocksmithUi.ClickReload(ui); + AssertRowCount(ui, expected: 1, timeoutMS: 30_000, "Reload did not rediscover the restarted process."); + } + + /// <summary> + /// Checklist: closing a listed process delists it automatically, with no manual refresh. + /// </summary> + [TestMethod("FileLocksmith.List.AutoDelist")] + [TestCategory("File Locksmith")] + public void ExitedProcessIsDelistedWithoutReload() + { + var fixture = CreateFixture(); + fixture.Start(count: 2); + + var ui = FileLocksmithUi.Launch(fixture.TargetPath); + AssertRowCount(ui, expected: 2, timeoutMS: 30_000, "File Locksmith did not list both locking processes."); + + fixture.KillOne(); + Assert.IsTrue(fixture.WaitForRunningCount(1, timeoutMS: 10_000), "The locking process did not exit."); + AssertRowCount( + ui, + expected: 1, + timeoutMS: 5_000, + "File Locksmith did not delist the exited process on its own within 5s."); + } + + /// <summary> + /// Checklist: a drive-wide scan reports the processes locking files on that volume, and scrolling + /// the (large) result list to the bottom and back does not crash File Locksmith. + /// </summary> + /// <remarks> + /// The list virtualizes, so only the realized rows are in the UIA tree; the specific-process + /// assertions live in the file and directory tests, and this one asserts the volume-wide scan + /// produced rows at all and stayed alive while they were scrolled. + /// </remarks> + [TestMethod("FileLocksmith.List.DriveScan")] + [TestCategory("File Locksmith")] + public void DriveScanListsLockingProcessesAndSurvivesScrolling() + { + var fixture = CreateFixture(); + fixture.Start(); + + var ui = FileLocksmithUi.Launch(DriveScanTimeoutMS, elevated: false, fixture.DriveRoot); + AssertListedProcesses(ui, $"Scanning drive '{fixture.DriveRoot}' reported no locking processes at all."); + + ScrollListEndToEnd(ui); + AssertUiAlive("File Locksmith did not survive scrolling the drive-wide process list."); + + if (!FileLocksmithUi.HostIsElevated) + { + TestContext.WriteLine( + "Skipped the elevated repeat of the drive scan: elevating from a non-elevated test host " + + "raises a UAC prompt that cannot be answered non-interactively."); + return; + } + + var elevatedUi = FileLocksmithUi.Launch(DriveScanTimeoutMS, elevated: true, fixture.DriveRoot); + Assert.AreEqual( + FileLocksmithConstants.ElevatedWindowTitle, + FileLocksmithUi.CurrentWindowTitle(), + "The relaunched File Locksmith did not report itself as elevated."); + AssertListedProcesses(elevatedUi, "The elevated drive-wide scan reported no locking processes at all."); + ScrollListEndToEnd(elevatedUi); + AssertUiAlive("Elevated File Locksmith did not survive scrolling the drive-wide process list."); + } + + /// <summary> + /// Checklist: a non-elevated File Locksmith cannot see a higher-integrity process and offers + /// "Restart as administrator"; the elevated window drops that button and does see the process. + /// </summary> + [TestMethod("FileLocksmith.List.Elevation")] + [TestCategory("File Locksmith")] + public void NonElevatedInstanceCannotSeeElevatedProcess() + { + var fixture = CreateFixture(); + fixture.Start(); + + var ui = FileLocksmithUi.Launch(fixture.TargetPath); + Assert.AreEqual( + FileLocksmithConstants.WindowTitle, + FileLocksmithUi.CurrentWindowTitle(), + "File Locksmith did not start as the non-elevated window."); + Assert.IsTrue( + FileLocksmithUi.HasRestartAsAdminButton(ui), + "A non-elevated File Locksmith must offer 'Restart as administrator'."); + AssertRowCount(ui, expected: 1, timeoutMS: 30_000, "File Locksmith did not list the locking process."); + + if (!FileLocksmithUi.HostIsElevated) + { + TestContext.WriteLine( + "Skipped the elevated half: an elevated locking process and the 'Restart as administrator' " + + "relaunch both need an elevated test host (otherwise UAC prompts block the run)."); + return; + } + + fixture.StartElevated(); + FileLocksmithUi.ClickReload(ui); + AssertRowCount( + ui, + expected: 1, + timeoutMS: 30_000, + "A non-elevated File Locksmith listed a higher-integrity process it cannot inspect."); + + var elevatedUi = FileLocksmithUi.LaunchElevated(fixture.TargetPath); + Assert.AreEqual( + FileLocksmithConstants.ElevatedWindowTitle, + FileLocksmithUi.CurrentWindowTitle(), + "The elevated File Locksmith did not use its administrator window title."); + Assert.IsFalse( + FileLocksmithUi.HasRestartAsAdminButton(elevatedUi), + "An elevated File Locksmith must hide 'Restart as administrator'."); + AssertRowCount( + elevatedUi, + expected: 2, + timeoutMS: 30_000, + "An elevated File Locksmith did not see the higher-integrity locking process."); + } + + private static void ScrollListEndToEnd(Session ui) + { + var list = ui.Find<Element>(By.AccessibilityId(FileLocksmithConstants.ProcessListAutomationId), timeoutMS: 15_000); + for (var pass = 0; pass < 2; pass++) + { + list.ScrollToEdge(toBottom: true); + Thread.Sleep(500); + list.ScrollToEdge(toBottom: false); + Thread.Sleep(500); + } + } + + private static void AssertRowCount(Session ui, int expected, int timeoutMS, string message) + { + var settled = expected > 0 + ? FileLocksmithUi.WaitForRowCountWithReload(ui, expected, timeoutMS) + : FileLocksmithUi.WaitForRowCount(ui, expected, timeoutMS); + Assert.IsTrue( + settled, + $"{message} Expected {expected} row(s), found {FileLocksmithUi.CountRows(ui, timeoutMS: 2_000)}."); + if (expected > 0) + { + Assert.IsTrue( + FileLocksmithUi.HasProcessRow(ui, LockingProcessFixture.LockerFileName), + $"The listed rows were not headed by '{LockingProcessFixture.LockerFileName}'."); + } + } + + private static void AssertUiAlive(string message) => Assert.IsTrue( + FileLocksmithUi.WaitForProcess(FileLocksmithConstants.UiProcessName, expected: true, timeoutMS: 2_000), + message); + + private static void AssertListedProcesses(Session ui, string message) => Assert.IsTrue( + FileLocksmithUi.CountRows(ui, timeoutMS: 30_000) > 0, + message); + + private LockingProcessFixture CreateFixture() + { + var fixture = new LockingProcessFixture(); + fixtures.Add(fixture); + return fixture; + } +} diff --git a/src/modules/FileLocksmith/Tests/FileLocksmith.UITests/FileLocksmithTestHelper.cs b/src/modules/FileLocksmith/Tests/FileLocksmith.UITests/FileLocksmithTestHelper.cs new file mode 100644 index 0000000000..9e637eb1cf --- /dev/null +++ b/src/modules/FileLocksmith/Tests/FileLocksmith.UITests/FileLocksmithTestHelper.cs @@ -0,0 +1,640 @@ +// Copyright (c) Microsoft Corporation +// The Microsoft Corporation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Diagnostics; +using System.Runtime.InteropServices; +using System.Text; +using Microsoft.PowerToys.UITest.Next; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Microsoft.PowerToys.FileLocksmith.UITests; + +/// <summary> +/// Names File Locksmith exposes to the outside world: its module key, its UI process/window, and the +/// caption both shell extensions register into the Explorer context menu. +/// </summary> +internal static class FileLocksmithConstants +{ + public const string ModuleName = "File Locksmith"; + public const string PowerRenameModuleName = "PowerRename"; + public const string UiProcessName = "PowerToys.FileLocksmithUI"; + public const string UiExecutableName = "PowerToys.FileLocksmithUI.exe"; + public const string ContextMenuCaption = "Unlock with File Locksmith"; + + /// <summary>Sibling PowerToys command used to prove the menu itself still renders.</summary> + public const string PowerRenameContextMenuCaption = "PowerRename"; + + public const string WindowTitle = "File Locksmith"; + public const string ElevatedWindowTitle = "Administrator: File Locksmith"; + + public const string ProcessListAutomationId = "ProcessesListView"; + public const string ReloadAutomationId = "ReloadBtn"; + public const string RestartAsAdminAutomationId = "RestartAsAdminBtn"; + public const string EndTaskCaption = "End task"; + public const string EmptyListCaption = "No results"; +} + +/// <summary> +/// A data file plus a set of uniquely named processes each holding an open handle to it. File +/// Locksmith reports one row per holder — the same shape the release checklist gets from the +/// PowerToys installer's two processes, but with a process name no other process can collide with. +/// </summary> +internal sealed class LockingProcessFixture : IDisposable +{ + /// <summary>Copy of <c>powershell.exe</c>: it can be told to hold a handle and keeps a unique name.</summary> + public const string LockerFileName = "PTFileLocksmithLocker.exe"; + + /// <summary>The file handed to File Locksmith.</summary> + public const string TargetFileName = "locked-file.dat"; + + private static readonly string LockerProcessName = Path.GetFileNameWithoutExtension(LockerFileName); + private static readonly string LockerSourcePath = Path.Combine( + Environment.SystemDirectory, "WindowsPowerShell", "v1.0", "powershell.exe"); + + private readonly List<Process> processes = new(); + + /// <param name="targetSubFolder"> + /// Places the locked file in a sub-folder of <see cref="RootFolder"/> so a scan of the root only + /// finds it when the scan really is recursive. + /// </param> + public LockingProcessFixture(string? targetSubFolder = null) + { + // File Locksmith matches paths by their kernel name and never resolves 8.3 aliases, so a + // short path (Path.GetTempPath() returns one whenever the profile name exceeds 8 characters) + // silently matches nothing. Measured: 0/3 detections short vs 3/3 expanded. + RootFolder = Path.Combine( + GetLongPathName(Path.GetTempPath()), + "PowerToys-FileLocksmith-UITests", + Guid.NewGuid().ToString("N")); + + var targetFolder = targetSubFolder is null ? RootFolder : Path.Combine(RootFolder, targetSubFolder); + Directory.CreateDirectory(targetFolder); + + LockerPath = Path.Combine(targetFolder, LockerFileName); + File.Copy(LockerSourcePath, LockerPath, overwrite: true); + + TargetPath = Path.Combine(targetFolder, TargetFileName); + File.WriteAllText(TargetPath, "PowerToys File Locksmith UI test fixture."); + + Assert.IsTrue( + File.Exists(LockerPath) && File.Exists(TargetPath), + $"The locking fixture was not written to disk under '{targetFolder}'."); + } + + /// <summary>Temp tree that owns the fixture; scanning it must find the holders recursively.</summary> + public string RootFolder { get; } + + /// <summary>Full path of the file the started processes hold open.</summary> + public string TargetPath { get; } + + /// <summary>Full path of the uniquely named executable the holders run.</summary> + public string LockerPath { get; } + + /// <summary>Folder that directly contains <see cref="TargetPath"/>.</summary> + public string TargetFolder => Path.GetDirectoryName(TargetPath)!; + + private string HolderErrorLogPath => Path.Combine(RootFolder, "holder-error.log"); + + /// <summary>Volume root the fixture lives on, e.g. <c>C:\</c>.</summary> + public string DriveRoot => Path.GetPathRoot(Path.GetFullPath(RootFolder))!; + + public int RunningCount => processes.Count(process => !HasExited(process)); + + /// <summary> + /// Start <paramref name="count"/> more holders at medium integrity and wait until every one is + /// alive. File Locksmith launched from the context menu always runs non-elevated + /// (<c>RunNonElevatedEx</c>) and cannot inspect a higher-integrity process, so the fixture must + /// stay medium-IL even when the test host is elevated. + /// </summary> + public void Start(int count = 1) + { + // Expect the holders alive now plus the new ones: a test that killed a holder earlier must + // not be held to the total ever started. + var expectedAlive = RunningCount + count; + + for (var index = 0; index < count; index++) + { + processes.Add(FileLocksmithUi.HostIsElevated ? StartViaShell() : StartAsChild()); + } + + Assert.IsTrue( + WaitForRunningCount(expectedAlive, timeoutMS: 20_000), + $"Only {RunningCount} of {expectedAlive} locking processes stayed alive.{HolderDiagnostics()}"); + + // A holder that started is not yet a holder that locked, and one holder locking is not all of + // them: require a ready marker per holder so a fixture shortfall is never reported as a File + // Locksmith failure. + Assert.IsTrue( + WaitForHoldersReady(expectedAlive, timeoutMS: 30_000), + $"Only {ReadyHolderCount} of {expectedAlive} locking processes opened " + + $"'{TargetPath}'.{HolderDiagnostics()}"); + } + + /// <summary> + /// Start one holder that inherits the elevated test host's token. Only prompt-free (and only + /// meaningful) when the host is already elevated. + /// </summary> + public Process StartElevated() + { + Assert.IsTrue(FileLocksmithUi.HostIsElevated, "An elevated locking process needs an elevated test host."); + var expectedAlive = RunningCount + 1; + var process = StartAsChild(); + processes.Add(process); + Assert.IsTrue( + WaitForRunningCount(expectedAlive, timeoutMS: 20_000) && + WaitForHoldersReady(expectedAlive, timeoutMS: 30_000), + $"The elevated locking process did not open '{TargetPath}'.{HolderDiagnostics()}"); + return process; + } + + /// <summary>Terminate the oldest live instance without going through the File Locksmith UI.</summary> + public void KillOne() + { + var process = processes.FirstOrDefault(candidate => !HasExited(candidate)); + Assert.IsNotNull(process, "No locking process was alive to terminate."); + TryKill(process!); + } + + public bool WaitForRunningCount(int expected, int timeoutMS) + { + var deadline = DateTime.UtcNow + TimeSpan.FromMilliseconds(timeoutMS); + do + { + if (RunningCount == expected) + { + return true; + } + + Thread.Sleep(200); + } + while (DateTime.UtcNow < deadline); + + return RunningCount == expected; + } + + public void Dispose() + { + foreach (var process in processes) + { + TryKill(process); + process.Dispose(); + } + + processes.Clear(); + TryDeleteRoot(); + } + + [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)] + private static extern uint GetLongPathNameW(string lpszShortPath, System.Text.StringBuilder lpszLongPath, uint cchBuffer); + + private static string GetLongPathName(string path) + { + var buffer = new StringBuilder(short.MaxValue); + return GetLongPathNameW(path, buffer, (uint)buffer.Capacity) > 0 ? buffer.ToString() : path; + } + + private static bool HasExited(Process process) + { + try + { + return process.HasExited; + } + catch + { + return true; + } + } + + private static void TryKill(Process process) + { + try + { + if (!process.HasExited) + { + process.Kill(entireProcessTree: true); + process.WaitForExit(10_000); + } + } + catch + { + // The fixture may already be gone — that's exactly what several tests assert. + } + } + + /// <summary> + /// FileShare.Read (not None) so every holder really keeps its own handle: an exclusive open would + /// let only the first process hold the file and File Locksmith would correctly report one row. + /// A holder marks itself ready only after the open succeeds, and records why it could not. + /// </summary> + private string BuildHolderCommand() => + "try { $handle = [IO.File]::Open('" + TargetPath + "', 'Open', 'Read', 'Read') } " + + "catch { $_.Exception.ToString() | Set-Content '" + HolderErrorLogPath + "'; exit 1 } " + + "New-Item -ItemType File -Force -Path ('" + RootFolder + "\\ready-' + $PID + '.marker') | Out-Null; " + + "Start-Sleep -Seconds 900"; + + private int ReadyHolderCount => processes.Count(process => + !HasExited(process) && File.Exists(Path.Combine(RootFolder, $"ready-{process.Id}.marker"))); + + private bool WaitForHoldersReady(int expected, int timeoutMS) + { + var deadline = DateTime.UtcNow + TimeSpan.FromMilliseconds(timeoutMS); + do + { + if (ReadyHolderCount >= expected) + { + return true; + } + + Thread.Sleep(250); + } + while (DateTime.UtcNow < deadline); + + return ReadyHolderCount >= expected; + } + + private string HolderDiagnostics() + { + try + { + if (File.Exists(HolderErrorLogPath)) + { + return $" Holder error: {File.ReadAllText(HolderErrorLogPath).Trim()}"; + } + } + catch + { + // Diagnostics must never mask the assertion being reported. + } + + return string.Empty; + } + + private Process StartAsChild() + { + var process = Process.Start(new ProcessStartInfo + { + FileName = LockerPath, + ArgumentList = { "-NoProfile", "-NonInteractive", "-Command", BuildHolderCommand() }, + UseShellExecute = false, + CreateNoWindow = true, + RedirectStandardOutput = true, + RedirectStandardError = true, + }); + + Assert.IsNotNull(process, $"The locking-process fixture '{LockerPath}' could not be started."); + return process!; + } + + /// <summary> + /// Hand the launch to the (medium-integrity) shell so an elevated test host does not pass its own + /// token down. Explorer takes no arguments, so a generated VBScript starts the holder hidden from + /// creation; unlike a temporary .cmd console, it cannot steal foreground from the next Explorer. + /// </summary> + private Process StartViaShell() + { + var knownProcessIds = Process.GetProcessesByName(LockerProcessName) + .Select(process => + { + var id = process.Id; + process.Dispose(); + return id; + }) + .ToHashSet(); + + var encodedCommand = Convert.ToBase64String(Encoding.Unicode.GetBytes(BuildHolderCommand())); + var escapedLockerPath = LockerPath.Replace("\"", "\"\""); + var launcher = Path.Combine(RootFolder, $"start-{Guid.NewGuid():N}.vbs"); + var launcherCommand = + $"CreateObject(\"WScript.Shell\").Run \"\"\"{escapedLockerPath}\"\" -NoProfile " + + $"-NonInteractive -WindowStyle Hidden -EncodedCommand {encodedCommand}\", 0, False{Environment.NewLine}"; + File.WriteAllText(launcher, launcherCommand); + + using var shellLaunch = Process.Start(new ProcessStartInfo + { + FileName = "explorer.exe", + Arguments = $"\"{launcher}\"", + UseShellExecute = true, + }); + + var deadline = DateTime.UtcNow + TimeSpan.FromSeconds(30); + do + { + var started = Process.GetProcessesByName(LockerProcessName) + .FirstOrDefault(process => !knownProcessIds.Contains(process.Id)); + if (started is not null) + { + return started; + } + + Thread.Sleep(200); + } + while (DateTime.UtcNow < deadline); + + Assert.Fail($"The shell did not start the locking-process fixture '{LockerPath}'."); + return null!; + } + + private void TryDeleteRoot() + { + for (var attempt = 0; attempt < 5; attempt++) + { + try + { + if (Directory.Exists(RootFolder)) + { + Directory.Delete(RootFolder, recursive: true); + } + + return; + } + catch (IOException) + { + } + catch (UnauthorizedAccessException) + { + } + + Thread.Sleep(250); + } + } +} + +/// <summary> +/// Drives the File Locksmith window: writes the same paths file the shell extensions write, starts +/// <c>PowerToys.FileLocksmithUI.exe</c>, and reads/acts on the process list. +/// </summary> +/// <remarks> +/// Launching the UI directly reproduces the product's own IPC contract +/// (<c>%LocalAppData%\Microsoft\PowerToys\File Locksmith\last-run.log</c>, UTF-16 paths terminated by +/// a blank line — see <c>FileLocksmithLib/IPC.cpp</c> and +/// <c>FileLocksmithLibInterop/NativeMethods.cpp</c>). It keeps the list-behaviour tests independent +/// of Explorer; <see cref="FileLocksmithContextMenuTests"/> covers the context-menu surface itself. +/// </remarks> +internal static class FileLocksmithUi +{ + private const int LaunchTimeoutMS = 30_000; + + private static readonly Lazy<string> ExecutablePathValue = new(ResolveExecutablePath); + + /// <summary>True when the test host is elevated, which every child process it starts inherits.</summary> + public static bool HostIsElevated { get; } = ElevationHelper.IsCurrentProcessElevated(); + + /// <summary>Resolved path of <c>PowerToys.FileLocksmithUI.exe</c> in the build under test.</summary> + public static string ExecutablePath => ExecutablePathValue.Value; + + public static string PathsFilePath => Path.Combine( + SettingsConfigHelper.PowerToysSettingsRoot, + FileLocksmithConstants.ModuleName, + "last-run.log"); + + /// <summary>Start File Locksmith on <paramref name="paths"/> and wait until its list has loaded.</summary> + public static Session Launch(params string[] paths) => Launch(LaunchTimeoutMS, elevated: false, paths); + + /// <summary>Start an elevated File Locksmith. Only prompt-free when the test host is elevated.</summary> + public static Session LaunchElevated(params string[] paths) => Launch(LaunchTimeoutMS, elevated: true, paths); + + public static Session Launch(int loadTimeoutMS, bool elevated, params string[] paths) + { + Assert.IsTrue(paths.Length > 0, "At least one path must be handed to File Locksmith."); + Close(); + WritePathsFile(paths); + StartProcess(elevated); + return WaitForWindow(loadTimeoutMS); + } + + /// <summary>Bind to the File Locksmith window and block until its process list finished loading.</summary> + public static Session WaitForWindow(int loadTimeoutMS) + { + var window = WindowsFinder.WaitForWindowByApp( + FileLocksmithConstants.UiProcessName, + candidate => candidate.Width > 0 && candidate.Height > 0, + timeoutMS: LaunchTimeoutMS); + Assert.IsNotNull(window, "The File Locksmith window did not open."); + var foregroundReady = WaitHelper.WaitForStable( + observe: WindowControl.GetForegroundWindowInfo, + isMatch: foreground => foreground.ProcessId == window!.ProcessId, + timeoutMS: 10_000, + requiredConsecutiveMatches: 2, + recover: _ => WindowControl.TryFocusByApp( + window!.ProcessId.ToString(System.Globalization.CultureInfo.InvariantCulture))).Succeeded; + if (!foregroundReady) + { + Console.WriteLine( + $"File Locksmith foreground could not be confirmed; continuing with UIA. " + + $"Current foreground: {WindowControl.GetForegroundWindowInfo()}."); + } + + Assert.IsTrue( + WaitForLoaded(window, loadTimeoutMS), + $"File Locksmith was still scanning after {loadTimeoutMS}ms — its process list never appeared."); + return window; + } + + /// <summary> + /// The list only enters the UIA tree once <c>IsLoading</c> flips back to false, so its presence is + /// the authoritative "scan finished" signal. + /// </summary> + public static bool WaitForLoaded(Session ui, int timeoutMS) => ui.WaitFor( + () => ui.Has(By.AccessibilityId(FileLocksmithConstants.ProcessListAutomationId), timeoutMS: 1_000), + timeoutMS: timeoutMS, + pollIntervalMS: 500); + + /// <summary> + /// The "End task" label of every listed row, top row first. The label is matched, not its Button: + /// the button wraps an icon+text panel and exposes no UIA name of its own, so a Button-typed search + /// finds nothing. Clicking the label lands inside the button. + /// </summary> + public static IReadOnlyList<TextBlock> EndTaskLabels(Session ui, int timeoutMS = 5_000) => + ui.FindAll<TextBlock>(By.Name(FileLocksmithConstants.EndTaskCaption), timeoutMS) + .Where(label => + label.Name.Equals(FileLocksmithConstants.EndTaskCaption, StringComparison.OrdinalIgnoreCase) && + label.Width > 0 && + label.Height > 0) + .OrderBy(label => label.Y) + .ToList(); + + /// <summary> + /// Number of listed rows, counted by their End task labels - one per row, and independent of the + /// process name, which the paths header also displays. + /// </summary> + public static int CountRows(Session ui, int timeoutMS = 5_000) => EndTaskLabels(ui, timeoutMS).Count; + + /// <summary>True when at least one row is headed by <paramref name="processName"/>.</summary> + public static bool HasProcessRow(Session ui, string processName, int timeoutMS = 5_000) => + ui.FindAll<TextBlock>(By.Name(processName), timeoutMS) + .Any(row => row.Name.Equals(processName, StringComparison.OrdinalIgnoreCase)); + + public static bool WaitForRowCount(Session ui, int expected, int timeoutMS) => + ui.WaitFor( + () => CountRows(ui, timeoutMS: expected == 0 ? 500 : 2_000) == expected, + timeoutMS: timeoutMS, + pollIntervalMS: 500); + + /// <summary> + /// Wait for <paramref name="expected"/> rows, re-scanning through Reload between attempts. The + /// window scans once when it opens, so a scan that came up short can only be retried the way a + /// user would - by pressing Reload. + /// </summary> + public static bool WaitForRowCountWithReload(Session ui, int expected, int timeoutMS, int reloadAttempts = 3) + { + var perAttempt = Math.Max(timeoutMS / (reloadAttempts + 1), 3_000); + for (var attempt = 0; ; attempt++) + { + if (WaitForRowCount(ui, expected, perAttempt)) + { + return true; + } + + if (attempt >= reloadAttempts) + { + return false; + } + + ClickReload(ui); + WaitForLoaded(ui, timeoutMS: 30_000); + } + } + + /// <summary>Press the toolbar Reload (refresh) button and let the rescan start.</summary> + public static void ClickReload(Session ui) => + ui.Find<Button>(By.AccessibilityId(FileLocksmithConstants.ReloadAutomationId), timeoutMS: 10_000) + .Click(msPostAction: 300); + + public static bool HasRestartAsAdminButton(Session ui, int timeoutMS = 3_000) => + ui.Has(By.AccessibilityId(FileLocksmithConstants.RestartAsAdminAutomationId), timeoutMS); + + /// <summary>Live window title, re-read from Win32 so an elevated relaunch is observed.</summary> + public static string? CurrentWindowTitle() => + WindowsFinder.ListByApp(FileLocksmithConstants.UiProcessName) + .FirstOrDefault(window => window.Width > 0 && window.Height > 0)? + .Title; + + public static bool Close() + { + if (WindowControl.TryCloseByApp(FileLocksmithConstants.UiProcessName, timeoutMS: 5_000) && + WaitForProcess(FileLocksmithConstants.UiProcessName, expected: false, timeoutMS: 2_000)) + { + return true; + } + + return WindowControl.TryKillProcessTreeByNameAndWait(FileLocksmithConstants.UiProcessName, timeoutMS: 10_000); + } + + public static bool WaitForProcess(string processName, bool expected, int timeoutMS) + { + var deadline = DateTime.UtcNow + TimeSpan.FromMilliseconds(timeoutMS); + do + { + var processes = Process.GetProcessesByName(processName); + var running = processes.Length > 0; + foreach (var process in processes) + { + process.Dispose(); + } + + if (running == expected) + { + return true; + } + + Thread.Sleep(250); + } + while (DateTime.UtcNow < deadline); + + return false; + } + + /// <summary> + /// Write the UTF-16 paths file exactly as <c>ipc::Writer</c> does: every path followed by a wide + /// newline, then one more newline as the terminator the reader stops on. + /// </summary> + private static void WritePathsFile(IReadOnlyList<string> paths) + { + var builder = new StringBuilder(); + foreach (var path in paths) + { + builder.Append(path).Append('\n'); + } + + builder.Append('\n'); + + Directory.CreateDirectory(Path.GetDirectoryName(PathsFilePath)!); + File.WriteAllBytes(PathsFilePath, Encoding.Unicode.GetBytes(builder.ToString())); + } + + private static void StartProcess(bool elevated) + { + var executable = ExecutablePathValue.Value; + var workingDirectory = Path.GetDirectoryName(executable)!; + + if (elevated) + { + using var elevatedLaunch = Process.Start(new ProcessStartInfo + { + FileName = executable, + WorkingDirectory = workingDirectory, + UseShellExecute = true, + Verb = "runas", + }); + return; + } + + if (!HostIsElevated) + { + using var directLaunch = Process.Start(new ProcessStartInfo + { + FileName = executable, + WorkingDirectory = workingDirectory, + UseShellExecute = true, + }); + return; + } + + // An elevated test host would hand its own token to a direct child, and File Locksmith + // behaves differently when elevated. Hand the launch to the (medium-integrity) shell instead, + // which is what the context-menu extension's RunNonElevatedEx does. + using var shellLaunch = Process.Start(new ProcessStartInfo + { + FileName = "explorer.exe", + Arguments = $"\"{executable}\"", + UseShellExecute = true, + }); + } + + private static string ResolveExecutablePath() + { + var candidates = new List<string>(); + + var overrideDirectory = Environment.GetEnvironmentVariable("POWERTOYS_INSTALL_DIR"); + if (!string.IsNullOrEmpty(overrideDirectory)) + { + candidates.Add(Path.Combine(overrideDirectory, "WinUI3Apps", FileLocksmithConstants.UiExecutableName)); + } + + // The build output that holds WinUI3Apps is an ancestor of the test assembly, both locally + // (<root>\<plat>\<cfg>\tests\<proj>\<tfm>\) and in CI (the downloaded build artifact). + for (var directory = new DirectoryInfo(AppContext.BaseDirectory); directory is not null; directory = directory.Parent) + { + candidates.Add(Path.Combine(directory.FullName, "WinUI3Apps", FileLocksmithConstants.UiExecutableName)); + } + + candidates.Add(Path.Combine( + Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), + "PowerToys", + "WinUI3Apps", + FileLocksmithConstants.UiExecutableName)); + candidates.Add(Path.Combine( + Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), + "PowerToys", + "WinUI3Apps", + FileLocksmithConstants.UiExecutableName)); + + var resolved = candidates.FirstOrDefault(File.Exists); + Assert.IsNotNull( + resolved, + $"'{FileLocksmithConstants.UiExecutableName}' was not found. Looked in:{Environment.NewLine}" + + string.Join(Environment.NewLine, candidates.Distinct())); + return resolved!; + } +} diff --git a/src/modules/FileLocksmith/Tests/FileLocksmith.UITests/app.manifest b/src/modules/FileLocksmith/Tests/FileLocksmith.UITests/app.manifest new file mode 100644 index 0000000000..d990268c0b --- /dev/null +++ b/src/modules/FileLocksmith/Tests/FileLocksmith.UITests/app.manifest @@ -0,0 +1,19 @@ +<?xml version="1.0" encoding="utf-8"?> +<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1"> + <assemblyIdentity version="1.0.0.0" name="FileLocksmith.UITests.app"/> + + <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1"> + <application> + <!-- Windows 10+ feature support for unpackaged apps. --> + <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" /> + </application> + </compatibility> + + <application xmlns="urn:schemas-microsoft-com:asm.v3"> + <windowsSettings> + <!-- Element.Click drives a real mouse at the physical-pixel bounds winappcli reports, so a + DPI-unaware host would click the wrong place on a scaled display. --> + <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2</dpiAwareness> + </windowsSettings> + </application> +</assembly> diff --git a/src/modules/imageresizer/tests/ImageResizer.UITests/ImageResizer.UITests.csproj b/src/modules/imageresizer/tests/ImageResizer.UITests/ImageResizer.UITests.csproj new file mode 100644 index 0000000000..132fe0717f --- /dev/null +++ b/src/modules/imageresizer/tests/ImageResizer.UITests/ImageResizer.UITests.csproj @@ -0,0 +1,33 @@ +<Project Sdk="Microsoft.NET.Sdk"> + <!-- Look at Directory.Build.props in root for common stuff as well --> + <Import Project="$(RepoRoot)src\Common.Dotnet.CsWinRT.props" /> + + <PropertyGroup> + <OutputType>Exe</OutputType> + <TargetFramework>net10.0-windows10.0.26100.0</TargetFramework> + <ImplicitUsings>enable</ImplicitUsings> + <Nullable>enable</Nullable> + <IsPackable>false</IsPackable> + <TreatWarningsAsErrors>false</TreatWarningsAsErrors> + <RootNamespace>Microsoft.PowerToys.ImageResizer.UITests</RootNamespace> + <AssemblyName>ImageResizer.UITests</AssemblyName> + <ApplicationManifest>app.manifest</ApplicationManifest> + + <IsTestingPlatformApplication>true</IsTestingPlatformApplication> + <EnableMSTestRunner>true</EnableMSTestRunner> + <GenerateDocumentationFile>false</GenerateDocumentationFile> + <RunVSTest>false</RunVSTest> + </PropertyGroup> + + <PropertyGroup> + <OutputPath>$(RepoRoot)$(Platform)\$(Configuration)\tests\ImageResizer.UITests\</OutputPath> + </PropertyGroup> + + <ItemGroup> + <PackageReference Include="MSTest" /> + </ItemGroup> + + <ItemGroup> + <ProjectReference Include="..\..\..\..\common\UITestAutomation.Next\UITestAutomation.Next.csproj" /> + </ItemGroup> +</Project> \ No newline at end of file diff --git a/src/modules/imageresizer/tests/ImageResizer.UITests/ImageResizerEndToEndTests.cs b/src/modules/imageresizer/tests/ImageResizer.UITests/ImageResizerEndToEndTests.cs new file mode 100644 index 0000000000..bc924334de --- /dev/null +++ b/src/modules/imageresizer/tests/ImageResizer.UITests/ImageResizerEndToEndTests.cs @@ -0,0 +1,1221 @@ +// Copyright (c) Microsoft Corporation +// The Microsoft Corporation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Diagnostics; +using System.Drawing; +using System.Text.Json; +using System.Text.Json.Nodes; +using Microsoft.PowerToys.UITest.Next; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Microsoft.PowerToys.ImageResizer.UITests; + +[TestClass] +[DoNotParallelize] +public sealed class ImageResizerEndToEndTests : UITestBase +{ + private const string ClassicContextMenuClassName = "#32768"; + private const string ContextMenuCaption = "Resize with Image Resizer"; + private const string ExplorerProcessName = "explorer"; + private const string ImageResizerModuleName = "Image Resizer"; + private const string ImageResizerProcessName = "PowerToys.ImageResizer"; + private const string ModernPackageName = "ImageResizerContextMenu"; + private const string ModernContextMenuClassName = "Microsoft.UI.Content.PopupWindowSiteBridge"; + private const int DialogTimeoutMS = 30_000; + private const int ExplorerTimeoutMS = 30_000; + private const int ResizeTimeoutMS = 60_000; + private static readonly string[] ImageResizerModule = { ImageResizerModuleName }; + private static readonly ResizePreset DefaultPreset = new("UITest", ResizeFitMode.Fit, 100, 100, ResizeUnitMode.Pixel); + private static readonly JsonSerializerOptions IndentedJson = new() { WriteIndented = true }; + private static readonly string ImageResizerSettingsPath = Path.Combine( + SettingsConfigHelper.PowerToysSettingsRoot, + ImageResizerModuleName, + "settings.json"); + + private static readonly string ImageResizerSizesPath = Path.Combine( + SettingsConfigHelper.PowerToysSettingsRoot, + ImageResizerModuleName, + "sizes.json"); + + private static bool originalSettingsFileExisted; + private static string? originalSettingsContent; + private static bool originalSizesFileExisted; + private static string? originalSizesContent; + private static bool contextMenuExplorerRefreshed; + + private readonly List<string> temporaryFolders = new(); + private long explorerWindowHandle; + + public ImageResizerEndToEndTests() + : base(PowerToysModule.PowerToysSettings, enableModules: ImageResizerModule) + { + } + + protected override bool ReuseScopeAcrossTests => true; + + [ClassInitialize] + public static void InitializeClass(TestContext testContext) + { + _ = testContext; + originalSettingsFileExisted = File.Exists(ImageResizerSettingsPath); + originalSettingsContent = originalSettingsFileExisted ? File.ReadAllText(ImageResizerSettingsPath) : null; + originalSizesFileExisted = File.Exists(ImageResizerSizesPath); + originalSizesContent = originalSizesFileExisted ? File.ReadAllText(ImageResizerSizesPath) : null; + ConfigureResizeSettings(DefaultPreset); + } + + [ClassCleanup] + public static void CleanupClass() + { + TryRestoreSettingsFile(ImageResizerSizesPath, originalSizesFileExisted, originalSizesContent); + TryRestoreSettingsFile(ImageResizerSettingsPath, originalSettingsFileExisted, originalSettingsContent); + } + + [TestInitialize] + public void PrepareTest() + { + Assert.IsTrue(CloseImageResizerWindows(), "A stale Image Resizer process could not be closed before the test."); + Assert.IsTrue(CloseExplorerFileWindows(), "Stale Explorer file windows could not be closed before the test."); + } + + [TestCleanup] + public async Task CleanupTest() + { + await CaptureFailureArtifactsBeforeCleanupAsync(TimeSpan.FromSeconds(2)); + CloseImageResizerWindows(); + CloseExplorerFileWindows(); + explorerWindowHandle = 0; + ConfigureResizeSettings(DefaultPreset); + + foreach (var folder in temporaryFolders) + { + if (!DeleteDirectoryWithRetry(folder)) + { + TestContext.WriteLine($"Cleanup could not delete temporary folder '{folder}'."); + } + } + + temporaryFolders.Clear(); + } + + [TestMethod("ImageResizer.ContextMenu.EnabledState")] + [TestCategory("Image Resizer")] + public void ContextMenuTracksModuleEnabledState() + { + var settings = NavigateToImageResizerSettings(); + var toggle = settings.Find<ToggleSwitch>(By.Name("Image Resizer")); + Assert.IsTrue(toggle.IsOn, "Image Resizer did not start from the deterministic enabled baseline."); + var fixture = CreateImageFixture("context-menu.png", 400, 200); + var folder = Path.GetDirectoryName(fixture)!; + + try + { + toggle = SetModuleEnabled(toggle, false); + var explorer = OpenExplorer(folder); + + // Assert the real per-OS surface (modern tier-1 on Windows 11, classic on Windows 10) + // with no classic fallback on Windows 11 — CI signs the sparse package so it registers. + AssertContextMenuPresence(explorer, new[] { fixture }, expected: false); + + toggle = SetModuleEnabled(toggle, true); + Assert.IsTrue( + WaitForModernPackageRegistration(timeoutMS: 30_000), + "The signed Image Resizer sparse package did not finish registering after the module was re-enabled."); + contextMenuExplorerRefreshed = false; + explorer = OpenExplorer(folder); + AssertContextMenuPresence(explorer, new[] { fixture }, expected: true); + } + finally + { + try + { + SetModuleEnabled(toggle, true); + } + catch (Exception ex) + { + TestContext.WriteLine($"Restoring the Image Resizer toggle failed; restarting the deterministic scope. {ex.Message}"); + RestartScope(ImageResizerModule); + } + } + } + + [TestMethod("ImageResizer.Settings.CustomPreset")] + [TestCategory("Image Resizer")] + public void RemovedAndAddedPresetsPopulateResizeWindow() + { + var removablePreset = new ResizePreset("Remove Me", ResizeFitMode.Fit, 320, 200, ResizeUnitMode.Pixel); + var retainedPreset = new ResizePreset("Keep Me", ResizeFitMode.Fill, 200, 120, ResizeUnitMode.Pixel); + ConfigureResizeSettings(new[] { removablePreset, retainedPreset }); + RestartScope(ImageResizerModule); + var settings = NavigateToImageResizerSettings(); + + var removeButton = FindExact<Button>(settings, "Remove the Remove Me preset"); + Assert.IsNotNull(removeButton, "The removable preset was not shown in Image Resizer settings."); + removeButton!.Click(); + + // The confirmation dialog can swallow the first click before its button is hit-testable, so + // re-press Yes on every poll until the preset is actually gone. + var settingsProcess = Session.FromProcess("PowerToys.Settings"); + Assert.IsTrue( + settings.WaitFor( + () => + { + FindExact<Button>(settingsProcess, "Yes", timeoutMS: 500)?.Click(); + return FindExact<Button>(settings, "Remove the Remove Me preset", timeoutMS: 250) is null; + }, + timeoutMS: 15_000, + pollIntervalMS: 500), + "The preset remained visible after confirming its removal."); + + settings.Find<Button>(By.AccessibilityId("AddSizeButton")).Click(); + var editNewPreset = FindExact<Button>(settings, "Edit the New size 1 preset"); + Assert.IsNotNull(editNewPreset, "Adding a preset did not create 'New size 1'."); + editNewPreset!.Click(msPostAction: 500); + + // The expander toggle can miss its hit-test, leaving the editor collapsed; re-open it (the + // pencil is only present while collapsed) until its Name field is exposed. + settingsProcess = Session.FromProcess("PowerToys.Settings"); + var nameBox = FindExact<TextBox>(settingsProcess, "Name", timeoutMS: 2_000); + for (var attempt = 0; nameBox is null && attempt < 5; attempt++) + { + FindExact<Button>(settings, "Edit the New size 1 preset", timeoutMS: 1_000)?.Click(msPostAction: 750); + nameBox = FindExact<TextBox>(settingsProcess, "Name", timeoutMS: 2_000); + } + + Assert.IsNotNull(nameBox, "The new preset editor did not expose its Name field."); + nameBox!.SetText("UITest Custom"); + KeyboardHelper.SendKeys(Key.Esc); + + Assert.IsTrue( + settings.WaitFor( + () => FindExact<Button>(settings, "Edit the UITest Custom preset", timeoutMS: 250) is not null, + timeoutMS: 5_000, + pollIntervalMS: 250), + "The renamed custom preset was not persisted in Settings."); + + var fixture = CreateImageFixture("preset.png", 400, 200); + var dialog = OpenResizeDialog(fixture); + var dialogProcess = Session.FromProcess(ImageResizerProcessName); + dialogProcess.Find<ComboBox>(By.AccessibilityId("SizeComboBox")).Click(msPostAction: 300); + + Assert.IsNotNull( + FindExact<Element>(dialogProcess, "UITest Custom"), + "The newly added preset was not populated in the Image Resizer window."); + Assert.IsNull( + FindExact<Element>(dialogProcess, "Remove Me", timeoutMS: 500), + "The removed preset was still populated in the Image Resizer window."); + KeyboardHelper.SendKeys(Key.Esc); + Assert.IsTrue(dialog.Has(By.AccessibilityId("SizeComboBox")), "The Image Resizer window closed unexpectedly."); + } + + [TestMethod("ImageResizer.Resize.SingleAndMultiple")] + [TestCategory("Image Resizer")] + public void ResizesSingleAndMultipleImages() + { + ConfigureResizeSettings(DefaultPreset); + + var singleFolder = CreateTestFolder(); + var single = CreateImageFixture(singleFolder, "single.png", 400, 200); + ResizeFiles(single); + var singleOutput = WaitForResizedCopies(new[] { single }, expectedCount: 1).Single(); + AssertImageDimensions(singleOutput, 100, 50); + + var multipleFolder = CreateTestFolder(); + var landscape = CreateImageFixture(multipleFolder, "landscape.png", 400, 200); + var portrait = CreateImageFixture(multipleFolder, "portrait.png", 200, 400); + ResizeFiles(landscape, portrait); + var multipleOutputs = WaitForResizedCopies(new[] { landscape, portrait }, expectedCount: 2); + + AssertImageDimensions( + multipleOutputs.Single(path => Path.GetFileName(path).StartsWith("landscape", StringComparison.OrdinalIgnoreCase)), + 100, + 50); + AssertImageDimensions( + multipleOutputs.Single(path => Path.GetFileName(path).StartsWith("portrait", StringComparison.OrdinalIgnoreCase)), + 50, + 100); + } + + [TestMethod("ImageResizer.Resize.GifWarning")] + [TestCategory("Image Resizer")] + public void GifSelectionShowsAnimationWarning() + { + ConfigureResizeSettings(DefaultPreset); + var gif = CreateImageFixture("animated.gif", 200, 100); + var dialog = OpenResizeDialog(gif); + + const string warning = "Gif files with animations may not be correctly resized."; + Assert.IsNotNull( + FindExact<Element>(dialog, warning), + $"The Image Resizer window did not show the expected GIF warning: '{warning}'."); + } + + [TestMethod("ImageResizer.Resize.FitModes")] + [TestCategory("Image Resizer")] + [DataRow("Fill", 0, 100, 100)] + [DataRow("Fit", 1, 100, 50)] + [DataRow("Stretch", 2, 100, 100)] + public void ResizesImagesWithEveryFitMode(string modeName, int fitValue, int expectedWidth, int expectedHeight) + { + var preset = new ResizePreset(modeName, (ResizeFitMode)fitValue, 100, 100, ResizeUnitMode.Pixel); + ConfigureResizeSettings(preset); + var folder = CreateTestFolder(); + var source = CreateStripedImageFixture(folder, $"{modeName.ToLowerInvariant()}.png", 400, 200); + + ResizeFiles(source); + var output = WaitForResizedCopies(new[] { source }, expectedCount: 1).Single(); + AssertImageDimensions(output, expectedWidth, expectedHeight); + + if ((ResizeFitMode)fitValue == ResizeFitMode.Fill) + { + AssertPixelDominatedBy(output, 10, 50, ColorChannel.Green); + AssertPixelDominatedBy(output, 90, 50, ColorChannel.Green); + } + else if ((ResizeFitMode)fitValue == ResizeFitMode.Stretch) + { + AssertPixelDominatedBy(output, 10, 50, ColorChannel.Red); + AssertPixelDominatedBy(output, 90, 50, ColorChannel.Blue); + } + } + + [TestMethod("ImageResizer.Resize.Units")] + [TestCategory("Image Resizer")] + [DataRow("Centimeters", 0, 2.54, 2.54, 96, 96)] + [DataRow("Inches", 1, 1.0, 1.0, 96, 96)] + [DataRow("Percent", 2, 50.0, 50.0, 200, 100)] + [DataRow("Pixels", 3, 120.0, 80.0, 120, 80)] + public void ResizesImagesUsingEveryDimensionUnit( + string unitName, + int unitValue, + double width, + double height, + int expectedWidth, + int expectedHeight) + { + var preset = new ResizePreset(unitName, ResizeFitMode.Stretch, width, height, (ResizeUnitMode)unitValue); + ConfigureResizeSettings(preset); + var source = CreateImageFixture($"{unitName.ToLowerInvariant()}.png", 400, 200); + + ResizeFiles(source); + var output = WaitForResizedCopies(new[] { source }, expectedCount: 1).Single(); + AssertImageDimensions(output, expectedWidth, expectedHeight); + } + + [TestMethod("ImageResizer.Resize.FilenameFormat")] + [TestCategory("Image Resizer")] + public void AppliesFilenameFormatToResizedImage() + { + const string format = "%1 - %2 - %3 - %4 - %5 - %6"; + var preset = new ResizePreset("Format", ResizeFitMode.Fit, 100, 100, ResizeUnitMode.Pixel); + ConfigureResizeSettings(preset, fileNameFormat: format); + var source = CreateImageFixture("format.png", 400, 200); + + ResizeFiles(source); + var output = WaitForResizedCopies(new[] { source }, expectedCount: 1).Single(); + Assert.AreEqual( + "format - Format - 100 - 100 - 100 - 50.png", + Path.GetFileName(output), + "The resized image filename did not apply all six format parameters."); + } + + [TestMethod("ImageResizer.Resize.KeepDateModified")] + [TestCategory("Image Resizer")] + public void KeepsOriginalModifiedDateWhenReplacingImage() + { + ConfigureResizeSettings(DefaultPreset, replace: true, keepDateModified: true); + var source = CreateImageFixture("keep-date.png", 400, 200); + var originalModifiedTime = new DateTime(2020, 2, 3, 4, 5, 6, DateTimeKind.Utc); + File.SetLastWriteTimeUtc(source, originalModifiedTime); + + var dialog = OpenResizeDialog(source); + AssertDialogCheckBox(dialog, "Overwrite files", expected: true); + ClickResizeAndWait(dialog); + + AssertImageDimensions(source, 100, 50); + Assert.AreEqual( + originalModifiedTime, + File.GetLastWriteTimeUtc(source), + "Replacing the image changed its original modified timestamp."); + Assert.AreEqual(0, GetResizedCopies(new[] { source }).Count, "Replacing the image created an unexpected copy."); + } + + [TestMethod("ImageResizer.Resize.ShrinkOnly")] + [TestCategory("Image Resizer")] + public void ShrinkOnlyDoesNotEnlargeSmallerImage() + { + var largePreset = new ResizePreset("Large Target", ResizeFitMode.Fit, 800, 800, ResizeUnitMode.Pixel); + ConfigureResizeSettings(largePreset, shrinkOnly: true); + var source = CreateImageFixture("smaller.png", 400, 200); + + var dialog = OpenResizeDialog(source); + AssertDialogCheckBox(dialog, "Make pictures smaller but not larger", expected: true); + ClickResizeAndWait(dialog); + + var output = WaitForResizedCopies(new[] { source }, expectedCount: 1).Single(); + AssertImageDimensions(output, 400, 200); + } + + [TestMethod("ImageResizer.Resize.ReplaceOriginal")] + [TestCategory("Image Resizer")] + public void ReplacesOriginalImageWithoutCreatingCopy() + { + ConfigureResizeSettings(DefaultPreset, replace: true); + var source = CreateImageFixture("replace.png", 400, 200); + + var dialog = OpenResizeDialog(source); + AssertDialogCheckBox(dialog, "Overwrite files", expected: true); + ClickResizeAndWait(dialog); + + AssertImageDimensions(source, 100, 50); + Assert.AreEqual(0, GetResizedCopies(new[] { source }).Count, "Replacing the image created an unexpected copy."); + } + + [TestMethod("ImageResizer.Resize.Orientation")] + [TestCategory("Image Resizer")] + public void UncheckedIgnoreOrientationUsesUnswappedDimensions() + { + var portraitTarget = new ResizePreset("Portrait", ResizeFitMode.Stretch, 100, 200, ResizeUnitMode.Pixel); + + ConfigureResizeSettings(portraitTarget, ignoreOrientation: true); + var swappedSource = CreateImageFixture("orientation-ignored.png", 400, 200); + ResizeFiles(swappedSource); + var swappedOutput = WaitForResizedCopies(new[] { swappedSource }, expectedCount: 1).Single(); + AssertImageDimensions(swappedOutput, 200, 100); + + ConfigureResizeSettings(portraitTarget, ignoreOrientation: false); + var unswappedSource = CreateImageFixture("orientation-honored.png", 400, 200); + var dialog = OpenResizeDialog(unswappedSource); + AssertDialogCheckBox(dialog, "Ignore the orientation of pictures", expected: false); + ClickResizeAndWait(dialog); + + var unswappedOutput = WaitForResizedCopies(new[] { unswappedSource }, expectedCount: 1).Single(); + AssertImageDimensions(unswappedOutput, 100, 200); + } + + private static Session NavigateToImageResizerSettings() + { + var settings = Session.FromProcess( + "PowerToys.Settings", + PowerToysModule.PowerToysSettings, + timeoutMS: 15_000); + if (WaitForElementSearch(settings, By.AccessibilityId("AddSizeButton"), timeoutMS: 5_000)) + { + return settings; + } + + if (!WaitForElementSearch(settings, By.AccessibilityId("ImageResizerNavItem"), timeoutMS: 5_000)) + { + settings.Find<NavigationViewItem>(By.AccessibilityId("FileManagementNavItem")).Click(msPostAction: 500); + Assert.IsTrue( + WaitForElementSearch(settings, By.AccessibilityId("ImageResizerNavItem"), timeoutMS: 5_000), + "The File Management navigation group did not expose Image Resizer."); + } + + settings.Find<NavigationViewItem>(By.AccessibilityId("ImageResizerNavItem")).Click(msPostAction: 500); + Assert.IsTrue( + WaitForElementSearch(settings, By.AccessibilityId("AddSizeButton"), timeoutMS: 60_000), + "Image Resizer settings page did not become ready."); + return settings; + } + + private static bool WaitForElementSearch(Session session, By by, int timeoutMS) => + session.WaitFor( + () => session.Has(by, timeoutMS: 500), + timeoutMS: timeoutMS, + pollIntervalMS: 200); + + private static ToggleSwitch SetModuleEnabled(ToggleSwitch toggle, bool enabled) + { + for (var attempt = 1; attempt <= 2; attempt++) + { + try + { + toggle.Toggle(enabled); + Assert.IsTrue( + toggle.WaitForProperty("ToggleState", enabled ? "On" : "Off", timeoutMS: 5_000), + $"Image Resizer enable switch did not settle to {(enabled ? "On" : "Off")}."); + return toggle; + } + catch (TimeoutException) when (attempt < 2) + { + var settings = Session.FromProcess( + "PowerToys.Settings", + PowerToysModule.PowerToysSettings, + timeoutMS: 15_000); + toggle = settings.Find<ToggleSwitch>(By.Name("Image Resizer"), timeoutMS: 15_000); + } + } + + return toggle; + } + + private Session OpenResizeDialog(params string[] filePaths) + { + Assert.IsTrue(filePaths.Length > 0, "At least one image must be selected."); + var folderPath = Path.GetDirectoryName(filePaths[0])!; + Assert.IsTrue( + filePaths.All(path => string.Equals(Path.GetDirectoryName(path), folderPath, StringComparison.OrdinalIgnoreCase)), + "All selected images must be in the same folder."); + + var explorer = OpenExplorer(folderPath); + var menuDeadline = DateTime.UtcNow + TimeSpan.FromSeconds(90); + Session? menu = null; + Element? resizeMenuItem = null; + var selectionFailures = 0; + do + { + var selected = TrySelectFilesStable(explorer, filePaths, timeoutMS: 12_000); + if (selected is null) + { + // A view opened during the one-time shell restart can stay empty; reopen it. + if (++selectionFailures >= 2) + { + selectionFailures = 0; + explorer = OpenExplorer(folderPath); + } + + Thread.Sleep(300); + continue; + } + + selectionFailures = 0; + explorer = selected; + menu = OpenContextMenu(explorer); + if (menu is not null) + { + resizeMenuItem = FindVisibleMenuItem(menu, ContextMenuCaption, timeoutMS: 5_000); + if (resizeMenuItem is not null) + { + break; + } + } + + KeyboardHelper.SendKeys(Key.Esc); + Thread.Sleep(300); + } + while (DateTime.UtcNow < menuDeadline); + + Assert.IsNotNull(menu, "Explorer did not open the expected image-file context-menu surface."); + Assert.IsNotNull( + resizeMenuItem, + $"Explorer did not show the '{ContextMenuCaption}' command for the selected image(s)."); + resizeMenuItem!.Invoke(msPostAction: 300); + + var dialog = WindowsFinder.WaitForWindowByApp( + ImageResizerProcessName, + window => window.Width >= 400 && window.Height > 0, + timeoutMS: DialogTimeoutMS); + Assert.IsNotNull(dialog, "The Image Resizer window did not open after invoking its context-menu command."); + Assert.IsTrue( + dialog!.WaitForElement(By.AccessibilityId("SizeComboBox"), timeoutMS: 10_000), + "The Image Resizer input page did not become ready."); + Assert.IsTrue( + WindowControl.WaitForForeground(new IntPtr(dialog.WindowHandle), timeoutMS: 10_000, requiredConsecutiveMatches: 2), + $"The Image Resizer window did not become foreground. Current foreground: {WindowControl.GetForegroundWindowInfo()}."); + return dialog; + } + + private void ResizeFiles(params string[] filePaths) + { + var dialog = OpenResizeDialog(filePaths); + ClickResizeAndWait(dialog); + } + + private static void ClickResizeAndWait(Session dialog) + { + var resizeButton = FindExact<Button>(dialog, "Resize"); + Assert.IsNotNull(resizeButton, "The Image Resizer input page did not expose its Resize button."); + resizeButton!.Click(); + Assert.IsTrue( + WaitForProcess(ImageResizerProcessName, expected: false, timeoutMS: ResizeTimeoutMS), + $"{ImageResizerProcessName} did not exit after completing the resize operation."); + } + + private static void AssertDialogCheckBox(Session dialog, string name, bool expected) + { + var checkBox = FindExact<CheckBox>(dialog, name); + Assert.IsNotNull(checkBox, $"The Image Resizer window did not expose the '{name}' checkbox."); + Assert.AreEqual(expected, checkBox!.IsChecked, $"The '{name}' checkbox had the wrong state."); + } + + private void AssertContextMenuPresence( + Session explorer, + string[] filePaths, + bool expected) + { + var folder = Path.GetDirectoryName(filePaths[0])!; + var deadline = DateTime.UtcNow + TimeSpan.FromSeconds(90); + var lastObservation = new ContextMenuObservation(false, false); + var selectionFailures = 0; + + do + { + KeyboardHelper.SendKeys(Key.Esc); + + // On a slow agent Explorer can render its file view asynchronously after the module + // toggles (or open an empty view right after the one-time shell restart). Re-establish a + // stable selection before each attempt and reopen a fresh window if it keeps failing. + var selected = TrySelectFilesStable(explorer, filePaths, timeoutMS: 12_000); + if (selected is null) + { + TestContext.WriteLine( + $"Selection not established. folder='{folder}' exists={Directory.Exists(folder)} " + + $"files=[{(Directory.Exists(folder) ? string.Join(", ", Directory.GetFiles(folder).Select(Path.GetFileName)) : "<none>")}] " + + $"fixtureOnDisk={filePaths.All(File.Exists)} temp='{Path.GetTempPath()}'."); + if (++selectionFailures >= 2) + { + selectionFailures = 0; + explorer = OpenExplorer(folder); + } + + Thread.Sleep(300); + continue; + } + + selectionFailures = 0; + explorer = selected; + var menu = OpenContextMenu(explorer); + if (menu is null) + { + Thread.Sleep(300); + continue; + } + + var stableObservation = WaitHelper.WaitForStable( + observe: () => ObserveContextMenu(menu), + isMatch: observation => observation is not null && observation.IsOpen && observation.CommandPresent == expected, + timeoutMS: 8_000, + requiredConsecutiveMatches: 4, + pollIntervalMS: 250); + lastObservation = stableObservation.LastObservation ?? lastObservation; + KeyboardHelper.SendKeys(Key.Esc); + + if (stableObservation.Succeeded) + { + return; + } + + Thread.Sleep(300); + } + while (DateTime.UtcNow < deadline); + + var surface = UseModernContextMenu ? "modern" : "classic"; + Assert.IsTrue( + lastObservation.IsOpen, + $"The {surface} Explorer context menu did not become ready."); + Assert.AreEqual( + expected, + lastObservation.CommandPresent, + $"The {surface} Explorer context menu did {(expected ? "not show" : "show")} '{ContextMenuCaption}'."); + } + + private static Session? OpenContextMenu(Session explorer) + { + EnsureExplorerForeground(explorer); + KeyboardHelper.SendKeys(Key.Esc); + + // Windows 11 shows the modern (tier-1) surface directly; Windows 10 the classic one. The + // Image Resizer command is registered into whichever the OS shows, so no "Show more options" + // step (and no classic fallback on Windows 11) is needed. + var surfaceClass = IsWindows11OrNewer() ? ModernContextMenuClassName : ClassicContextMenuClassName; + if (!WindowControl.TryOpenContextMenuForFocusedControl(new IntPtr(explorer.WindowHandle))) + { + return null; + } + + return WaitForContextMenuSurface(surfaceClass, timeoutMS: 15_000); + } + + private static Session? WaitForContextMenuSurface( + string className, + int timeoutMS) => + WindowsFinder.WaitForWindow( + window => IsContextMenuClass(window.ClassName, className), + timeoutMS: timeoutMS, + pollIntervalMS: 100); + + private static bool IsContextMenuClass(string actualClassName, string expectedClassName) => + expectedClassName == ClassicContextMenuClassName + ? actualClassName.Equals(expectedClassName, StringComparison.OrdinalIgnoreCase) + : actualClassName.Contains(expectedClassName, StringComparison.OrdinalIgnoreCase); + + private static ContextMenuObservation ObserveContextMenu(Session menu) + { + var menuReady = menu.WindowHandle != 0 && + WindowsFinder.ListAll().Any(window => window.Hwnd == menu.WindowHandle); + if (!menuReady) + { + return new ContextMenuObservation(false, false); + } + + try + { + return new ContextMenuObservation(true, HasVisibleMenuItem(menu, ContextMenuCaption)); + } + catch (Exception) + { + // The transient menu popup can vanish mid-query (winappcli reports its HWND as gone); + // treat it as not-yet-stable so the caller reopens it. + return new ContextMenuObservation(false, false); + } + } + + private static bool HasVisibleMenuItem(Session menu, string name) => + FindVisibleMenuItem(menu, name, timeoutMS: 250) is not null; + + private static Element? FindVisibleMenuItem(Session menu, string name, int timeoutMS) + { + var deadline = DateTime.UtcNow + TimeSpan.FromMilliseconds(timeoutMS); + do + { + var item = menu.FindAll<Element>(By.Name(name), timeoutMS: 250) + .FirstOrDefault(element => + element.Name.Equals(name, StringComparison.OrdinalIgnoreCase) && + element.ControlType.Equals("MenuItem", StringComparison.OrdinalIgnoreCase) && + element.Displayed && + element.Width > 0 && + element.Height > 0); + if (item is not null) + { + return item; + } + + Thread.Sleep(100); + } + while (DateTime.UtcNow < deadline); + + return null; + } + + private Session OpenExplorer(string folderPath) + { + EnsureContextMenuHandlerLoaded(); + CloseExplorerFileWindows(); + var existingHandles = WindowsFinder.ListByApp(ExplorerProcessName) + .Where(IsExplorerFileWindow) + .Select(window => window.Hwnd) + .ToHashSet(); + + using var process = Process.Start(new ProcessStartInfo + { + FileName = "explorer.exe", + Arguments = $"/n,\"{folderPath}\"", + UseShellExecute = true, + }); + + var explorer = WindowsFinder.WaitForWindowByApp( + ExplorerProcessName, + window => IsExplorerFileWindow(window) && !existingHandles.Contains(window.Hwnd), + timeoutMS: ExplorerTimeoutMS); + Assert.IsNotNull(explorer, $"Explorer did not open '{folderPath}'."); + + explorerWindowHandle = explorer!.WindowHandle; + EnsureExplorerForeground(explorer); + return explorer; + } + + // Both context-menu handlers are registered at runtime when the module is enabled (the classic + // registry-COM handler always, plus the modern sparse-MSIX package on signed builds). An + // Explorer that was already running only surfaces them after the shell restarts, so do it once. + private static void EnsureContextMenuHandlerLoaded() + { + if (contextMenuExplorerRefreshed) + { + return; + } + + contextMenuExplorerRefreshed = true; + Thread.Sleep(3_000); + + var previousProcessIds = Process.GetProcessesByName(ExplorerProcessName) + .Select(process => + { + var id = process.Id; + process.Dispose(); + return id; + }) + .ToHashSet(); + + WindowControl.TryKillProcessByName(ExplorerProcessName); + + var deadline = DateTime.UtcNow + TimeSpan.FromSeconds(30); + while (DateTime.UtcNow < deadline) + { + var current = Process.GetProcessesByName(ExplorerProcessName); + var hasFreshShell = current.Any(process => !previousProcessIds.Contains(process.Id)); + foreach (var process in current) + { + process.Dispose(); + } + + if (hasFreshShell) + { + break; + } + + Thread.Sleep(500); + } + + Thread.Sleep(2_000); + } + + private static Session SelectFiles(Session explorer, params string[] filePaths) + { + var selection = ExplorerShell.SetSelectionAndWaitForStable( + new IntPtr(explorer.WindowHandle), + filePaths, + filePaths[0], + timeoutMS: ExplorerTimeoutMS, + requiredConsecutiveMatches: 4); + if (!selection.Succeeded) + { + var replacement = FindReplacementExplorer(explorer, Path.GetDirectoryName(filePaths[0])!); + if (replacement is not null) + { + explorer = replacement; + selection = ExplorerShell.SetSelectionAndWaitForStable( + new IntPtr(explorer.WindowHandle), + filePaths, + filePaths[0], + timeoutMS: ExplorerTimeoutMS, + requiredConsecutiveMatches: 4); + } + } + + var observedSelection = selection.LastObservation; + var selectedPaths = observedSelection is null ? "<none>" : string.Join(", ", observedSelection.SelectedPaths); + var normalizedPaths = filePaths + .Select(path => Path.TrimEndingDirectorySeparator(Path.GetFullPath(path))) + .ToHashSet(StringComparer.OrdinalIgnoreCase); + var exactTerminalSelection = observedSelection is not null && + observedSelection.SelectedPaths.SetEquals(normalizedPaths) && + string.Equals( + observedSelection.FocusedPath, + Path.TrimEndingDirectorySeparator(Path.GetFullPath(filePaths[0])), + StringComparison.OrdinalIgnoreCase) && + WindowControl.GetForegroundWindowHandle() == new IntPtr(explorer.WindowHandle); + + Assert.IsTrue( + selection.Succeeded || exactTerminalSelection, + $"Explorer selection did not settle. Last selected paths: [{selectedPaths}]. " + + $"Last focused path: '{observedSelection?.FocusedPath ?? "<none>"}'. " + + $"Expected Explorer HWND: {explorer.WindowHandle}. " + + $"Current foreground: {WindowControl.GetForegroundWindowInfo()}."); + return explorer; + } + + // Non-throwing selection used by the context-menu retry loop: re-establishes a stable selection + // (handling an Explorer window that was replaced mid-render) and returns the live session, or + // null if it could not settle within the timeout so the caller can retry. + private static Session? TrySelectFilesStable(Session explorer, string[] filePaths, int timeoutMS) + { + if (ExplorerShell.SetSelectionAndWaitForStable( + new IntPtr(explorer.WindowHandle), filePaths, filePaths[0], timeoutMS, requiredConsecutiveMatches: 4).Succeeded) + { + return explorer; + } + + var replacement = FindReplacementExplorer(explorer, Path.GetDirectoryName(filePaths[0])!); + if (replacement is not null && + ExplorerShell.SetSelectionAndWaitForStable( + new IntPtr(replacement.WindowHandle), filePaths, filePaths[0], timeoutMS, requiredConsecutiveMatches: 4).Succeeded) + { + return replacement; + } + + return null; + } + + private static Session? FindReplacementExplorer(Session explorer, string folderPath) + { + var folderName = Path.GetFileName(Path.TrimEndingDirectorySeparator(folderPath)); + var foregroundWindow = WindowControl.GetForegroundWindowHandle().ToInt64(); + var replacement = WindowsFinder.ListByApp(ExplorerProcessName) + .Where(IsExplorerFileWindow) + .Where(window => window.Hwnd != explorer.WindowHandle) + .Where(window => window.Title.Contains(folderName, StringComparison.OrdinalIgnoreCase)) + .OrderByDescending(window => window.Hwnd == foregroundWindow) + .FirstOrDefault(); + if (replacement is null) + { + return null; + } + + return WindowsFinder.WaitForWindow( + window => window.Hwnd == replacement.Hwnd, + timeoutMS: 2_000, + pollIntervalMS: 100); + } + + private static void EnsureExplorerForeground(Session explorer) + { + Assert.IsTrue( + WindowControl.WaitForForeground( + new IntPtr(explorer.WindowHandle), + ExplorerTimeoutMS, + requiredConsecutiveMatches: 3), + $"Explorer HWND {explorer.WindowHandle} was not the stable foreground window. Current foreground: {WindowControl.GetForegroundWindowInfo()}."); + } + + private string CreateTestFolder() + { + var folder = Path.Combine(Path.GetTempPath(), "PowerToys-ImageResizer-UITests", Guid.NewGuid().ToString("N")); + Directory.CreateDirectory(folder); + temporaryFolders.Add(folder); + return folder; + } + + private string CreateImageFixture(string fileName, int width, int height) + { + return CreateImageFixture(CreateTestFolder(), fileName, width, height); + } + + private static string CreateImageFixture(string folder, string fileName, int width, int height) + { + var path = Path.Combine(folder, fileName); + using var image = new Bitmap(width, height); + image.SetResolution(96, 96); + using (var graphics = Graphics.FromImage(image)) + { + graphics.Clear(Color.CornflowerBlue); + } + + var imageFormat = Path.GetExtension(fileName).Equals(".gif", StringComparison.OrdinalIgnoreCase) + ? System.Drawing.Imaging.ImageFormat.Gif + : System.Drawing.Imaging.ImageFormat.Png; + image.Save(path, imageFormat); + + // Confirm the fixture actually reached disk before Explorer is asked to show it; retry once + // to absorb a slow or locked temp on constrained agents. + if (!File.Exists(path)) + { + Thread.Sleep(500); + image.Save(path, imageFormat); + } + + Assert.IsTrue(File.Exists(path), $"Image fixture was not written to disk at '{path}' (temp='{Path.GetTempPath()}')."); + return path; + } + + private static string CreateStripedImageFixture(string folder, string fileName, int width, int height) + { + var path = Path.Combine(folder, fileName); + using var image = new Bitmap(width, height); + image.SetResolution(96, 96); + using (var graphics = Graphics.FromImage(image)) + { + graphics.Clear(Color.Green); + using var red = new SolidBrush(Color.Red); + using var blue = new SolidBrush(Color.Blue); + graphics.FillRectangle(red, 0, 0, width / 4, height); + graphics.FillRectangle(blue, width * 3 / 4, 0, width - (width * 3 / 4), height); + } + + image.Save(path, System.Drawing.Imaging.ImageFormat.Png); + return path; + } + + private static void AssertImageDimensions(string path, int expectedWidth, int expectedHeight) + { + using var image = Image.FromFile(path); + Assert.AreEqual(expectedWidth, image.Width, $"Unexpected width for '{path}'."); + Assert.AreEqual(expectedHeight, image.Height, $"Unexpected height for '{path}'."); + } + + private static void AssertPixelDominatedBy(string path, int x, int y, ColorChannel expectedChannel) + { + using var image = new Bitmap(path); + var pixel = image.GetPixel(x, y); + var expected = expectedChannel switch + { + ColorChannel.Red => pixel.R, + ColorChannel.Green => pixel.G, + ColorChannel.Blue => pixel.B, + _ => 0, + }; + var otherMaximum = expectedChannel switch + { + ColorChannel.Red => Math.Max(pixel.G, pixel.B), + ColorChannel.Green => Math.Max(pixel.R, pixel.B), + ColorChannel.Blue => Math.Max(pixel.R, pixel.G), + _ => byte.MaxValue, + }; + + Assert.IsTrue( + expected >= otherMaximum + 40, + $"Pixel ({x}, {y}) in '{path}' was {pixel}, not predominantly {expectedChannel}."); + } + + private static IReadOnlyList<string> WaitForResizedCopies(IReadOnlyCollection<string> sourcePaths, int expectedCount) + { + var deadline = DateTime.UtcNow + TimeSpan.FromSeconds(10); + IReadOnlyList<string> copies; + do + { + copies = GetResizedCopies(sourcePaths); + if (copies.Count == expectedCount) + { + return copies; + } + + Thread.Sleep(200); + } + while (DateTime.UtcNow < deadline); + + Assert.AreEqual(expectedCount, copies.Count, "The expected resized image copies were not created."); + return copies; + } + + private static IReadOnlyList<string> GetResizedCopies(IReadOnlyCollection<string> sourcePaths) + { + var sources = sourcePaths.Select(Path.GetFullPath).ToHashSet(StringComparer.OrdinalIgnoreCase); + var folder = Path.GetDirectoryName(sourcePaths.First())!; + return Directory.EnumerateFiles(folder) + .Select(Path.GetFullPath) + .Where(path => !sources.Contains(path)) + .OrderBy(path => path, StringComparer.OrdinalIgnoreCase) + .ToList(); + } + + private static bool WaitForProcess(string processName, bool expected, int timeoutMS) + { + var deadline = DateTime.UtcNow + TimeSpan.FromMilliseconds(timeoutMS); + while (DateTime.UtcNow < deadline) + { + var processes = Process.GetProcessesByName(processName); + var running = processes.Length > 0; + foreach (var process in processes) + { + process.Dispose(); + } + + if (running == expected) + { + return true; + } + + Thread.Sleep(250); + } + + return false; + } + + private static T? FindExact<T>(Session session, string name, int timeoutMS = 5_000) + where T : Element, new() + { + return session.FindAll<T>(By.Name(name), timeoutMS) + .FirstOrDefault(element => element.Name.Equals(name, StringComparison.OrdinalIgnoreCase)); + } + + private static void ConfigureResizeSettings( + ResizePreset preset, + bool shrinkOnly = false, + bool replace = false, + bool ignoreOrientation = true, + bool keepDateModified = false, + string fileNameFormat = "%1 (%2)") + { + ConfigureResizeSettings( + new[] { preset }, + shrinkOnly, + replace, + ignoreOrientation, + keepDateModified, + fileNameFormat); + } + + private static void ConfigureResizeSettings( + IReadOnlyList<ResizePreset> presets, + bool shrinkOnly = false, + bool replace = false, + bool ignoreOrientation = true, + bool keepDateModified = false, + string fileNameFormat = "%1 (%2)") + { + var sizes = new JsonArray(); + for (var index = 0; index < presets.Count; index++) + { + sizes.Add(CreatePresetNode(presets[index], index)); + } + + var properties = new JsonObject + { + ["imageresizer_selectedSizeIndex"] = WrappedValue(0), + ["imageresizer_shrinkOnly"] = WrappedValue(shrinkOnly), + ["imageresizer_replace"] = WrappedValue(replace), + ["imageresizer_ignoreOrientation"] = WrappedValue(ignoreOrientation), + ["imageresizer_removeMetadata"] = WrappedValue(false), + ["imageresizer_jpegQualityLevel"] = WrappedValue(90), + ["imageresizer_pngInterlaceOption"] = WrappedValue(0), + ["imageresizer_tiffCompressOption"] = WrappedValue(0), + ["imageresizer_fileName"] = WrappedValue(fileNameFormat), + ["imageresizer_sizes"] = new JsonObject { ["value"] = sizes }, + ["imageresizer_keepDateModified"] = WrappedValue(keepDateModified), + ["imageresizer_fallbackEncoder"] = WrappedValue("19e4a5aa-5662-4fc5-a0c0-1758028e1057"), + ["imageresizer_customSize"] = new JsonObject + { + ["value"] = CreatePresetNode( + new ResizePreset("custom", ResizeFitMode.Fit, 1024, 640, ResizeUnitMode.Pixel), + presets.Count), + }, + }; + var settings = new JsonObject + { + ["name"] = ImageResizerModuleName, + ["version"] = "1", + ["properties"] = properties, + }; + + Directory.CreateDirectory(Path.GetDirectoryName(ImageResizerSettingsPath)!); + File.WriteAllText(ImageResizerSettingsPath, settings.ToJsonString(IndentedJson)); + } + + private static JsonObject CreatePresetNode(ResizePreset preset, int id) => new() + { + ["Id"] = id, + ["name"] = preset.Name, + ["fit"] = (int)preset.Fit, + ["width"] = preset.Width, + ["height"] = preset.Height, + ["unit"] = (int)preset.Unit, + }; + + private static JsonObject WrappedValue<T>(T value) => new() + { + ["value"] = JsonValue.Create(value), + }; + + private static void TryRestoreSettingsFile(string path, bool existed, string? content) + { + try + { + if (existed) + { + Directory.CreateDirectory(Path.GetDirectoryName(path)!); + File.WriteAllText(path, content!); + } + else if (File.Exists(path)) + { + File.Delete(path); + } + } + catch (Exception ex) + { + Console.Error.WriteLine($"Could not restore Image Resizer settings file '{path}'. {ex.Message}"); + } + } + + private static bool IsWindows11OrNewer() => Environment.OSVersion.Version.Build >= 22_000; + + private static bool WaitForModernPackageRegistration(int timeoutMS) + { + if (!IsWindows11OrNewer()) + { + return true; + } + + return WaitHelper.WaitForStable( + observe: ModernPackageRegistered, + isMatch: registered => registered, + timeoutMS: timeoutMS, + requiredConsecutiveMatches: 2, + pollIntervalMS: 250).Succeeded; + } + + private static bool ModernPackageRegistered() + { + try + { + return new Windows.Management.Deployment.PackageManager() + .FindPackagesForUser(string.Empty) + .Any(package => package.Id.Name.Contains(ModernPackageName, StringComparison.OrdinalIgnoreCase)); + } + catch + { + return false; + } + } + + // Windows 11 shows the tier-1 (modern, sparse-MSIX) context menu; Windows 10 shows the classic + // (registry-COM) menu. CI signs the sparse package so the modern menu registers, so the test + // drives the real per-OS surface with no classic fallback on Windows 11. + private static bool UseModernContextMenu => IsWindows11OrNewer(); + + private static bool IsExplorerFileWindow(WindowsFinder.WindowInfo window) => + window.ClassName.Equals("CabinetWClass", StringComparison.OrdinalIgnoreCase); + + private static bool CloseExplorerFileWindows() => + WindowControl.TryCloseByApp(ExplorerProcessName, IsExplorerFileWindow, timeoutMS: 10_000); + + private static bool CloseImageResizerWindows() + { + if (WindowControl.TryCloseByApp(ImageResizerProcessName, timeoutMS: 5_000) && + WaitForProcess(ImageResizerProcessName, expected: false, timeoutMS: 1_000)) + { + return true; + } + + return WindowControl.TryKillProcessTreeByNameAndWait(ImageResizerProcessName, timeoutMS: 10_000); + } + + private static bool DeleteDirectoryWithRetry(string path) + { + for (var attempt = 0; attempt < 5; attempt++) + { + try + { + if (Directory.Exists(path)) + { + Directory.Delete(path, recursive: true); + } + + return true; + } + catch (IOException) + { + } + catch (UnauthorizedAccessException) + { + } + + if (attempt < 4) + { + Thread.Sleep(250); + } + } + + return !Directory.Exists(path); + } + + private sealed record ContextMenuObservation(bool IsOpen, bool CommandPresent); + + private sealed record ResizePreset( + string Name, + ResizeFitMode Fit, + double Width, + double Height, + ResizeUnitMode Unit); + + private enum ResizeFitMode + { + Fill, + Fit, + Stretch, + } + + private enum ResizeUnitMode + { + Centimeter, + Inch, + Percent, + Pixel, + } + + private enum ColorChannel + { + Red, + Green, + Blue, + } +} diff --git a/src/modules/imageresizer/tests/ImageResizer.UITests/app.manifest b/src/modules/imageresizer/tests/ImageResizer.UITests/app.manifest new file mode 100644 index 0000000000..c3b16cd304 --- /dev/null +++ b/src/modules/imageresizer/tests/ImageResizer.UITests/app.manifest @@ -0,0 +1,16 @@ +<?xml version="1.0" encoding="utf-8"?> +<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1"> + <assemblyIdentity version="1.0.0.0" name="ImageResizer.UITests.app" /> + + <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1"> + <application> + <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" /> + </application> + </compatibility> + + <application xmlns="urn:schemas-microsoft-com:asm.v3"> + <windowsSettings> + <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2</dpiAwareness> + </windowsSettings> + </application> +</assembly> \ No newline at end of file diff --git a/src/modules/imageresizer/tests/ImageResizer.UnitTests.csproj b/src/modules/imageresizer/tests/ImageResizer.UnitTests.csproj index e83fc93998..eeddc3e3bc 100644 --- a/src/modules/imageresizer/tests/ImageResizer.UnitTests.csproj +++ b/src/modules/imageresizer/tests/ImageResizer.UnitTests.csproj @@ -13,6 +13,7 @@ <AssemblyName>ImageResizer.Test</AssemblyName> <OutputPath>$(SolutionDir)$(Platform)\$(Configuration)\tests\$(AssemblyName)\</OutputPath> + <DefaultItemExcludes>$(DefaultItemExcludes);ImageResizer.UITests\**</DefaultItemExcludes> <AllowUnsafeBlocks>true</AllowUnsafeBlocks> </PropertyGroup> diff --git a/src/modules/peek/Peek.FilePreviewer/FilePreview.xaml b/src/modules/peek/Peek.FilePreviewer/FilePreview.xaml index e7f6db1652..f8769d8aac 100644 --- a/src/modules/peek/Peek.FilePreviewer/FilePreview.xaml +++ b/src/modules/peek/Peek.FilePreviewer/FilePreview.xaml @@ -14,9 +14,23 @@ <Grid> <ProgressRing + x:Name="LoadingIndicator" HorizontalAlignment="Center" VerticalAlignment="Center" - IsActive="{x:Bind MatchPreviewState(Previewer.State, previewers:PreviewState.Loading), Mode=OneWay}" /> + AutomationProperties.AutomationId="LoadingIndicator" + IsActive="{x:Bind MatchPreviewState(Previewer.State, previewers:PreviewState.Loading), Mode=OneWay}" + Visibility="{x:Bind IsLoadingIndicatorVisible(Previewer.State), Mode=OneWay}" /> + + <TextBlock + x:Name="PreviewStateAutomationPeer" + Width="1" + Height="1" + HorizontalAlignment="Left" + VerticalAlignment="Top" + AutomationProperties.AutomationId="PreviewStateAutomationPeer" + IsHitTestVisible="False" + Opacity="0" + Text="{x:Bind GetPreviewStateText(Previewer.State), Mode=OneWay}" /> <controls:ShellPreviewHandlerControl x:Name="ShellPreviewHandlerPreview" diff --git a/src/modules/peek/Peek.FilePreviewer/FilePreview.xaml.cs b/src/modules/peek/Peek.FilePreviewer/FilePreview.xaml.cs index 77364d1cc4..49feea7831 100644 --- a/src/modules/peek/Peek.FilePreviewer/FilePreview.xaml.cs +++ b/src/modules/peek/Peek.FilePreviewer/FilePreview.xaml.cs @@ -185,6 +185,16 @@ namespace Peek.FilePreviewer return value == stateToMatch; } + public Visibility IsLoadingIndicatorVisible(PreviewState? state) + { + return MatchPreviewState(state, PreviewState.Loading) ? Visibility.Visible : Visibility.Collapsed; + } + + public string GetPreviewStateText(PreviewState? state) + { + return (state ?? PreviewState.Uninitialized).ToString(); + } + public Visibility IsPreviewVisible(IPreviewer? previewer, PreviewState? state) { var isValidPreview = previewer != null && MatchPreviewState(state, PreviewState.Loaded); diff --git a/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_2_arm64.png b/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_2_arm64.png new file mode 100644 index 0000000000000000000000000000000000000000..e5a9a6bc56edfc411731784632ebb18a9b2b8a6c GIT binary patch literal 98192 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 R^q<{pVQT$*rLjls{{R8qDINd- literal 0 HcmV?d00001 diff --git a/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_2_x64Win10.png b/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_2_x64Win10.png new file mode 100644 index 0000000000000000000000000000000000000000..f6a97a8c35aea89567b90eed13dd7e03dded2230 GIT binary patch literal 101012 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 literal 0 HcmV?d00001 diff --git a/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_2_x64Win11.png b/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_2_x64Win11.png new file mode 100644 index 0000000000000000000000000000000000000000..a59986a075f3863180b328ffdf91ddd8c45c0a7d GIT binary patch literal 102410 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 literal 0 HcmV?d00001 diff --git a/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_4_arm64.png b/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_4_arm64.png new file mode 100644 index 0000000000000000000000000000000000000000..4bc50db2323ea9e3d99fe8156a1070ba003a9b05 GIT binary patch literal 21586 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 Jb57gb`ZwHLmnQ%K literal 0 HcmV?d00001 diff --git a/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_4_x64Win10.png b/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_4_x64Win10.png new file mode 100644 index 0000000000000000000000000000000000000000..19f470e40036f459e621532d4eae2071c4f9a5bc GIT binary patch literal 19469 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 DWxX#> literal 0 HcmV?d00001 diff --git a/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_4_x64Win11.png b/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_4_x64Win11.png new file mode 100644 index 0000000000000000000000000000000000000000..83f2d6ae33efeef5cc481b129373307b43932058 GIT binary patch literal 20826 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 literal 0 HcmV?d00001 diff --git a/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_5_arm64.png b/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_5_arm64.png new file mode 100644 index 0000000000000000000000000000000000000000..9fa92f1ba69ee489aa31d6d71f24e7a70282b801 GIT binary patch literal 18727 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 literal 0 HcmV?d00001 diff --git a/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_5_x64Win10.png b/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_5_x64Win10.png new file mode 100644 index 0000000000000000000000000000000000000000..3343f2195d1ed77bf0c22eb568253cd6626ca4c0 GIT binary patch literal 15641 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 literal 0 HcmV?d00001 diff --git a/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_5_x64Win11.png b/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_5_x64Win11.png new file mode 100644 index 0000000000000000000000000000000000000000..0878eb24cbf2f58d16f2a5b07fdb6645e04d36f8 GIT binary patch literal 19150 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%0A?fWs{aA2Bj&eI3q^DC(f9u!s)a9A+h3w31x3YO( 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 literal 0 HcmV?d00001 diff --git a/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_6_arm64.png b/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_6_arm64.png new file mode 100644 index 0000000000000000000000000000000000000000..edd054d20693c9c20d3ca787ecd38ff57d2b9506 GIT binary patch literal 24884 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 literal 0 HcmV?d00001 diff --git a/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_6_x64Win10.png b/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_6_x64Win10.png new file mode 100644 index 0000000000000000000000000000000000000000..c5154374c95f52b500641a89104dd6e54037da3e GIT binary patch literal 20573 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 E1NLFV_5c6? literal 0 HcmV?d00001 diff --git a/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_6_x64Win11.png b/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_6_x64Win11.png new file mode 100644 index 0000000000000000000000000000000000000000..9d6b102cce0510d5d1b587cf0c805ba07116c9c2 GIT binary patch literal 24017 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 Ng&f-368z=qe*^A24A=kw literal 0 HcmV?d00001 diff --git a/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_7_arm64.png b/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_7_arm64.png new file mode 100644 index 0000000000000000000000000000000000000000..977a4036afe7551969c685d2a3a921fd5de4ca3b GIT binary patch literal 33297 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%0DItg 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 literal 0 HcmV?d00001 diff --git a/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_7_x64Win10.png b/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_7_x64Win10.png new file mode 100644 index 0000000000000000000000000000000000000000..0cd49bf36e206d6f09a27663ad4e9f829b9270c6 GIT binary patch literal 24946 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 literal 0 HcmV?d00001 diff --git a/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_7_x64Win11.png b/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_7_x64Win11.png new file mode 100644 index 0000000000000000000000000000000000000000..cf8c9723823e63e2b47896d8d4804818ae56ddd0 GIT binary patch literal 31424 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 Fe*uFKw*deE literal 0 HcmV?d00001 diff --git a/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_8_arm64.png b/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_8_arm64.png new file mode 100644 index 0000000000000000000000000000000000000000..9f308b7e26e2b68b5e24a0b3a56f673e93ebf580 GIT binary patch literal 14077 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 literal 0 HcmV?d00001 diff --git a/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_8_x64Win10.png b/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_8_x64Win10.png new file mode 100644 index 0000000000000000000000000000000000000000..e5fff0dcf66b90255d799de471577cd69ad06b71 GIT binary patch literal 12274 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 literal 0 HcmV?d00001 diff --git a/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_8_x64Win11.png b/src/modules/peek/Peek.UITests.Next/Baseline/PeekFilePreviewTests_TestSingleFilePreview_8_x64Win11.png new file mode 100644 index 0000000000000000000000000000000000000000..b5892351ef0d1ee2bfbb2f9c8e2456906d8daec4 GIT binary patch literal 13364 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 literal 0 HcmV?d00001 diff --git a/src/modules/peek/Peek.UITests.Next/Peek.UITests.Next.csproj b/src/modules/peek/Peek.UITests.Next/Peek.UITests.Next.csproj new file mode 100644 index 0000000000..c3a0e09605 --- /dev/null +++ b/src/modules/peek/Peek.UITests.Next/Peek.UITests.Next.csproj @@ -0,0 +1,40 @@ +<Project Sdk="Microsoft.NET.Sdk"> + <Import Project="$(RepoRoot)src\Common.Dotnet.CsWinRT.props" /> + + <PropertyGroup> + <OutputType>Exe</OutputType> + <TargetFramework>net10.0-windows10.0.26100.0</TargetFramework> + <ImplicitUsings>enable</ImplicitUsings> + <Nullable>enable</Nullable> + <IsPackable>false</IsPackable> + <TreatWarningsAsErrors>false</TreatWarningsAsErrors> + <RootNamespace>Peek.UITests</RootNamespace> + <AssemblyName>Peek.UITests.Next</AssemblyName> + <ApplicationManifest>app.manifest</ApplicationManifest> + <IsTestingPlatformApplication>true</IsTestingPlatformApplication> + <EnableMSTestRunner>true</EnableMSTestRunner> + <GenerateDocumentationFile>false</GenerateDocumentationFile> + <RunVSTest>false</RunVSTest> + </PropertyGroup> + + <PropertyGroup> + <OutputPath>$(RepoRoot)$(Platform)\$(Configuration)\tests\Peek.UITests.Next\</OutputPath> + </PropertyGroup> + + <ItemGroup> + <PackageReference Include="MSTest" /> + <!-- ProjectReference does not copy this runtime dependency from UITestAutomation.Next. --> + <PackageReference Include="CoenM.ImageSharp.ImageHash" /> + </ItemGroup> + + <ItemGroup> + <ProjectReference Include="..\..\..\common\UITestAutomation.Next\UITestAutomation.Next.csproj" /> + </ItemGroup> + + <ItemGroup> + <EmbeddedResource Include="Baseline\*.png" /> + <Content Include="TestAssets\**\*"> + <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory> + </Content> + </ItemGroup> +</Project> \ No newline at end of file diff --git a/src/modules/peek/Peek.UITests.Next/PeekFilePreviewTests.cs b/src/modules/peek/Peek.UITests.Next/PeekFilePreviewTests.cs new file mode 100644 index 0000000000..3bddb06b1f --- /dev/null +++ b/src/modules/peek/Peek.UITests.Next/PeekFilePreviewTests.cs @@ -0,0 +1,998 @@ +// Copyright (c) Microsoft Corporation +// The Microsoft Corporation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Diagnostics; +using System.Text; +using System.Text.Json.Nodes; +using Microsoft.PowerToys.UITest.Next; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Microsoft.Win32; + +namespace Peek.UITests; + +[TestClass] +public class PeekFilePreviewTests : UITestBase +{ + private const string PeekProcessName = "PowerToys.Peek.UI"; + private const string PersonalizeRegistryPath = @"Software\Microsoft\Windows\CurrentVersion\Themes\Personalize"; + private const string AppsUseLightThemeValueName = "AppsUseLightTheme"; + private const int ExplorerOpenTimeoutMS = 30_000; + private const int ExplorerOpenAttempts = 3; + private const int ExplorerSelectionStableSamples = 4; + private const int PeekWindowTimeoutMS = 30_000; + private const int PreviewLoadTimeoutMS = 60_000; + private const int PreviewOpenAttempts = 3; + private const int MaxHotkeyAttempts = 3; + private const int MaxNavigationAttempts = 3; + private static readonly IDisposable PeekSettings; + + private long explorerWindowHandle; + private IReadOnlyList<string> expectedExplorerSelection = Array.Empty<string>(); + private string? expectedExplorerFocusedPath; + + private static bool appsUseLightThemeValueExisted; + private static object? originalAppsUseLightThemeValue; + private static RegistryValueKind originalAppsUseLightThemeValueKind; + private static bool restoreAppsUseLightTheme; + + public PeekFilePreviewTests() + : base(PowerToysModule.PowerToysSettings, WindowSize.Small_Vertical, enableModules: new[] { "Peek" }) + { + } + + static PeekFilePreviewTests() + { + PeekSettings = SettingsConfigHelper.PreserveModuleSettings("Peek"); + try + { + ForcePipelineLightTheme(); + + SettingsConfigHelper.UpdateModuleSettings( + "Peek", + """ + { + "name": "Peek", + "version": "1.0", + "properties": {} + } + """, + settings => + { + var properties = settings["properties"] as JsonObject ?? new JsonObject(); + properties["ActivationShortcut"] = new JsonObject + { + ["win"] = false, + ["ctrl"] = true, + ["alt"] = false, + ["shift"] = false, + ["code"] = 32, + ["key"] = "Space", + }; + properties["AlwaysRunNotElevated"] = new JsonObject { ["value"] = true }; + properties["CloseAfterLosingFocus"] = new JsonObject { ["value"] = false }; + properties["ConfirmFileDelete"] = new JsonObject { ["value"] = true }; + properties["EnableSpaceToActivate"] = new JsonObject { ["value"] = false }; + settings["properties"] = properties; + }); + } + catch + { + PeekSettings.Dispose(); + throw; + } + } + + [ClassCleanup] + public static void RestoreClassState() + { + try + { + if (!restoreAppsUseLightTheme) + { + return; + } + + try + { + using var key = Registry.CurrentUser.CreateSubKey(PersonalizeRegistryPath); + if (appsUseLightThemeValueExisted) + { + key.SetValue(AppsUseLightThemeValueName, originalAppsUseLightThemeValue!, originalAppsUseLightThemeValueKind); + } + else + { + key.DeleteValue(AppsUseLightThemeValueName, throwOnMissingValue: false); + } + } + catch + { + } + } + finally + { + PeekSettings.Dispose(); + } + } + + protected override IReadOnlyList<string> StaleProcessNames { get; } = new[] + { + "PowerToys", + "PowerToys.Settings", + "PowerToys.FancyZonesEditor", + PeekProcessName, + }; + + [TestInitialize] + public void PreparePeekTest() + { + CloseTestWindows(); + WindowControl.TryCloseByApp("PowerToys.Settings"); + } + + [TestCleanup] + public async Task CleanupPeekTest() + { + await CaptureFailureArtifactsBeforeCleanupAsync(TimeSpan.FromSeconds(2)); + CloseTestWindows(); + } + + [TestMethod("Peek.FilePreview.Folder")] + [TestCategory("Preview files")] + public void PeekFolderFilePreview() + { + var folderPath = Path.GetFullPath(@".\TestAssets"); + var peekWindow = OpenPeekWindow(folderPath); + + peekWindow.Find<TextBlock>(By.Name("File Type: File folder"), 5_000); + } + + [TestMethod("Peek.FilePreview.JPEGImage")] + [TestCategory("Preview files")] + public void PeekJPEGImagePreview() + { + TestSingleFilePreview(Path.GetFullPath(@".\TestAssets\2.jpg"), "2"); + } + + [TestMethod("Peek.FilePreview.QOIImage")] + [TestCategory("Preview files")] + public void PeekQOIImagePreview() + { + TestSingleFilePreview(Path.GetFullPath(@".\TestAssets\4.qoi"), "4"); + } + + [TestMethod("Peek.FilePreview.CPPSourceCode")] + [TestCategory("Preview files")] + public void PeekCPPSourceCodePreview() + { + TestSingleFilePreview(Path.GetFullPath(@".\TestAssets\5.cpp"), "5"); + } + + [TestMethod("Peek.FilePreview.MarkdownDocument")] + [TestCategory("Preview files")] + public void PeekMarkdownDocumentPreview() + { + TestSingleFilePreview(Path.GetFullPath(@".\TestAssets\6.md"), "6"); + } + + [TestMethod("Peek.FilePreview.ZIPArchive")] + [TestCategory("Preview files")] + public void PeekZIPArchivePreview() + { + TestSingleFilePreview(Path.GetFullPath(@".\TestAssets\7.zip"), "7"); + } + + [TestMethod("Peek.FilePreview.PNGImage")] + [TestCategory("Preview files")] + public void PeekPNGImagePreview() + { + TestSingleFilePreview(Path.GetFullPath(@".\TestAssets\8.png"), "8"); + } + + [TestMethod("Peek.WindowPinning.PinAndSwitchImages")] + [TestCategory("Window Pinning")] + public void TestPinWindowAndSwitchImages() + { + var firstImagePath = Path.GetFullPath(@".\TestAssets\8.png"); + var secondImagePath = Path.GetFullPath(@".\TestAssets\2.jpg"); + var initialWindow = OpenPeekWindow(firstImagePath); + var movedBounds = MoveWindowBy(initialWindow, 100, 50); + + ClickPinButton(initialWindow); + CloseTestWindows(); + + var secondWindow = OpenPeekWindow(secondImagePath); + AssertBoundsEqual(movedBounds, GetWindowBounds(secondWindow), "when switching images while pinned"); + } + + [TestMethod("Peek.WindowPinning.PinAndReopen")] + [TestCategory("Window Pinning")] + public void TestPinWindowAndReopen() + { + var imagePath = Path.GetFullPath(@".\TestAssets\8.png"); + var initialWindow = OpenPeekWindow(imagePath); + var movedBounds = MoveWindowBy(initialWindow, 150, 75); + + ClickPinButton(initialWindow); + CloseTestWindows(); + + var reopenedWindow = OpenPeekWindow(imagePath); + AssertBoundsEqual(movedBounds, GetWindowBounds(reopenedWindow), "after reopening while pinned"); + } + + [TestMethod("Peek.WindowPinning.UnpinAndSwitchFiles")] + [TestCategory("Window Pinning")] + public void TestUnpinWindowAndSwitchFiles() + { + var firstFilePath = Path.GetFullPath(@".\TestAssets\8.png"); + var secondFilePath = Path.GetFullPath(@".\TestAssets\2.jpg"); + var pinnedWindow = OpenPeekWindow(firstFilePath); + var movedBounds = MoveWindowBy(pinnedWindow, 200, 100); + var movedCenter = movedBounds.Center; + + ClickPinButton(pinnedWindow); + ClickPinButton(pinnedWindow); + CloseTestWindows(preservePeekProcess: false); + + var unpinnedWindow = OpenPeekWindow(secondFilePath); + var unpinnedBounds = GetWindowBounds(unpinnedWindow); + var unpinnedCenter = unpinnedBounds.Center; + + var sizeChanged = Math.Abs(movedBounds.Width - unpinnedBounds.Width) > 10 || + Math.Abs(movedBounds.Height - unpinnedBounds.Height) > 10; + var centerChanged = Math.Abs(movedCenter.X - unpinnedCenter.X) > 50 || + Math.Abs(movedCenter.Y - unpinnedCenter.Y) > 50; + + Assert.IsTrue(sizeChanged, "Window size should be different for different file types."); + Assert.IsTrue(centerChanged, "Window center should move to its default position when unpinned."); + } + + [TestMethod("Peek.WindowPinning.UnpinAndReopen")] + [TestCategory("Window Pinning")] + public void TestUnpinWindowAndReopen() + { + var imagePath = Path.GetFullPath(@".\TestAssets\8.png"); + var initialWindow = OpenPeekWindow(imagePath); + var movedBounds = MoveWindowBy(initialWindow, 250, 125); + + ClickPinButton(initialWindow); + ClickPinButton(initialWindow); + CloseTestWindows(preservePeekProcess: false); + + var reopenedWindow = OpenPeekWindow(imagePath); + var reopenedBounds = GetWindowBounds(reopenedWindow); + var openedAtDefault = Math.Abs(movedBounds.Left - reopenedBounds.Left) > 50 || + Math.Abs(movedBounds.Top - reopenedBounds.Top) > 50; + + Assert.IsTrue(openedAtDefault, "Unpinned window should open at its default position."); + } + + [TestMethod("Peek.OpenWithDefaultProgram.ClickButton")] + [TestCategory("Open with default program")] + public void TestOpenWithDefaultProgramByButton() + { + var zipPath = Path.GetFullPath(@".\TestAssets\7.zip"); + var peekWindow = OpenPeekWindow(zipPath); + + peekWindow.Find<Button>(By.AccessibilityId("LaunchAppButton"), 5_000).Invoke(); + + Assert.IsTrue( + WaitForExplorerTitle(Path.GetFileNameWithoutExtension(zipPath), 10_000), + "The default program did not open the ZIP archive after clicking the launch button."); + } + + [TestMethod("Peek.OpenWithDefaultProgram.PressEnter")] + [TestCategory("Open with default program")] + public void TestOpenWithDefaultProgramByEnter() + { + var zipPath = Path.GetFullPath(@".\TestAssets\7.zip"); + var peekWindow = OpenPeekWindow(zipPath); + + peekWindow.Find<Button>(By.AccessibilityId("LaunchAppButton"), 5_000).Focus(); + KeyboardHelper.SendKeys(Key.Enter); + + Assert.IsTrue( + WaitForExplorerTitle(Path.GetFileNameWithoutExtension(zipPath), 10_000), + "The default program did not open the ZIP archive after pressing Enter."); + } + + [TestMethod("Peek.FileNavigation.SwitchFilesWithArrowKeys")] + [TestCategory("File Navigation")] + public void TestSwitchFilesWithArrowKeys() + { + var testFiles = GetTestAssetFiles(); + var peekWindow = OpenPeekWindow(testFiles[0]); + + for (var index = 1; index < testFiles.Count; index++) + { + peekWindow = NavigateToFileWithRetry(peekWindow, Key.Right, testFiles[index]); + } + + for (var index = testFiles.Count - 2; index >= 0; index--) + { + peekWindow = NavigateToFileWithRetry(peekWindow, Key.Left, testFiles[index]); + } + } + + [TestMethod("Peek.FileNavigation.SwitchBetweenSelectedFiles")] + [TestCategory("File Navigation")] + public void TestSwitchBetweenSelectedFiles() + { + var selectedFiles = GetTestAssetFiles().Take(3).ToList(); + var explorerWindow = OpenExplorerAndSelect(selectedFiles[0]); + SetExplorerSelection(explorerWindow, selectedFiles, selectedFiles[^1]); + + var peekWindow = SendPeekHotkeyWithRetry(selectedFiles[2]); + EnsurePeekWindowInteractive(peekWindow); + var expectedNames = selectedFiles.Select(Path.GetFileNameWithoutExtension).ToHashSet(StringComparer.OrdinalIgnoreCase); + var visitedNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase) + { + FileNameFromTitle(peekWindow.WindowTitle, expectedNames), + }; + + const int maxAttempts = 10; + for (var attempt = 1; attempt <= maxAttempts && visitedNames.Count < expectedNames.Count; attempt++) + { + var previousTitle = peekWindow.WindowTitle; + EnsurePeekWindowInteractive(peekWindow); + EnsurePeekWindowForeground(peekWindow); + KeyboardHelper.SendKeys(Key.Left); + var changedWindow = WaitForSelectedFileChange(previousTitle, expectedNames, timeoutMS: 2_000); + if (changedWindow is null) + { + TestContext.WriteLine( + $"Selected-file navigation attempt {attempt}/{maxAttempts} made no progress from '{previousTitle}'. Retrying."); + continue; + } + + peekWindow = changedWindow; + visitedNames.Add(FileNameFromTitle(peekWindow.WindowTitle, expectedNames)); + } + + CollectionAssert.AreEquivalent( + expectedNames.ToList(), + visitedNames.ToList(), + $"Peek should visit every selected file and no unselected files. Visited: {string.Join(", ", visitedNames)}."); + } + + private Session OpenPeekWindow(string filePath) + { + OpenExplorerAndSelect(filePath); + + for (var attempt = 1; attempt <= PreviewOpenAttempts; attempt++) + { + try + { + var peekWindow = SendPeekHotkeyWithRetry(filePath); + EnsurePeekReady(peekWindow); + return peekWindow; + } + catch (AssertFailedException ex) when (attempt < PreviewOpenAttempts) + { + TestContext.WriteLine( + $"Peek activation/readiness attempt {attempt}/{PreviewOpenAttempts} failed for " + + $"'{Path.GetFileName(filePath)}': {ex.Message}. Restarting Peek before retrying activation."); + WindowControl.TryCloseByApp(PeekProcessName, timeoutMS: 10_000); + Assert.IsTrue(StopPeekProcess(), "Peek did not stop before the next activation attempt."); + } + } + + Assert.Fail($"Peek did not become ready for '{Path.GetFileName(filePath)}'."); + return null!; + } + + private Session OpenExplorerAndSelect(string filePath) + { + Assert.IsTrue(File.Exists(filePath) || Directory.Exists(filePath), $"Test asset does not exist: {filePath}"); + + var normalizedPath = filePath.TrimEnd(Path.DirectorySeparatorChar); + var selectedItemName = Path.GetFileName(normalizedPath); + TestContext.WriteLine(GetActivationDiagnostics($"Opening Explorer for '{normalizedPath}'")); + + for (var attempt = 1; attempt <= ExplorerOpenAttempts; attempt++) + { + CloseExplorerFileWindows(); + + var existingHandles = WindowsFinder.ListByApp("explorer") + .Where(IsExplorerFileWindow) + .Select(window => window.Hwnd) + .ToHashSet(); + + using var launchProcess = Process.Start(new ProcessStartInfo + { + FileName = "explorer.exe", + Arguments = $"/n,/select,\"{normalizedPath}\"", + UseShellExecute = true, + }); + TestContext.WriteLine( + $"Explorer launch attempt {attempt}/{ExplorerOpenAttempts}: " + + $"launcherPid={launchProcess?.Id.ToString() ?? "unknown"}, existingHwnds=[{string.Join(", ", existingHandles)}]."); + + var explorerWindow = WindowsFinder.WaitForWindowByApp( + "explorer", + window => IsExplorerFileWindow(window) && !existingHandles.Contains(window.Hwnd), + ExplorerOpenTimeoutMS); + + if (explorerWindow is null) + { + TestContext.WriteLine(GetActivationDiagnostics($"No fresh Explorer HWND after launch attempt {attempt}")); + continue; + } + + var expectedExplorerTitle = Path.GetFileName(Path.GetDirectoryName(normalizedPath)); + if (!WaitForExplorerWindowTitle(explorerWindow.WindowHandle, expectedExplorerTitle, ExplorerOpenTimeoutMS)) + { + TestContext.WriteLine( + GetActivationDiagnostics( + $"Explorer HWND {explorerWindow.WindowHandle} did not navigate to '{expectedExplorerTitle}' after launch attempt {attempt}")); + continue; + } + + if (!SetAndWaitForExplorerSelection( + explorerWindow.WindowHandle, + [normalizedPath], + normalizedPath, + ExplorerOpenTimeoutMS)) + { + TestContext.WriteLine( + GetActivationDiagnostics( + $"Explorer HWND {explorerWindow.WindowHandle} did not become foreground with a stable '{selectedItemName}' selection after launch attempt {attempt}")); + continue; + } + + explorerWindowHandle = explorerWindow.WindowHandle; + expectedExplorerSelection = [normalizedPath]; + expectedExplorerFocusedPath = normalizedPath; + TestContext.WriteLine( + $"Explorer ready for '{selectedItemName}': hwnd={explorerWindow.WindowHandle}, " + + $"pid={explorerWindow.ProcessId}, title='{explorerWindow.WindowTitle}', " + + $"session={GetProcessSessionId(explorerWindow.ProcessId)}, elevated={FormatElevation(explorerWindow.IsElevated)}."); + return explorerWindow; + } + + Assert.Fail( + $"Explorer did not open for {selectedItemName} after {ExplorerOpenAttempts} launch attempts." + + Environment.NewLine + GetActivationDiagnostics("Explorer launch failed")); + return null!; + } + + private static bool WaitForExplorerWindowTitle(long windowHandle, string expectedTitle, int timeoutMS) + { + var deadline = DateTime.UtcNow + TimeSpan.FromMilliseconds(timeoutMS); + + while (DateTime.UtcNow < deadline) + { + var window = WindowControl.EnumerateAllWindows() + .FirstOrDefault(candidate => candidate.Hwnd.ToInt64() == windowHandle); + if (window.Hwnd != IntPtr.Zero && + window.Title.Contains(expectedTitle, StringComparison.OrdinalIgnoreCase)) + { + return true; + } + + Thread.Sleep(250); + } + + return false; + } + + private void SetExplorerSelection( + Session explorerWindow, + IReadOnlyList<string> selectedPaths, + string focusedPath) + { + var normalizedPaths = selectedPaths.Select(NormalizePath).ToList(); + var normalizedFocusedPath = NormalizePath(focusedPath); + + Assert.IsTrue( + SetAndWaitForExplorerSelection( + explorerWindow.WindowHandle, + normalizedPaths, + normalizedFocusedPath, + ExplorerOpenTimeoutMS), + $"Explorer did not establish the expected selection [{string.Join(", ", normalizedPaths.Select(Path.GetFileName))}] " + + $"with '{Path.GetFileName(normalizedFocusedPath)}' focused."); + + explorerWindowHandle = explorerWindow.WindowHandle; + expectedExplorerSelection = normalizedPaths; + expectedExplorerFocusedPath = normalizedFocusedPath; + } + + private static bool SetAndWaitForExplorerSelection( + long windowHandle, + IReadOnlyList<string> selectedPaths, + string focusedPath, + int timeoutMS) + { + return ExplorerShell.SetSelectionAndWaitForStable( + new IntPtr(windowHandle), + selectedPaths, + focusedPath, + timeoutMS, + ExplorerSelectionStableSamples).Succeeded; + } + + private static string NormalizePath(string path) + { + return Path.GetFullPath(path.TrimEnd(Path.DirectorySeparatorChar)); + } + + private Session SendPeekHotkeyWithRetry(string expectedPath) + { + for (var attempt = 1; attempt <= MaxHotkeyAttempts; attempt++) + { + var visiblePeekWindow = WindowsFinder.ListByApp(PeekProcessName).FirstOrDefault(); + if (visiblePeekWindow is not null) + { + return WaitForInitializedPeekWindow( + expectedPath, + visiblePeekWindow.Hwnd, + visiblePeekWindow.ProcessId, + visiblePeekWindow.Title, + ElevationHelper.IsProcessElevated(visiblePeekWindow.ProcessId), + attempt); + } + + Assert.IsFalse( + expectedExplorerSelection.Count == 0 || string.IsNullOrEmpty(expectedExplorerFocusedPath), + "Explorer selection expectations were not initialized before Peek activation."); + var explorerReady = explorerWindowHandle != 0 && + SetAndWaitForExplorerSelection( + explorerWindowHandle, + expectedExplorerSelection, + expectedExplorerFocusedPath!, + ExplorerOpenTimeoutMS); + Assert.IsTrue( + explorerReady, + $"Explorer did not become foreground with the expected stable selection before Peek hotkey attempt {attempt}."); + + TestContext.WriteLine( + $"Peek hotkey attempt {attempt}/{MaxHotkeyAttempts} for '{Path.GetFileName(expectedPath)}': " + + $"explorerHwnd={explorerWindowHandle}, explorerReady={explorerReady}, " + + $"foregroundHwnd={WindowControl.GetForegroundWindowHandle().ToInt64()}."); + KeyboardHelper.SendKeys(Key.Ctrl, Key.Space); + var appearedWindow = WindowsFinder.WaitForWindowByApp( + PeekProcessName, + _ => true, + PeekWindowTimeoutMS); + if (appearedWindow is not null) + { + return WaitForInitializedPeekWindow( + expectedPath, + appearedWindow.WindowHandle, + appearedWindow.ProcessId, + appearedWindow.WindowTitle, + appearedWindow.IsElevated, + attempt); + } + + TestContext.WriteLine(GetActivationDiagnostics($"No matching Peek window after hotkey attempt {attempt}")); + } + + Assert.Fail( + $"Peek did not open {Path.GetFileName(expectedPath)} after {MaxHotkeyAttempts} hotkey attempts." + + Environment.NewLine + GetActivationDiagnostics("Peek activation failed")); + return null!; + } + + private Session WaitForInitializedPeekWindow( + string expectedPath, + long windowHandle, + int processId, + string initialTitle, + bool? isElevated, + int hotkeyAttempt) + { + TestContext.WriteLine( + $"Peek window appeared after hotkey attempt {hotkeyAttempt}: hwnd={windowHandle}, " + + $"pid={processId}, initialTitle='{initialTitle}', " + + $"session={GetProcessSessionId(processId)}, elevated={FormatElevation(isElevated)}. " + + $"Waiting for expected title without resending the hotkey."); + + EnsurePeekWindowForeground(windowHandle); + var initializedWindow = WaitForPeekWindow(expectedPath, PeekWindowTimeoutMS); + if (initializedWindow is not null) + { + EnsurePeekWindowForeground(initializedWindow); + TestContext.WriteLine( + $"Peek initialized after hotkey attempt {hotkeyAttempt}: hwnd={initializedWindow.WindowHandle}, " + + $"pid={initializedWindow.ProcessId}, title='{initializedWindow.WindowTitle}', " + + $"session={GetProcessSessionId(initializedWindow.ProcessId)}, elevated={FormatElevation(initializedWindow.IsElevated)}."); + return initializedWindow; + } + + Assert.Fail( + $"Peek window appeared after hotkey attempt {hotkeyAttempt}, but did not initialize for " + + $"{Path.GetFileName(expectedPath)} within {PeekWindowTimeoutMS / 1_000}s." + + Environment.NewLine + GetActivationDiagnostics("Peek window initialization failed")); + return null!; + } + + private string GetActivationDiagnostics(string stage) + { + var output = new StringBuilder(); + using var testHost = Process.GetCurrentProcess(); + var foreground = WindowControl.GetForegroundWindowInfo(); + output.AppendLine($"[{DateTime.UtcNow:O}] {stage}"); + output.AppendLine( + $"Test host: pid={testHost.Id}, session={GetProcessSessionId(testHost.Id)}, " + + $"elevated={ElevationHelper.IsCurrentProcessElevated()}."); + output.AppendLine( + $"Foreground: hwnd={foreground.Hwnd.ToInt64()}, pid={foreground.ProcessId}, " + + $"process='{foreground.ProcessName}', class='{foreground.ClassName}', title='{foreground.Title}', " + + $"elevated={FormatElevation(foreground.IsElevated)}."); + output.AppendLine( + $"Settings session: pid={Session.ProcessId}, session={GetProcessSessionId(Session.ProcessId)}, " + + $"elevated={FormatElevation(Session.IsElevated)}."); + output.AppendLine( + $"Configured Peek shortcut: Ctrl+Space; AlwaysRunNotElevated=true; EnableSpaceToActivate=false; " + + $"AppsUseLightTheme={ReadAppsUseLightTheme()?.ToString() ?? "unknown"}."); + AppendProcessDiagnostics(output, "PowerToys"); + AppendProcessDiagnostics(output, "explorer"); + AppendProcessDiagnostics(output, PeekProcessName); + AppendWindowDiagnostics(output, "explorer"); + AppendWindowDiagnostics(output, PeekProcessName); + return output.ToString(); + } + + private static void AppendProcessDiagnostics(StringBuilder output, string processName) + { + var processes = Process.GetProcessesByName(processName); + if (processes.Length == 0) + { + output.AppendLine($"Process '{processName}': none."); + return; + } + + foreach (var process in processes) + { + using (process) + { + output.AppendLine( + $"Process '{processName}': pid={process.Id}, session={GetProcessSessionId(process.Id)}, " + + $"elevated={FormatElevation(ElevationHelper.IsProcessElevated(process.Id))}, " + + $"mainHwnd={GetMainWindowHandle(process)}."); + } + } + } + + private static void AppendWindowDiagnostics(StringBuilder output, string appName) + { + var windows = WindowsFinder.ListByApp(appName); + if (windows.Count == 0) + { + output.AppendLine($"Windows for '{appName}': none."); + return; + } + + foreach (var window in windows) + { + output.AppendLine( + $"Window for '{appName}': hwnd={window.Hwnd}, pid={window.ProcessId}, " + + $"class='{window.ClassName}', title='{window.Title}', size={window.Width}x{window.Height}."); + } + } + + private static int? GetProcessSessionId(int processId) + { + try + { + using var process = Process.GetProcessById(processId); + return process.SessionId; + } + catch + { + return null; + } + } + + private static long? GetMainWindowHandle(Process process) + { + try + { + return process.MainWindowHandle.ToInt64(); + } + catch + { + return null; + } + } + + private static string FormatElevation(bool? elevated) => elevated?.ToString() ?? "unknown"; + + private static void ForcePipelineLightTheme() + { + if (!EnvironmentConfig.IsInPipeline) + { + return; + } + + try + { + using var key = Registry.CurrentUser.CreateSubKey(PersonalizeRegistryPath); + appsUseLightThemeValueExisted = key.GetValueNames() + .Contains(AppsUseLightThemeValueName, StringComparer.OrdinalIgnoreCase); + if (appsUseLightThemeValueExisted) + { + originalAppsUseLightThemeValue = key.GetValue(AppsUseLightThemeValueName); + originalAppsUseLightThemeValueKind = key.GetValueKind(AppsUseLightThemeValueName); + } + + key.SetValue(AppsUseLightThemeValueName, 1, RegistryValueKind.DWord); + restoreAppsUseLightTheme = true; + } + catch + { + } + } + + private static int? ReadAppsUseLightTheme() + { + try + { + using var key = Registry.CurrentUser.OpenSubKey(PersonalizeRegistryPath); + return key?.GetValue(AppsUseLightThemeValueName) is int value ? value : null; + } + catch + { + return null; + } + } + + private static Session? WaitForPeekWindow(string filePath, int timeoutMS) + { + return WindowsFinder.WaitForWindowByApp( + PeekProcessName, + window => WindowTitleMatches(window.Title, filePath), + timeoutMS); + } + + private static Session? WaitForSelectedFileChange(string previousTitle, HashSet<string> expectedNames, int timeoutMS) + { + return WindowsFinder.WaitForWindowByApp( + PeekProcessName, + window => !string.Equals(window.Title, previousTitle, StringComparison.OrdinalIgnoreCase) && + expectedNames.Any(name => TitleMatchesName(window.Title, name)), + timeoutMS); + } + + private static bool WindowTitleMatches(string title, string filePath) + { + return TitleMatchesName(title, Path.GetFileName(filePath)) || + TitleMatchesName(title, Path.GetFileNameWithoutExtension(filePath)); + } + + private static bool TitleMatchesName(string title, string name) + { + return string.Equals(title, name, StringComparison.OrdinalIgnoreCase) || + title.StartsWith(name + ".", StringComparison.OrdinalIgnoreCase) || + title.StartsWith(name + " -", StringComparison.OrdinalIgnoreCase); + } + + private Session NavigateToFileWithRetry(Session peekWindow, Key key, string expectedPath) + { + for (var attempt = 1; attempt <= MaxNavigationAttempts; attempt++) + { + var expectedWindow = WaitForPeekWindow(expectedPath, timeoutMS: 500); + if (expectedWindow is not null) + { + return expectedWindow; + } + + EnsurePeekWindowInteractive(peekWindow); + EnsurePeekWindowForeground(peekWindow); + KeyboardHelper.SendKeys(key); + + expectedWindow = WaitForPeekWindow(expectedPath, PeekWindowTimeoutMS); + if (expectedWindow is not null) + { + return expectedWindow; + } + } + + Assert.Fail( + $"Peek did not navigate to {Path.GetFileName(expectedPath)} after " + + $"{MaxNavigationAttempts} {key} key attempts."); + return null!; + } + + private void EnsurePeekWindowForeground(Session peekWindow) + { + EnsurePeekWindowForeground(peekWindow.WindowHandle); + } + + private void EnsurePeekWindowForeground(long windowHandle) + { + var nativeWindowHandle = new IntPtr(windowHandle); + Assert.IsTrue( + WindowControl.WaitForForeground(nativeWindowHandle, PeekWindowTimeoutMS, pollIntervalMS: 250), + $"Peek HWND {windowHandle} did not become the foreground window within " + + $"{PeekWindowTimeoutMS / 1_000}s." + Environment.NewLine + + GetActivationDiagnostics("Peek foreground activation failed")); + } + + private static void EnsurePeekReady(Session peekWindow) + { + EnsurePeekWindowInteractive(peekWindow); + + var previewState = peekWindow.Find<Element>(By.AccessibilityId("PreviewStateAutomationPeer"), 15_000); + Assert.IsTrue( + previewState.WaitForValue("Loaded", timeoutMS: PreviewLoadTimeoutMS), + $"Peek did not finish loading '{peekWindow.WindowTitle}' within {PreviewLoadTimeoutMS / 1_000}s. " + + $"Last preview state: '{previewState.GetValue()}'."); + + var loadingIndicator = peekWindow + .FindAll<Element>(By.AccessibilityId("LoadingIndicator"), 1_000) + .FirstOrDefault(); + + if (loadingIndicator is not null) + { + Assert.IsTrue( + loadingIndicator.WaitForGone(PreviewLoadTimeoutMS), + $"Peek's loading indicator did not disappear for '{peekWindow.WindowTitle}'."); + } + } + + private static void EnsurePeekWindowInteractive(Session peekWindow) + { + peekWindow.Find<Button>(By.AccessibilityId("PinButton"), 15_000); + } + + private static string FileNameFromTitle(string title, HashSet<string> expectedNames) + { + var match = expectedNames.FirstOrDefault(name => TitleMatchesName(title, name)); + Assert.IsFalse(string.IsNullOrEmpty(match), $"Unexpected Peek window title '{title}'."); + return match!; + } + + private static bool WaitForExplorerTitle(string title, int timeoutMS) + { + var deadline = DateTime.UtcNow + TimeSpan.FromMilliseconds(timeoutMS); + while (DateTime.UtcNow < deadline) + { + if (WindowsFinder.ListByApp("explorer").Any(window => TitleMatchesName(window.Title, title))) + { + return true; + } + + Thread.Sleep(250); + } + + return false; + } + + private void TestSingleFilePreview(string filePath, string expectedFileName) + { + var previewWindow = OpenPeekWindow(filePath); + VisualAssert.AreEqual(TestContext, previewWindow, expectedFileName); + } + + private static WindowBounds MoveWindowBy(Session window, int offsetX, int offsetY) + { + var originalBounds = GetWindowBounds(window); + WindowHelper.MoveWindow( + new IntPtr(window.WindowHandle), + originalBounds.Left + offsetX, + originalBounds.Top + offsetY); + + var deadline = DateTime.UtcNow + TimeSpan.FromSeconds(5); + WindowBounds movedBounds; + do + { + movedBounds = GetWindowBounds(window); + if (Math.Abs(movedBounds.Left - (originalBounds.Left + offsetX)) <= 5 && + Math.Abs(movedBounds.Top - (originalBounds.Top + offsetY)) <= 5) + { + return movedBounds; + } + + Thread.Sleep(100); + } + while (DateTime.UtcNow < deadline); + + Assert.Fail("Peek window did not move to the requested position."); + return default; + } + + private static WindowBounds GetWindowBounds(Session window) + { + var (left, top, right, bottom) = WindowHelper.GetWindowBounds(new IntPtr(window.WindowHandle)); + Assert.IsTrue(right > left && bottom > top, "Peek window has invalid bounds."); + return new WindowBounds(left, top, right - left, bottom - top); + } + + private static void AssertBoundsEqual(WindowBounds expected, WindowBounds actual, string scenario) + { + Assert.AreEqual(expected.Left, actual.Left, 5, $"Window X position should remain the same {scenario}."); + Assert.AreEqual(expected.Top, actual.Top, 5, $"Window Y position should remain the same {scenario}."); + Assert.AreEqual(expected.Width, actual.Width, 10, $"Window width should remain the same {scenario}."); + Assert.AreEqual(expected.Height, actual.Height, 10, $"Window height should remain the same {scenario}."); + } + + private static void ClickPinButton(Session peekWindow) + { + peekWindow.Find<Button>(By.AccessibilityId("PinButton"), 5_000).Click(msPostAction: 500); + } + + private static List<string> GetTestAssetFiles() + { + var testAssetsPath = Path.GetFullPath(@".\TestAssets"); + return Directory.GetFiles(testAssetsPath, "*.*", SearchOption.TopDirectoryOnly) + .Where(file => !Path.GetFileName(file).StartsWith('.')) + .OrderBy(file => file, StringComparer.OrdinalIgnoreCase) + .ToList(); + } + + private void CloseTestWindows(bool preservePeekProcess = true) + { + var peekClosed = WindowControl.TryCloseByApp(PeekProcessName, timeoutMS: 10_000); + var peekSettled = preservePeekProcess ? WaitForPeekProcessInputIdle() : StopPeekProcess(); + var explorerClosed = CloseExplorerFileWindows(); + + if (!peekClosed || !peekSettled) + { + TestContext.WriteLine( + preservePeekProcess + ? "Cleanup could not close Peek and wait for its UI thread to become idle within 10 seconds." + : "Cleanup could not close and stop Peek within 10 seconds."); + } + + if (!explorerClosed) + { + TestContext.WriteLine("Cleanup could not close every File Explorer window within 10 seconds."); + } + + explorerWindowHandle = 0; + expectedExplorerSelection = Array.Empty<string>(); + expectedExplorerFocusedPath = null; + } + + private static bool WaitForPeekProcessInputIdle() + { + var processes = Process.GetProcessesByName(PeekProcessName); + try + { + foreach (var process in processes) + { + if (!process.WaitForInputIdle(10_000)) + { + return false; + } + } + + return true; + } + catch + { + return false; + } + finally + { + foreach (var process in processes) + { + process.Dispose(); + } + } + } + + private static bool StopPeekProcess() + { + return WindowControl.TryKillProcessTreeByNameAndWait(PeekProcessName); + } + + private static bool CloseExplorerFileWindows() + { + return WindowControl.TryCloseByApp("explorer", IsExplorerFileWindow, timeoutMS: 10_000); + } + + private static bool IsExplorerFileWindow(WindowsFinder.WindowInfo window) + { + return string.Equals(window.ClassName, "CabinetWClass", StringComparison.OrdinalIgnoreCase); + } + + private readonly record struct WindowBounds(int Left, int Top, int Width, int Height) + { + public (int X, int Y) Center => (Left + (Width / 2), Top + (Height / 2)); + } + +} diff --git a/src/modules/peek/Peek.UITests.Next/TestAssets/2.jpg b/src/modules/peek/Peek.UITests.Next/TestAssets/2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..808462ae772d0bd8ecc52cb0277a523233fe5d42 GIT binary patch literal 30597 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 literal 0 HcmV?d00001 diff --git a/src/modules/peek/Peek.UITests.Next/TestAssets/4.qoi b/src/modules/peek/Peek.UITests.Next/TestAssets/4.qoi new file mode 100644 index 0000000000000000000000000000000000000000..90eef44febf90aaa1628194d75ba8802d5604c5d GIT binary patch literal 16488 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 literal 0 HcmV?d00001 diff --git a/src/modules/peek/Peek.UITests.Next/TestAssets/5.cpp b/src/modules/peek/Peek.UITests.Next/TestAssets/5.cpp new file mode 100644 index 0000000000..54e47ecd1e --- /dev/null +++ b/src/modules/peek/Peek.UITests.Next/TestAssets/5.cpp @@ -0,0 +1,6 @@ +#include <iostream> + +int main() { + std::cout << "Hello, world!" << std::endl; + return 0; +} diff --git a/src/modules/peek/Peek.UITests.Next/TestAssets/6.md b/src/modules/peek/Peek.UITests.Next/TestAssets/6.md new file mode 100644 index 0000000000..339bae7a48 --- /dev/null +++ b/src/modules/peek/Peek.UITests.Next/TestAssets/6.md @@ -0,0 +1,11 @@ +## 简单的 C++ 示例 + +这是一个最基础的 C++ 程序，它会输出 "Hello, world!"： + +```cpp +#include <iostream> + +int main() { + std::cout << "Hello, world!" << std::endl; + return 0; +} \ No newline at end of file diff --git a/src/modules/peek/Peek.UITests.Next/TestAssets/7.zip b/src/modules/peek/Peek.UITests.Next/TestAssets/7.zip new file mode 100644 index 0000000000000000000000000000000000000000..769fc182533854a7475b986a921ae4d13d8ef077 GIT binary patch literal 122920 zcmZ^I1yCGalr;o`BoN%)-5r7jcXxMpcXxM(;5xW#a39>=9fA(d&-d+C?QZ?MQ`M(> z?t6XCJ@?)2>Uu3N1p$c)_RlZS<x=zClmCS8V1!`GCQi<RPEIDyP7E&Y-@(8k{~7xi zRFvVtpxH{D%>_S?k345{`G1LEz+k|X6xRL+5$gXWGPSTaVWM|(HT&Nf^WJpKIX)Q+ zOPtLcsOY8CD95Gg+{S8ZRhZ=&<r!JQjL1SF*RwkfwThz?6Ti^-yxrV5b~ze#y%sq8 zkU&5{`26N0<I$!6N?0oaq?H6psE9*l>VKP0*M`lH`hzN+z$c6rZv`=H4GktQ1q~Da zXtt#HY02~R_`eNc{7(Z;1~&HACiG@TcE%?Emj}*I4>+G5&b!o{XgU(fpZSn(3GUn} zoYNrf+KuqVBW^aO5L$#%Z#F-kzbg|32&*I{ubEwSp_i7vR23S7t1w2qcC$WSC0t(L zU%$QYUC)g4u8oYn&Go-OAFS+Lzro-r85!RloNGoTWSt?2Vt$BBFi46$5Qv4pF<5*= zjU-IQM0~vUynej4ynK+vmCC6>FTI$hkw6b`G@K!gO;o;YAqi&uy=eeE+^l}j$h+KZ zT>sG0-1>Q8?Yhxp`sSBo|Iu*v?&RorU}@U>W)zSx4m@4VG{<WwH0o{?S*k9j<MPdE zch@$*dO^pqTU=aR1$CHZZLBT!4LqNooD8fEoQhQP*2%hVqHdf!$Cj*`x_H@KJ3H89 z(VYM;FW=cabm!N2X!dFv++HJjqk$D1vLNrMwAcOPW5Mjs@x_z1p{8y<zC&;CmmTpL zP}CWnXCsqKLGIn${l)0o&CdJGJ^qGYhc~aL-G<y*F%3_Ti#JJ#MT?x7R;A7s@mVfG zMd3x*%*^#s8`n$gtve6jM`z_!HFwfw&=NU?+Y$YhExIU%>krY<*{2!U9R7V}xvB`E z_U49<T4vssRlcn5^Gm=v;#NTpXBTg$uMfWmr$+n|P3iEy{gXZ@2M=$((bO%k<wt2V zd$X%6{gzuZgC0RH#irf>b54DdrQ>rI&y42sR%@Z%nwIx#IzU_R8J*|+`M{#n3Z8dm zmZIa_u#ShPU4I$1jZ>Lo52QAcJz?jH5vO{k>ZaFWmD7JYKX8|y;hUjcC>Mw0MB#j$ zBb|3u3EiO>UAVDv<*c@(W$fx_@bntXXHC0a3%DPZaT<v=qfb?(=VkyjEIvT2)rZkw z-2AmTQMA@xUyqDg7>u|yHnTOc(YoS2Cz#a6m3u^&yQAd6<zH1ToV$2feLw8vYH!!@ zasR2)$$FlUp5s<Lx(PfRKdnpGJMXlmx2?&u!@Wo>EiD}`9zRQ(T!<P4?yauQT#iph z**Vw=((`rO;px)fwt&WE+S}|Wm+$t^FP~<5=XW>u+AQ_#x~J1_gF23$S{7Ei7K7D) zmS!0nJT?0`c>DPH6<u=dpBSF~zIQ*@%I53n@k>J}G`lovzD&EMFS)8I(bGggSvuXn zIC-@>JUo58)c1C?dD`(fEpFm^S=Nk~O5Eb_p1RcQlq-uVEpLg+Xl^^BrLB5K*UOVj z@7n6X!n3g<;N`ut<0qJwGF<iqS-XO4PR#cV{9I<~n&z^g?>UV&#fIbJY!Ak}xmfo= z)<)jmUa_v4rIkrpyTNhK=yIc@v=%bbc2ONENqhZs4vt=?Lt9#w4gpQBvUiSVukI`G zVx?<2%DW!FcnM@=Tj)(WwyI0>@|F(Q7dZ>|o-gmM$I>abb}vV7?`{DZ&XxAA56{~t zjy88bA*a{(F^g5*z8pzOap&%qCI()vO$$0YHW#>b<4KF{KKM(eQ9RHXEgfr)cjk%& zopElmxjs=-a~q&2Su;V}7PZov)Iq72%Mzp1OOvHIwj2%K=D8QOC2yxYlNJ2Rw#%2t z{-HyzybU}ZF3&nk2Va-&Ipip(j;W-ikdoz<R$krKbPXF`X<35FD3I5Kr0S(6!yJd# z)uD-HAa3T|gO-(v_tTS)?1W7B1b_3>=!vFU6E|QbX9>9b8i}lgSKrC}R^=0QwL~)o zZRPCcWpyw(f&X*$4VamA+LSdJvrt*OF{s4SWqrATiZsmQx^wZ@-N(o|>Z-eSlzU6p zrhMfExW5j(xR2D<P4}jAo{Hk~;BP+P*4}WzxWA?H(O9+Ap+8>*bZjhM6nVFzd7D_N zZMenR9bL7jU2y<_yO*cc?bCY*9DvD({;`wAr|W~$k{s?kI@|h(os;K%Tacw|HCtV4 ztwZBAHy@CmKowtY>0)8^w(l*|ce9q}J4Yjr*bzfsZgU69#_i<d=#M73%4db!m_0Se z`qc!n&SjRqpIy9hHOprwOP`M^yJrW#i*3W*{CoDd?#7a>k)6?rofu9|cO61E4jd^C zF|#EAAgXdv(Coqa+UM5%`PKMvy_rJn=+HIY?pl1a;$VY5YkAF_E>Fg}q}p{#FM^XB zE62E|GK~ho&f2Qyexi*#*9y-T-#Tx7Vv0_2^P;Ls!>gY4*|lXgvy0bb|NCL5`*3;F z;v}^X&em48_Il>Q()bdEnb}$88G<BzZj0JuG><lC7W>|m*O?|Ron7<O*hDdJ4k?P3 zEuL*IEDNvOK=WPDY7dR;4zrggpR>`;GiMiw(^9N-LeQ$-$IH1amxqPU$Sk*d>G)-A zVQ~NOt}f%a(QK3~Bgt(F1CUalc3*h1hn|t0uB*enva0D$>AG_+b7t%6dvAO3P_&VG zd|VhaIX?byFn4e}w0hCamv-ctQvZ?!>$#$-X?4}Ce&)V&0JPnzmIYLAuFkb&wZ&rb zYuebka`;4DK3eB#^IidDFLPZr-8jU)Q=n|5?7gHEf?7gAfQ7{v9#@Wzi_4qluADC4 zR<fiUb#3~t2|9pn(<(+z(B<y#?c%AS+nH&x`E_##A9qjJ!+T>Z-+lXhu2qffL{)Q* zCP+(8TNfznQW{Iapw(a|#bG6P6_?pQs+*p-y55LVoi@5c($BGG=paZpWxL^0>Jx=v z>S20nT*1=Rr)HYA#&MB#gl>^Tt9{YEj=!F@F?c=tz?&e2(!#MfCzj;e+{M+!$KA&5 zu%@fM(X}5|(X`B+=a-SqpT}?ggl<P(jj`B#bz~ch-lBzaQ`h9(<Nm_D=ChI0so|HK zx7N{WVI$L;rs3UTJ0-hbllOCiHwSpeLbm?M;5zy;A>q|zVwyHEdn4%pEE}hId+=@F z%H+4{n#`ufYg*KrtGV^!p?jI%@Y1k!QRP_Flu9b%ap}J0_T^l#>1vMCOk#M6L%{&F z^mioXv?MKBySV^d6gv0jqt?4~P}AIKplc{9X)dELFI!SK1c`ImUCEO(Tf5h+T~=QJ zC!nBV=mIU4np-)VHBTAfR`b-u`C~oKR7&OCqNA6gOEV|heq=^Bw;x+$)17Vj)r<4Z zYf(q7N$&h?f%_&3kMV1j%Q7(qLkAGMT~EhHPo1Z2)jPdMosYj^!;J5JeT8dz)u)?k zv#yDmiDxBq9VhRsd0^Jmt%k*c$-&33%V0|_H*bmozj?DdwlTwH7PwHIicrY{DBlZN z99TRYZ7t$qsej?SZJ$d7Ddj9C+d16d*_aw#zq&NsH#@IirgvPH>#BQf@p`JGXW0QF zvKG2VUn-Z<(iZQ}*7NyzG@JHv)PQQ6pmcZ7{V^AI4-TG<4QrXMG#YQa!^>i)?c_49 zb54`4*UrY7Rhz5Efi4?{O=;Q6Cyee+N0*!GducBp6EBw<wx;%Ow|8%cHEwG?{8(9M zQ3CRkqoc(MV}q=wjxf5_OkEv4%O2_Kyej&wN;k7<+8()^iy60$#^r8{92slc+;qUA zv(@-XsS^diE*E#kng@=~Y4hPxhg`$qu5pS@-qj=e=-A9F3%`fEM)nqa4vFPL|A4ib zhss4xhY#P%ieI{RyN?<}6poVV&i&4|$NT=l<J(^ggDHTpC5P(egw8mxfv(wx#;#T; z$~XwHbdb|_lyiAM-q(u7&)2<w=zVkjR^c>lNjE-NK2!Q|G9K)?te2r}gXcQsrggND zLC<R~2kX+>$h`y1UM%;u+CtlN?>0ryyp_#wye}Ya&>9}62m{Q3=$hHvu9`s(m1}%D ze7rqAs$pp?-#acUfd*&xo}PAHB5QMoeK}z$43%!BZgZfli#Lfa!<L1N9t(i18wCbW z3Ek?&Ld@cU(KthSF-60xy)}F8#oA#+ZX3U+Ii1Jbi}z+XH`_+WQ(79}D6K#3w$#lO z!4;#_E)t!AyaPa2k;g%CrN=S6bo6its;0OQvYHI|`qo*)eI<Inft!7`!2@yn;IOB^ zppldXP-tjsw4h(vIbE1E9=_ne9#Osg_Fex*G!H-4%?{zR<j~Yj6R?r7H(WWFbYB`X zI2?7RdbGZogBN2<U%3|3kn!+%K5-1ZHL!9CS-ZYiVi{Az-w$5NHCnU2DOOQe9OfzX z!q}54)Ux968a@KOx;WSvfJ_R!9DX)=-!;y7wrc78^lURfIqSmX0v@K3mu@|vyH3SU zw4z!SHTB#q=Xm(Jd#tu@t@ThY?p>@*JZWfMHrmS3XP+?p($b^rX?{PNvue3{*4W$v zFl=Vt+pcNXWH(*JxUXh;r|Wv^IITuEp?3g*YneKnS*z*YS?e^L*ZKw*@9u}scjZpU zhr9bHJD=}}g)T1RYT<k-Kx1tU*WdY*<Z7<yHXs+Taym_^xxLC7nkBb~%T3IDTQ&?u z7xs;4RO}X~g<PKQ+!JaSm$i+Sq^P5{J&KK_mTQW8&f(F^<GF>K#lhRVl%Ia~P)lp) zG%3U9oon3MT&uMdENPc_tz6k!9ym4^=uQ`@=K~Ew)H#<$GYq9?Q!R3aeutjJc;;q2 zXO@1?rdG}embb=3Kaa=X9wy#H?H4C5Pi0=Z=eTSbWG-udhR=in$AH#n=A$j<u^jC= z=uOWqC$%hGUJV<%o|z347tmo}H$;6s+gvMr9!x<Ya_8%IW6*P#jaTIKs`!Vd2zrl2 zA8T(0l`Je?6q+1^^yd@tZ%zlP7jRtMJZ*OsT^qdkEf?k2G*6Brt4nT2QE_`58!cQN ztC`8;OG#!7uQu-`PIr&qZOiRh<}Ipbix<F&)r;GDyBUMnqnyH^>n0^fLRo}0V;8fl z(~R`~lrFrT>2u|dCVM8o=0>J2qJg>dgZt~GevP>fz{W~W#FEvlD>;Hy9zhPnW{)-c zsx`oiI`x6#f#*^sRrKlU<Yj2|RqE`dnuo24`{mcd{9SMFxYb$LhAl52{{$WHg$-@= zYX1qH*S$C2nkJ_cG-!8zAu@vqwA4M=PselH?DtW>FnbZP5i&>e-0kN`F+`x7OHjn6 zZd233t@LW~ac65{dTV@eu>I!ka$4NA>L7O6m8;&<vx>{_v7zDg=RnswMKzMM%VM$# z#6EGdsQBXJVWu{zy~&y5z{2F<>1!sJHqn>FcI31sM{zfsp<Q@Y8V1OTc+vr(YuRF( zs+RGt;pMF5begA~T|ca6bZ1p6PTFWSFty0QXkq&y0RYW&DmlQ3fr&wPx2>+-V|bHS z-|@+fp>t)c3LeYq6rLovr-RwWqDI>jJ+#$xK$HC>!sv~n)wr#7WpOiBm$!qIt<#}_ z>vhO?AG*;<i#+NMc3-brmyY#oNKq>vCo2ydUD<OW@O>*AfvcPE8?J<4YBX*SAO4o! zm0s*R{#Kq2UdPAH_J`}ooxQ6Q?~SADojdo9pV&yczS<xT{Bs7SpX(vq#`t(Qzej7^ zPoC!y1OhwTm-pyoejct4KX=@=bw8f&tJ|+1FMf2)zr<WgiAXx$Kh70Ee%zOO#sgh* z*L(dV3-4zu3v&x2?>jr!#YaWjJP03GBMS?U{ntAm!;$Fjn|<P93;6t8e0(>-s@KOO zttj~DaghlwAM;QmI=j`P?|JthEcJdqtd4%K?md2w>PXdZd1I9$33x1rTg8t(UcLhB zpy=Wu0=YObVB8ghDE(A55PvT%IBaR7(wM)CyMunS2U934qkV9^Rn3F1o0iXVz)!{U zpoha%jr)V``tGm$-jLhs^H45+tk?s>IvhVQejM)R`g(`!t9&aTJi*h|baPhO%bpZS zXR3NBtI&v|*w?)bj)C>Y-P^^>smJew-O=av-Pc3=wU;hDVeMt_Xzy$|AuG%6BUDTd z^v*A9w?6LX!(t1!Xdt;h_V@eipRP8)^{&FRAg`VGgM-QOk&E}Yy^I&Z<6V=F_tVjj zNGuS_(th2?MtGJA=y}fBc&cjy6{YBrfya6xrc(<{X<dfG8?4Y{>G<GHj<$1s{5|7k zbkfJ0<HG_W?giQ`&Ft#HUfrDTy_p&L_~`v$B;D)cuV-qEbN$jCO@9wf%HV11y;fWL zZN1DR6@wo)S(MyZ*3RHkDxg*u@CPM2)WE%+@3!)6h^~5k{5L;eyK3i8`lLb@P}fq} zFv6hxfQ_zxR>SxkO%Hi{SZ(T0p8Dz4i>kM&f#?P@?#rIbw=^6gP##Op%1K7dU%l0w z@`EPe$3A~Z&EwTB$GhJ;jI*x<$3kTCULD7fXo)qG<i|$lsy%|5Ck_5RgxP&My0!7r z8wF9LwIuqjaJ-`bWTUTx>j&qiE5zA*Jugoi)2*JaA6gt*zb^YJ+fucPk#t!C5Oe0& zD51Xk?{so>NM~sa6_}LY?^L5UsP#-%HrI*oCQ|uOL<Dn+k1G@lK!HB-CJw%#;`_w< zHBC2ZYzDd)z}*pswK?}yoH6oz9-C2igyQkbWIK&m_xYq-);;<VwfC1(+Hc|qYkgps zp?sA(7H+>#ljxj@j0OhWNNt<DqLm;jDe}}nI4!PGTaQU4dwGn+c}|1h0wUr2v(o~{ zvZYXT!%}O6%B7Qj1L(W^K^ouCGWh{}*?T|%#XKjDjBbwO=2<*EmejO{?ayp5OcyzF zKw``id`E$&wc!;TA>ivFwhfzo>b=>ez=GfGM+g6rhz8oB3YwP~4AJ+fQ9PNrcV|b; z>t(znl$SI!=mQJBYiIkP4}aacKJRY5fs^jF79`|(ID)9iAq)Q$;765R<0AW5N`Y5( zvfgEnq6K#9SPc_R__hM_Cc9+Fyzf)0k4q}~PS|{mbluswU(tQ$yjppK>L11d>Zo=f z8!OAGOr~)a%SIM*w4DlS_>Ym|>yT%u4Sw@Fx?)!1nBjEh14sJznbs%DCR?+cJDMfY zb#Ddq_W+Z+dtYV{0^JxpmWjle1(ov$EVLw3MNX#2=3V#LQ0Yb>8Fz(be9A}0`0piO z=8wF=P!dI&JGy4&2;0C0vg=+IDOduOvEYXd+;_){g6@ZPIG&frY$=i#+Af!1(t3!w z6|Q@sIkrk+bG58pIAh7#%=s1WM$Y;&$=jNZpP~1I#k9>_bL0}`wHc`VQJU=a$7)n6 zDBO5zwA>$**&*{bbB+>2p>#;p5)te{9S26K9+Sf5`X%IOvR~6JdmN=bE6JLq+wzGe zU}u6}&@P=pYXQ`jXIp3O`X$d*URXIGD`RZa+<CE6wIxke!8XQSXPqGBRCeggCBS%} zXgD1UP-I=&b~71wy+-S6r@N{p5W7fHt;0o%E=$LBz0!Xgps01$^v-KKQP>8=r05%i zDyN_1eI1(bGHll7Vj;JMEG<vRT(7}13NaZbQ|c77q^x|9T6Z=*OR*yR<7*#BIST!7 zhP@L)?BeOa#9otx-A_H$p1Q$cKOPvt3A7E*mc{4nu$_jyKU0Chqtl>mN>qDc3&9G1 zSzwKA&_V=8Vy-jbpbXWhadcGBAIL^TSoT;>oLc9JTh1Ajty9cD1L7K#PC}^YzShXp ztd$O^>aARuOVxip)8))`mmPyXgIlVlmX(*XmQmsA5>mNWC^dnb@>F5<sl+sDE=fNt zq|DjS#m!%zXKPSuh*m>@ELCnAbB$1>y&oUOth6}v?6H)#>d{P5=;T8O7Lcl>>;Mr> z8gvRa_*D`WxgLe>>9W2YS>)QQC2|`VR#F67$=6w@nU|)EBtG-+`breaqd_AfhXP&m zUphDb7Km$llup|}tvrGB%j*}qu%IwNQA149(#2cP&?$4-Qv|7&WED<&^yKr*x*P^X zKh9gU7oR)_75lBMs@Hj1w;E-}bU13&G**M%?F{qDn!c)4z|J!+!U*=mWv?shnMA^T z2UKHO6)O&G5WlHWDzmg|)#PeScT|zH`Tuq3IUw@a9D3%%C4>-b`x$%VL@qI2Smj!c zodi(z?hb))((gIA&dRG)(8S$n=2m@=pHi*lpE5~g20%UFOvJ3miqFm}m*-S!?!OVg zkYNf39de|rwQVF9g_x+GG}ms+cPwktMDsJXs@X|a%!(SjSXhKE$~svz*aX_l>7W0= zHNh8PX^u#0WbLpTZZlr-9Bg)Hyo7$x`W1o;p<li>zu?PDI6Aaq6z5#4$*#@>ZJaEG zPpi_%-a+=>M@LeI_IvHm30;7G=-=9DqmfmQ%NcT8Oz`n9<qszd{d*h!Y2P`|04E># z9)EKi<mTj}Y?)%JSg5i_ovt-*v<Yus3tt5ey!>JutWqx6RD0Ihk$H!o(moQZ>}+_4 zlm&g-eBTU`=McP%3=x|c3Oa`2y>8Sz<TmDf>`R2-ThFU;L#cgc!Y*nMrxoQ>DbKng zop0Eq_XnP*E&dWXVY{Ez@1MZ85Kn6L(nAvw6OD@`yirbYi?KS{eQQ5t7npyZw)vcg z^B6&w#VX74dO+{L3=o2lejrxj-Lv}+(c4Z2;FH?F72hu`>Er*2YL8C8oMG}3RJ23T zHa`ba+*d3~nESOVQ2Tw>=%`39#P899BDMJa>kdTmKQmCa6wMUP;7B6#zH;lV^^*EF z#0l?C=?4UueI*m*@|CfH9vS<XFnI@YC$*X68fSldY^|w#uJ%AXrv`e`3y1l^*rR0o z<SwTDgkBNosYOmlBxjN)5db106&-7QjL@?xCOx;TeQpl5SO-AW(TbZ);R%hm!XDZ* z^!<{mpnI*e9vkNr3yo#Pj>yg#wv-v0)!8m7UB!c@ndilr0+01Z4T=3#coI7-E~1(j zW%Hcp9+fGfl)&{BbsNHS>L#vE#%#dKco&EM8Km|;00AvwE<(PsJZ|ZCK%nHeXmL&2 zpa{CEd5wS&SN^V%zy*mez;RmhYGj=Rn``~U%`x+R1Fgqij>@W{p|p3ouPen*x=SMk z$c-Wk;M>U1$Fd)CcOm0q1sLDA{i8*X`v8&QGFkRs+3*@c0U2D~9fij-r2Injfw_hX z*+wGVY<t!flIOlEq$YBypWisE@o01^?HIs`8<A$C<aQwUvm?pq1bIt|zT&O!4}35? zSprm@!Z(JslJ~K^)+0`mcH+HUiLwW^cc%NJbLvdv(ADlJvezPeqb1|M49=7#+7EOs zW!t(j()z&rE5K{S5wnVlou{wAvKZMb(|svt%sb{(=*at93jcLB0Iic;sW^A&EyXX| z#xnC!APyw+k%R9$d!3w84$KXcZC=%T8lKN%hI}G@1QWsY-OU~6n<_6=EDK6n0l+$2 zI`q?Ox}uKQEqQnhAr;-`Ske{$Sf4MB4l|QE*(Bpz2iM?b6+5phydiWQ^2qB~9sp7M z(Z-X|(>^ASFw2H^s*b4i&nCq%py_&J@D;x+x>xo2U-lvPgGyqBl$0CB<U_94LXZFw zF15Js#H83mWGn&Wdc#PwtMb-LU>G%(QuMCmHYb7QlG)etN-R5Z<s6}gBAspex0}iU z8J#k$mJ0{e&>!d`7k}v9Kg*KoL>g&ZpxYI(eWUnm2}%R1q1#XnQXKKw$;l{jf_kN= z=Z50zM6VzW_c96_8_GN8TJl)<L@wjo3yt3{7ldlgPdgsvCh5-=i=__4a^Al8a#4FP z+Vh#yTr$>NYE*g}UM`W>7QNrE`r2uom1_Eg0>WKd#=|ons`!s~14@RE1(JrgiTUkN z0R5Tzl#`_m_>?El{thpbr;&d(@-Qv*a~ovf#`g#x6ZhH^thKcJ>{2`7VhuABM9ZGb zu{?JKC?b^%7JSP?{m0K9m542Lgq!nGlX{HsinY*KfeX2xHdp*jWEAYUuUvInXZgv7 z3puUQwQB>d*#zh(Fp8R=boU1GAiIBT{?kyHN-i0ZhlK2u^#_+#BdsCXP5z&K==a%& z*W#Epqm5NEo}V31f(XegW)q(xrK!2_Qsq=4_h`cvxuPNFVLlT6Y%nCAE=!UyIei9c zx*fa7{rb5>W-4g#ce^n3?`a~v-%by(3FHDTk)$T<vq)3GcZF8&oe%O9r}2zgtYJ!o zH(~!95<iQd^e~=<kou5$)s9JrM`29qPps#3nUaxG;!*eRxE8Q9pX)j{jT$idgXp$B zO%(oSwyXxZmaV=%8?b3@;jyjkzWA;8iDbSU$6SF-taAPU%&`&Up8yqxiX*ETnO`*S zg@~hX8Yi6|e?nmZ3SID6SxtOl04m)YhR=w?kJi!2%a+lZ#O*uZS!PE-1n#}!_gU<^ zQxK5|q*<{3Z#h(f{)s`$UM{)#Mh31^*Y?kEax=oQfr@s7VmRkn^F@?+uP%=BlVUJ^ zw!~te`!0@+JL0l7sie*jT&F_q*mZEB^)dVAdGFqgX?bl>j`PEg3Ay`}cT2*t4<~Z1 zMuoK)XZvMw8cb|A7$XX`Ti7Erd>eIjftsKEKH9O?1I*^3*rT7ZnQcw$&(JH<l|*dd z{l@3z8abEN)ac%yI(t>-3#)Pal=>OmT&o=%pjz5RuN+*LEdv>nc)_3*@lPpWYiuOr z2{+g2VL6<yC8-#AID0~&&-1NAHt&c+%eSVoFEiq?zx-tO&94S`SBpe0#Xosn6Duwu z3B>|L%!$Qb?#PG5!QpU56bL9xteW}a3#au^xK>N~3CI_NaPPqt+hNDI4>teNiVI;4 zfO1TJ9ErkKg>XcDw)*F4vA47s<<CM--+joNgssBuiX!o(H{=oD^^ZZ6Mc{}yZ|mDO zx>x)x=I@L7!lZp9+GV0}J|Sv5Pq5NgMDgNO$ja33)Ar9oeGoQ>Vo2F0lNWHB@$X^j zeOcw^IE9BU=9`T90@xggVdpeZGz(;PEZqEEW|1)x^UF?V-5eq!Z`C*?)nZ%pdr(1d z?jQPea@$5ZJLcdi4*Nn`iP6l|i1p7^8Hjl}naV)vgyuM%jQBUk*_hcn!}rGJRWQx$ zV%u0tft>>|55#W!T#_fkp*}o~&rErHEyrM675<8`I~4k)mNZaA8Z`yr+&@5;Ka-Gf ze0yVaDC~N<MHi{t#%Z1DD>A=pDY&-Y6@76&qKi!Uw1|URe<~UKslWJ-zAVp6T`lq1 zdKm|$<)Z$+XfNB=XIPhR^Eaiv8N{d6Z>#1C+kb+fJ`K3lN266c6>jD-vY8bLOIVWd zekR-XWPkC+e!fk?POgmH%&K`k>mLV9e(f>;6eSn2Ndh|e+iI14A#(jf|A?`eQ3`Iz zD|^K$G<uLfA~m+Q4_U%t@f+aF7NT|9tiQdvIUy6a%@^B>YHT}%uSsHsN53$Ls$0CP zm%fMKOH-;R^vIip(^ip@2v6eszgiYnq$=q%jJws3oIXpCFL|eqvgsK*Hq=xxRXl+$ z44PNb1Y7Z0$Woe2USXPckPnO(0qG0Bs(B$ZtY<Rn-8O+HAEXdYv6^*7vad8jW6Ji8 z-YOPT9q?1*Kfy{YVw~4-Sb`{xZy`_}B~DVu_Zz@lAOcN$`Z?2-9m#FBlOgujCa4hL zGT(meO^5(FIqb*CGG1(CJ><8~)t*dqN10_;lty><x`(JRlpQ&LO)_q~V%qc6v%s}p zY;FAe2gkVIf6d^}#ea;zwGQr2{d*d<iVL;=1Hv{*h6%0}&w?~147?@h!~7538?J;@ zSZ{Mm$aAs2)@mMQ@yDq68Wm_xQ!vm^cEaY}^<y)A?VQDTDqYJ@T-34-frr}*4+@}b zu0Ah1E@o>E7v7|xa+c;bzLBSwyp)~%2Q3l%TAo@<D5FerjGjg=C8vl5{a(c0IVO!t zrt%8BRfSU31$!2A-MIE^B~w5quj)I#pEjE*n&v<pQFE2>^hw>aVWW+Ps=mT_HvtB8 zmBE*7=}I{P_m@!EaFkU}aDlj8Sa~DXJ(_Wmo1o!+vzqqbD=HWSHHR_$GZ)OKv9hT} z%3)*%!Vc~BCV@zaIrKsFbCf-YQ54b#sF==uti--8JqfPQo+()f_-ZCh+4yYsr}S;F z7u`w+he5+Bi7IK@zCXO5Mg;S&54br9xGJ0vMqqPWbtpq`o5mh+sn;5EQ!Z{}J|;=R zIPCh*N6IbBq`#YZ!k<-ZV;IJ$E&N_lQkjfuvJx>e0%)t;!G{UVB`EQ#)(=w;Bl%W2 zhO^<?%ZSO|PfU1L<~H5OS^adpN$N8Af*qS(0YAeD4lgEad;Ur$2Bi2dJX?brUgd4b z>FAz_J!B;oYs={fh3Y}ub9fc?_V-0gIqT&}IAGrnbQSX@pI2bc4)yCzA*C3rT|dzn zRzY^p*8^|nmt0@6m-k_LpntT>b58XAza#$%Pn8NliaE&Rv{^{sZwGMU_N9JK!7qph za0<ZxggY)rzLU|Xmsd`RPEH{LAmRqx%;dkokG@em6$)Ql6Ab@~*lrNi2es_h2Nim3 z8gBcaaL6Fakq3{Xuh*`26NU)<T?_t@QycLA>Gwk|r$s(|ppIc7vj6cdntuE5`mZ9N zb@-g2)(7PacK`>2qrU}<gISRMUo1W72Y;vVIA86AI6FTK`osQv0(p_Pk7oT)k6Y?C z{s`Z2w)-t1gq&G~IsSzYedpViTJU!cRh;e5>>q1a|NNISKh|gIto=V?7N8zK6X&a9 zXB6fVN@n>7ZskO|^5Af`{fwHx`6#XZ5h~&Tt6;BApCz?u>S4ez11n~q=*KF^B5MB^ zo`wr>u0I8@KLrs#1qc2S{I7CiZg{g>3%q^`4txqS{V#%u{|GWseonerfZ}{v5jrqa zkbQ9d&`nPA8M2FX4DMN7|A>xpxSbS&j!FBAu_@Fr$hIq7978!o%OR+#O(PX9!zs=^ z9-pdM5=qk@ApwFOXQ~z&f3MJISkNRb{{pZx@#x~n=azu~t|?potFm1Lm^9BE;!J2# zf8<kgxkPJ|<i}?_XR95_QD-FjvOrF0R6<>B99@5Nc;+0};uTz>??HW`btp@hPHMuA zgC%R!VLV}cRAqdk>QJgQrr~;~nB3xtqrm&J%S5}!Hr2!O7v=J6?TiR~oy3rgyKD-9 zESIM|lKMlt_5&>zMIW74rXAL}VgGDb9?aTgs@6hNLQ!X{(6XHhT8RXCzA_<e=X%t) zuH;xR(FSeUnl0^IyakmA)?bJkN))8jaG>h~cQI;p&+nM>O3~~pP+h+2AY1)1%3|!5 z0LY=nPK`}EBEP1eo&+Tk;`|r~`M);OQk3K~C9aPygQ%KeC8jA9D;<Y|1r_0&yXy^> z71V59S*TbfK^`mxyYgub0}<Bv%Z{9T+;hI1Z*>EFuokb=)brsDCAf?SUAm(<Mv*K* zJ@Ew$cN|?xJ=9iWs4mR`06^hu_^&MqiGGj$693>$RH~ysm%O6YU^yn*s(fe5Rv*DV zYAR6iy(sb}>f8F2NJJX0OV%&)@|{}E@t~Qmnz1Fsh3ljG<+_8!y#p_)5FiWqn(jz# zJDR7eunY=NAs3Fcg=g*&Ls9lsV|lM~nlPAb51rBu|H)8TMYw)&Dq_z1E(u+_X-dy% z0uwlkAud(73}9@L^7Q$wrEhB=4_}ZnHmE#GjxuTmtCE}37#0#d9KE1M(6}91yqtZh zEPNF8vZXkrp^nI^hk&jyP&K{a>y7q(><1fJf4M~;5#g+d)sQk1uB@d*erNcfb*E(J zim`?5CWZdAlpfQPpTQYa^Uy{q1m6R?H}h}@Yw$v;?)BTLHhp@&9eH?k%gfZ(YWMw! zwAa9Ae4ojKEXjkTN7egAU*&zk;CFbFOLAv5k@MO)Y|fK!AER76&yZq>f>`K+630!* zsPHPTZ}=2f6S!)g><!)Q8y`eBV}l@%^PUi-dFQ$n03g`c=WVxvYC7=q#hNdedSteL zgZUUc`>h(!SdPEp`*ohWv{c<(?+&tQC04;lz=nW@RXxJ}&$q8Q59LB!f?>oPv|sos zgPs?(NvTqhSp_VpwHo{9VEdgphh<b=>QATU90Iw<5O68PJzfDv5^n+#5c*&1CRq}v zY8VR|V*#&?lE4?*i=|Z>1<mMY6fKIQF1~3k3|228L=6AI4EiFlbw4I>Bc%qRFNYu^ zeN1_>cK?-i^_<{9v+Mw72mO)s{z7r`R$=DCKBtP{pH+vc;dfEup||mVPc45L(EQ&O z-a{6fBvQt%Pqitam-L2!@;Cv`uv}=Paw4S(CeLlC(<ty}SYop<pyWn_P<gdYB4tIk z14xNi{8Uj|E!hCFGJ^_r@`H8NG7Q;iimY$3<cdBw#})S{2@GhVAWtK=My|4GzC|cL zk=k8rV(EnqeV1Tf#Am2O4xVsxgR5->SFb9=HTe*gaK#l#qv%5Q&mFr6<%ROU!U<pn z+}R%7mkJ-m_RJ~l5NHuK`nD*2P(N_v>f4`gvAOWakgoq0q9Wi%y#Hi~bqM@n2@Y5I zakHyF0PT|Vfpm=0SeKEEMec{JIX(q$_4HL;=S|qIpJ~;~{pVm=9VgDJ-lpSX`%<Gj zgdFmsRifV$ip;F;_W_Pve?+-++qzZX7%D4?n3wgWH>8f&wVdgu)>6M@ly;1Yk2J3Q zN(VV13THpKV0j=S#2X)GxY$`Wrjo7l>B5CJR<{D0WZ$H75p}lmF8J@Cz3z!674Z&4 z!ig4GRg`$0G|V2ymWUCeQ{#xlZ(4-27&`L?nk6>@Pf-Ghh3wFRnHAq)3}Ip@@ul@q zyy=Dx@ofwX<Eqs2w`b7n3l7%1i3Am3wYr-Jv|>lXnIuPyr>*R(>*84!uZlI$^d)rf zDHMLrqFptyO!A*-;huNNZdwSaFP@}}f*OMm^n)V72_-DXO>C|o*-;_;lm7-$2HDHN z)los%za9!GqOldi;<Kvk$Wn>qYK*JII&%Vu@Fqx9<6|k9KZwh2)w~*P`U$}(Q%bhd z9jxY1y{brWn51qs-?L47$k&(Uuw@tM@m}rqbwJPlda}LxcSNWU-5m>OrZU&yKpS@R zd(+K}Ob~H9N$tzS*2NmVVIZdwnoiLS#*N|@Hpl*fZ6Y#{k#YQ~{}kE7nId|p1Ug)< z;q5E#mk(>(@>fM$i+h$Xw>9Pkt7u$wS22;v0C<SYghu@WYWmkTINbGSa9V^hnH2uS ztY<uEj)v=r7ijL*hL#u5Cr)8<w?gx@&iMzVPQI?0Q!pcO$NaDjb-`=xk)lYMyI*$7 z#bY@b{cwN=9myv9ReRyQE+jil6XiXqiG?+uWl8;X<3CI=h4(GwBL@dCkaCm=8$+df z9gTsJapyc2b?Bds%yts5#5J+d>|xt$%B`Fq9U$S!Sb!(w)<fp^ZRbieE_U&k`3FH| z>>wLD#?Z-F2wGgVuovyJ5VA>OmkKj(`w-I4tK$MF>6`)MOd}IN%or)i_TeqyL!HBg zo5O_+{mGLVdoBEzsRa8PW-J71k${Hkj%}9-bIV=DBgNVKFH@YTArsU4XWv)?{6$cX zKn9rzfF`2Jw9)qi*1T|IajcVgVo%;UXo<)%DBP;)!f%b?hGe0!rAa8Km_oX-7PI8U zI5y;1v#g4TGP_5~;5xm8tWAAj<gU|n*9Kq4dt&fjHNn0vZGRO@H8%nak(})b=Rsxi z4@7lXy^Ohm7|R(8hYNn1VP_3l;RELZ2f`(PIrPPrO=gT73MVxgMTObN7pkE|L+372 zulqhjecg-FrXn~QCmJ+9r8*R^R}ro7WN9}lVSq$n$tGlI<|d^W1pedikFsc@9u=(q zqJ^3THE@PWSvW??F+{lnDoyBS<qI&292-ey&tx-28MOL-e<F&i^=;M!1Y3zO5qRw; zs4J1k`1b*hgR9DAOSKd>0<=^N0lnW9+=<)<437A5FF(Jxh&AI7&HR9?_>uIxH~+kC zQ*q2eKG5GEH~))X9%Iy;>7sGJFcM!`9n>WYX{7{SA2lNX-Y=2{A;mvgtd!8vDdwXp zna7md8um_*q3oEyP<e5lT^N1`Sq?`a1&rHg{uvJ@$0TLW5fm(;`X!_c-B{$zSjRX@ zVGZU+bRrzTD*vcKpTZOf(<A_WDBD@~tEcz0RY<@xb1F`-53`e0fQQDpF%xqgT~?rI zX(KQQLO7TONJtb^2+eG*{0%MXudGFmQX~)q*+<DB2L(4+bg!Y8R&JjHmStOyS{h-n z{mTSBG=(G_v3w0~5%Fz{@;rRD8g4ioE)~p?;WVZ##eDG}J*0D(cygoeaJJROqH>+P zqF7yGrIT4JY!o0HY_sv5h=B=7@A)Kg4B_ZJ`pYn50AhLwn7)GK27f~LZ$?lRT!fPs zLZP^L24q*Jk@PRGXvG+C=Z)j`c~q}VDnq0}<0cvAc~j{U7i96YL221(S?Y9mWUDXW z85p7cy+Qc!c1d?}L{L%z;nci#KQxFXMbLRFVSWZjNc=)mj{c^MEvXZHb*G5as7p*m zEQVctUl%h`)qo2*%ddB6(}k2-<3(+p8lbbmGSlbu4GP_y^$!;FYM|Sn7)4B2iG*Y; z_2+NO81;6A?*YX%hE<e{{DPTh1n5R0Cd<ljR!HLV@Ytb*M!|hg7iMpjKUq~p;kbhU zq$WDp$EMJNUzvYZrHUUTeAPr5a=k8`$otq~8B+)AE3_Qe3|V-9tJjyzU*xQkbV>~^ zRf?gBVfTE~N@_gOqG{|1@+=Y^?U1p4B{l@+HZNSD7Hc#xwXX39k2QdmJ|)YQT;wrr z)=EhU3BazKX-JP4xk3qJ0lE`7WWxcmfq0cLIHKU$=+dKhVoy&xrkMDegJl)4S*i(1 z-@+;LdqrKzefy!{lVT);e!pR<Cd|UvApcdEn>8mzwX-obaB+M`lasWWdvgr6iOi|K zY}d=p5vOGaUnCSSUy_2KA;1qvJ3@Z39c53Y68Rbp1!fr-&HODI>br1Sb2<%`LFd{w zY48Y1ejtp8)EAQ&PD~_?a4_lVXqY@9#=tT><lAUVvO{(5tV-qCD;2|7f#f90<gobB zG1_nI+k!-q#N<gx(u<P)NGcM9H$n>7q1?U&_}}*}2+@5KrRZ<9&9;{yf%c={=Vy{9 z|JG2-Qw;z4MX#2(Jrcd}TjI|^lLUH#u>Mq;0KyG&aBVOzS^<bEJ~kT6A$%Pp)t_~s z$|B^IlsYk1Wqie^NU<qE`hzv>epJ!xMymMXM(*wj9+%+u>G<^~g^Toztx=avYr#qP zb?(?2FmY1zMR(+IK^`&*bEY-Yo9JtbfO@g(Z!eaVW>u#Xfz>~w@RWFzJu2Mto>Eob z@PM9?Q8LwhFb4tl4E;<aHNrIH`7D?cu95;}Fcbm!GF13!0rq_Vp{oR$Y)H=G9YDM* z?AIJPM51H^4EGeP0yv{7{s^mYJBbdS*(o6>r0F0>l~xpRLFO-FX+H|%Xi<J>jRX#> z5t>Djqs=A{a5MT+jYyk^i~hoYQk`yov{te={Pjd0N-IGV=t3h?_L}@F&WBSHNXtTu zXd&cIuY%a3AgS`hnRzoq5c7+(6`5h=uE5D3IWq3J)RU-#rBr%F?O(aQQbe+{MlIaQ z5wYtmLJCmZ4UldMfnB<7{%2d${_C}A8^V|jG-xGtqC||t6UnV&-)SeGn9MTkEB*=v zCkovDbwiW{w~qW9f&9JF8@b~Bp5j{KJ)YyKNJ9mMeO6-r3mvRC1#<l{IPA6<x#(&J z)b?Ro{#ay!%s0w<3C=hz)B4DFa8tEVLS#r%wBOo4fEIVZP1_QGV~xSjidJwHv659_ ziKI;@|D6|LlPX)n(hWC-U1X}1fZFUEAwNKFJ8TpPd3mO!n{-3{O&Hnv;%I5Ttneix z_}lTmUA(3ELU<7w%8YWFZ?L&yI4S|M49OO8Ch6p{q?yodW-as#DG3p&2PWS_ty_S3 zB7C#Zeg<O3xPGZ{vtj|>@p<kk@h+PM3yT$G33CEdl5xyH6@{LEI=mFojiEbqUzlTK z#ooz}PFfZCjs{>E+Wn7yPR7_mZV1vCB-RI%Y?Wrb;%FJ=IO!!WeO)Nuvk6leapX-c z7Sw!<#C~LP4peY%a6vt&AAGny7*gwyXPJ@%l*iFQ`K0iwbdU((6MkYax<il#&81_6 zCbS9gT5EX7Unh1{VU1~qQP=<K_YE6QfVruwV%Kv<0=4RTQGeKq&ao&0v0zhP{Cwxc zxeOGtWcf*rk4V4?m#H6zjQFC%Z1p4k;pJHL_`f@|()BM|m}=A^0>=WgR@9C0U~$wj z{z6#={ni<QkQQ_e!G4q2JWWdBJW!){Sme81!c3rQ?c^5DT{3)x91m;RZgQS#yM{{| zz+bf1jY=e<(qzy>(oJWksC1+9_y8-g!?9H~grA@H|ML5W=c_<hP<o&bMj{^nl=RM` zKB>`m;2(U%@XKjZf1(&cu+9khI`lxI?}LATaz>TBCdLP;<`dQbMuu^pkv9dyNca+o zs2*-ypx&bYX9`}#-T{&<2}^5_CTdUdiL{gmSG3<3Dp!jU3tn(LCSNNiiO5|UgxD9I zMD$0$7I);!d@Uf6E18HA5k=m{f&wQWQOtmlzc&~aK33?)h!tF4BS`Kdod(}XhRJBu zgfIFV)`N;<;><H0br98PyjZe{hvvv7tW}E9`sHNm4Qe6Lp8(>$Zdr+X{^UefkLXe} z+XPcK^eXosv8K2KP+C(lP9a&pGV_8cvXbH{3gUIcBNze&)4y?}7wjpAX4?kkOU+Xy zsQ+n#ERg-YL1JBk5CQ(4w1ano()&LcOqgg4Do6!X5vE3TgEQ^u)374@XE@Jf=!>%P z(Gzt^6RBa~1LAsj9GWG2)U_r3g=9J&B{i_VJSt1{j)&dD4qyd8DkYZ%1fG$cjd;jB zGp#CoS5109G9Mn{fhunnhh6XxvtD_Z=rjVBbB%;~h(X~*250pCBAagiU=|5sjSZEz z!~QiLEWGGGkDV|pz~L!e44w@IoDX+4=Kb<Lq?=q)NI7IOI<$nVP>>A(>m`q^Im{5^ zzea8Z-mT1P^EzTd$kQh(8y=&q&XS-^5pi*oc_#$-TVDw3Zy2UP3V^X9Vj8|r--9vs z=_wsjw0M$|8rMw4-I-rd!Qfa7&cDN6+Und@KK>jwG*fVyE)kOn50awHf)gzThLxY) zMmhIfVy|;asI;nDo}|a*7*)c=eq33W2ys$^8GAASVn8s0_J=rP<P#Mm#CGcrCvS2u z9{(y7e9G9ZnmAMJape|Ig{0-r>>mibfl^Fsse(X)Ap>$zWGDhQ`bAV?{x{ukiqgtq zw2rErqf(XNC*H!MVT{5gzKIsk#@_Qw1%)?quLt+~sSv3#aTJl1K)fmFr6j@doNA!7 zhSwsyoTY+|7%19tH@g^Fnr{rYVi*=Dom8Vo%2XhF&W$+Ra9>?eFs<<20$-xAj*$GB zRLJtn4^|^I!w_mMh(4GENsUqzPh=>f6L^>)TAk`4jBRHwG&nc{Q$2hkN}}Q+40&Ad zzZBPB7Y`fyHPD5?Xf&XN^!CbJpdK22;J4D2Vq0pfm!ZVQcgGB%*M?zxpnP@zL*iA& zm>z~Q0#%%j6g)8G_ATEk!rir0O|mW(oV~z)H(oQ&qozz|L_HUkI?-)DDU8()gI^<g zb!-#%K2mCa@Tzw<9L6xRN?1%Fn!LrtJvjjrc>oTDMCcclMWpa7vUUt75G<OG9}5d3 zxW9;X7&^}iy!V?D{Q20;1>6Z*g8~H{X@ORcEGFb~9t^|;<{ziY<bY7AurGVWDn0UK zQ3iu~!dSua=d5<2<C%?2suBa5!uit4gSjwhb4%vSO~?|3^Z_Zt_KtvQ1<lN<C-{f> zb@D*AtPKgID?fe4A#qbn=k#g`90{S!IHDO!Z+1x>iGKHTA@4ltIN^;U8t)L$uYsSu z_(j-MWo5?xiqdL(kC9SbTjtCp%FH>F@Yp^KF-)}qZ3fs@46SSPN9?{Slw$?#m27aq zRj~ZR#+V9d@E*|#4A+?06efx}e9U8>156^C2$2gg5miyGCnP2zpr4cFwaI}31qc<; zCu&^v^^D{TR!_-9SmNew%4`M*V{(GW$~o%;JS_C)np^3A9+4VvIfL!{%$P&!rA&&# zt$D*?iBTs?1JnQVDa$8EUvD4w%EB1s!y$czhWa(2JkX9`%q47Z^W%qT)GiSU?2)2C ztvg}(ETfuG!n$97mQ4|~;2lmdu|v2L9sd3hIr>`cU@shq3^_0zf6$#h^MsUmuuD+l za1pycsW1*fb22x&_{tf^AgLX>Jh&kJn84AXYiNKRW7JnrwLKAhN*`B*n0q^Zz@L`n zhp^4Md8=^*F=8)C->8jmGQqR;it&9){b*Coopj88`w}7=u0mv1Wo!*afZ{>6x9QK9 zWJ3<iUg5skfuv`1;@0oHjsoqvwi@u%Emhr0wrz}6{gw;8sLx*zf@5{?u$ly>8<Y)Y z(8_1IDuxxFnX1|IJ&Rrnv<L_6NO>VqgX@WQp>LPBWf21i3)De_l$P!U&Ux%qkpl)) z-3wz|nguth3NB8d@Ul+SL5wo8O(t*nYRej7v}qK`4x>fK37!I&>F?-5^?fVp0S+)* zV5dUH?_MxG@Jvw}$M(7`qiLj<V%sZFo}cMs6eau-qGs2}lZy@kE1}(mw!K~KwXnF( z&@uX}DA>mz*_%{*h8#qZkXS<wlV8goNWCuET0Ql<Uu0m+1zZ9%bi1>JDX6RuVaEzv zLO875u*c8`DS=0D(<7zmKvjPkoZw0aJ{oKgS3i0NAx#-MfKxz{M#wO{Oado?M}f<% zSlH0Gpb@D}DYFOZwBe6~LR1JbG$x<@HV;`?8Kv>FunTfNPxGxs;@B7_dWmm#j(!Qw z1XyT49V$YDhG935C?;t&^Ui2J*D~HWV=c&-hE#Z7w=6GJ!Hb&k?q(LFz<g*!C4-l^ z_HN4Hfpk1dlWQ(_u_$IDH_}8Z;05?Ag!rno--Z=Z!l<@@Rj)Lxfc@8V2|9n!BnlzC zy>$I7lRr7B%1&pwyOr#>-wL0vMh=9e!@o%C$`ONk!yzP`4{{(2?h16v$UF^bNSL9; zX$I^M#l^SVm8%r9r`Tw%X5;LwvC9jHM%i!Z5+`S?=u?75O32Rz8#G{?3W+k)3?Q+B z_%hI%<cYtLPL-My-<f{td`S*?7#xC)Q5RAMruW%lo%KPF^9#A4zZ6sMHTfroH_N0L zKJt=;peCa-*fpYPQ}6_!7E4G<2|xm&y!c4YVamVYu1IN`<TEG}@zA#0^dXr$9z%H` z$s4yI(<bkRPvj})M3}WDXKUgbgD<us6B&aOwK68kAN?Xp!KMEJx)Wa(ZH-Jcj#n6~ zpb`iPfFYYj<zDtpBzZP2w!cr2+-aJ+OKXQYFBuyiIV#Mj5&OIC`5bOi>{qWrbzFFU z_?<OBgb}N80h8EGz>G+E;g`f}1=O>-z_sIj&hCLoKFVL>V3Aw+=dx`=M#cMp!jXEw zESz@H85X}F%k&?X-%h!!gz&n$ZtlB|qVmhCR;}O5_38?tPV#zLYC9w2aD>-{$w&*p zxA4Kij{^o4Aw!S`;ke*UHsis+7;Ci75cxz0V*GM8Ivfomp__?0{vFTsPKn7&85J*J zll)tTi+k2EVM_iqN-?OYuDK9KnM|ZJXv|I@6j#8aI-4D1TqdpS;pD!^Ofpi6Y$qR> zw)+^0hGS>+4aiA{WF?5gi~sFp=R2PX8S=Qz?lQAmrP7g*H0;A=QiWY0Q8H4Ou)&-| z?D1EWvnjA!<LN>u)71Y5Q$Vc01!B<P^DbUSKxq$Ns;Kc$DSE;&0+PTCe}KPGMAn4= zN&12XWW+))p3E4EYEf?WhejqTnHNz~Sg|RY6M~q&(BPft6oQK~@B}0zg;G6;ZeX<{ zKo;>0Q9s3WMtp}%<n45r_2fzM3Mw=#LfoZI6@hIsNmz)M(pb4MVY9W(5;s~TLFWu7 zx`vfRIwrJRsqqGy8s153#9=as^pOGz&mo>8YMIDka->HHd{5*sF~b=nIwho=Xk^|B z=$F&#*1|y$;nFf;kRG8Dky_topHhP#;zpD*RoRdm8TkS?qMTKhl~OY3KB*{d<VI8~ zHb4VwkL)3|y<>$Te1UvCqkv7szKdAn0cwHca^FT(&L+X@(q=Z1vy4r|b&aC12b&l# z5J>gOO~Vd_SJF*p0DLPB9waICFnEA)av_BXWdc!3c=yJ0*au=(!;}m}FR)J~vf&-6 zIMnzC-GSfS#Mo+XtI9*BiV$!=W>&wE>YRUyyRI6D#1%*9>hBzgBx2Zp0m8UJeo70$ zD70Yi3Z;>*H}f|jf`cqvX|J)%F4h5qAaqpoBVNNflJkJRHhsLnQ;Pb7GDYQwE>k_i zYMc^JeuUpRObJysEwcvEWgotpe%KBgDh4AfibF7kl_8i6-;NZn^>y1&KtWsmvn<nR zbJf05%e(fOJ`zbA-D8M+G!f0NUqplJgeKj_TMISvw|x%?HEN)W2IZT5r>1s6=0o+s zuU_n)#jeSC?Mx_;K?yd?WA$VX0qarfPW3nsVL@>u<SOc+u-dY~efSDnR_`(rr^d1v zOlbmDWRQlFvEoi?ZBmZ4lm<r&3+2eTL}t0xc^Po@L0(mvN_>vRQUMqxv`j2P)Ikj6 zjBh285{%S=A%T3smq3$vHE)2Is8$Arw?dIjNxkwh0~46Y0fg{r43P>7K_j6Ag|0&c zX%@AhVzNTaI>Yzoz<ne!lqsFd4ICpv#Dh7;0Mir4m{l)|9An^qGL8}KaBX4X^oeCc zF!B%M7`e*lM~HqIM0qe%j0L0uGSiXN0E%>Lv%(7@trMvw9(q7-B894eLDY*tbR<t# z$U(F%GTTWN?IX29;Ern<ED?=8Yz(3R;9l;OUsh!6L&XrNsDxXtR^>t9nAB46+|t6D z0pc!0!}+t8S6<3sKu<w$$bh@GMp}he3OV6oqfT$c%g9317pDFwucCb%*1#chfrG0H z7f%&5XQ<tm^P2QyoS!hPCjB(&CxWC_Alm;eRxoNJ{bW!zK<KLECu}19sKL@dhxF4K z)8)*qtPnET_ax-TN{UE>SPSx7<d04b#`{5QwTiLksMRXQngh_aKuki+JEp;R!f{PB zTh*76*QL!&0?mcWSW^@BU=moo>8xCxD5w|heRw0h^TA?>Jc39<n{ov~yW@Z+R*6Rx zm?I3*k1%hjUj28Ow-DPLBIQv`SQGUoZAJJyP;V5B+Ay}r>xYC5HH@5;M{ZWt0*?Y~ zQ`G<a1oMN=`B)GubWRk;xhz(|31&XcE@a4ZpOCMu7F#6JtsPa={d)x$K@N@8B_Bd@ zVb!?hgQcKxQELhw6ds_O#vX@w+?UFY3M3<N^>Ha<mSS1nDtgkhN%1CUR_U@xi3?F} z1TKB3a9=1aDV3%8&Et|tmRRXN4Vh#XWDX7mu!d_C!2x9j_{(wfIEl5wN|PeX4%a{n zg(|_qyLo?-7W!nVZ1t5=+10P~u}9dV%?HSb9-%m(>gW~)kkX>dC&rUTBprLz_#)|` zE-GNua1&eoA~rRs+O_&lwd<nF2%wkn(O)2q@O`^F53wM~6;TKO4lsVA5Rm}z9}<}~ zI(Mm+Rq&6Kkwj3d;X)`%u_;gk|0oIL&jSD9P)_q>`Xw3U;6IT<Aul}L7v*8SfJ`O< zAx7BNNI^!SOb$b!KbZ=^7bdAsHG*eD0UlIP*@JW73j@tXu+Kw7fgD94JrSQ$G5aC# zg^D7nt<YS~(nF^z(-jho;Y)d04C+(7{w(BY!%L-ZJ((Dbv(uVG-4|E~YBj)qgX@zp zS)mK5M08>GRy#v1jsbuuV;irgL)bmyCk>HCIMgQ=m1e-K;zTAOk{R4Og((9Dh7GM1 zLBhWRS||n+;hasD!_fZ3f~7Uo{8teR)oZ_Ktd$d4N{1H_^r&Y;Wp$JP9A3e)eAcuy zvL<baCQ|<O!-*W0F~Q*mEZ&_K*mf&WxIxrIku_7;ZxP)kz%L4<X()II!Xi(%h<YUj z;f@^QUpaD2L@u5}9w4r^CabKO(pX#QoM7Ze)TIsilEf`QnZFaN=kK)|d@Oi>WRsq0 z$cW@AUm@~~S+qjRR}C5r=RVOGg&D%V45A<s!xL(R<)kKx>G(3ABx?<Rh|&<YCL2;3 zU!*j$Ts~@%4Fa+ru|zyp_J&jn6e$?@Hn3L=b9_}=OyE#J@K@531|V6nURtHaWR?is zn--&ReMlq#iK)qY@P8CA3A~cT`O0y3!daQDQeM5CPAii+6k~1l5RJw0hKLpE!}`no z2FW05h$I3&iTb1e6MPa5ItE>4gN8NOpPAybHN*;Gh)41mm1Le&gN1~wMuq&Y!9vo; znl7GcaR3Ad(i<QE0~O41UYU($EyIzN1^uMZSp~ULI9dpn7(AOv1rQPhYEM<^m>3bn z(1oeLbx07ic!5f4P>_az!_=9zC9cAWrzk%opf3KSxn=ru<c|K@Eoj*%{_;=~Uw4B? z#|wE9R%3d!kocmqhM1m)pdQ_yozdS4=+QJP<8r}%ft$hg{9;Z=Nadl)%yd>W6pGXW zOe^d?1Ipck>sBMHTJdTe3chZURN{TIY9A~{3Wc*uVLb!XoME7vk<>(>T)vUQqo6IW zU=(!@6!1_C{n%|9hU*d$@KdwEdlnfv>E}{&T#6`aG#X4+6!1cdGdOQ7(0t8($6H?E zRg0QPjo;;&eSj6J;j_?6D18K#!6ZntnwTmSAiBifMpl_#L~^n*4Pp9lsT-o+c&a~R z%W896;8Q!+Wi}zDmf-rx@uInaP824tMMh*1ikOZDqEYi2yVjd%45vjR8WFe;GOoiW z!7>ujJAo`PB&=PK#{bX|BgL~=Ix0C9R#Jf~BqQLzR0RZsdq@rRDZ@EggmVfY?+w!J zIP!@y@M#GN1Po>XXeCT2#g1bw2(VXkWKfYxa8jlPV<fZ`P_7dxPziBWJVY2-fu4=! zOG#u8kg%FaCvnjM37Hv?iewF~NgL^bI8EV|kb~B16O(_9#d%6mn?!biB7LD^d{L+t z&6A7FX%je<CD5B#nE(^a8QiFds;|+?ZBlNSR89IJj!<)1mwuWfgr_tFvLRg&?pO6B zAq2)}Bw^qeHQZ30ClyvnLLsp9Phklaq?N~cb7vgd%LKw%NJt++*Ce`~E`EY8LRv=x zGY^!%Fo=GLssreUyqH=RoTL>7TNJ8_G~5dBt*eU529;Be(kA-B#}{V&mSi|++44L? zs={1A-57W$#2BId5Bvj;K$3a2Wu16ZuN!Q1n*d9LbVG&Abcd*|3O_{FS)!}5AzAlD zvQ7xRh^WP<b(A%RAH_R4sIEpI#XHJAR~;K6p?I<ZJ&gmC;$d5waJ??C_Bjs8H2JNA ziv$ZrXo_Vcn6wBvMD(Lg@Sz%{Vl>==MKp|OW}N`>7kDI@O#EuBk5&oz{LZmHVoc|h zqm@Xe;4Dxk6t=}B9YnkmTm^p2A}NQd2*|RyPxJ@rp3jz>)?X<%UHeLZ@xAUfKt+yM zR*OmJd=Qa6xZYpBhHw999Y1GPI%rTeY5kpQ(#3T{U<;5hmjlArl2&S-5RFZ<DvFjA zC&dp!(F{;@2%gXg?otabauSM<WVt%w;M7nNOZLOj=%xNF9IY!CjZ2+}*Z0BE7Q%64 zsAiK=6g)x(r<D%%Cyhm>ajaQufk%?)Sq+}4l#+&XWnu;L^3r=Fv7sBCPX;RO;~O(= zr2As&?TmzjAbk_24>`J7q{+ggOl9#lGVc~eSNiNdnSHLO*pVS@tIQ`y)~pbj(2x{* z>8)94I5?~XvR7>+>qKz+<BN1ybfNQ-XcG7)aEShAa2Xcz@7Wl6L`8)nL27}}3T)u` z_7FmI)}Sv|#=-nwh03f7m9y$RHK>f?t_~H<O^BV425;&Fl|#$;U=P4Fs*-+5JWk0W zRq{8&=%|DGAZ$T?3Sm=|NvT_`x+ZOm!-)}FoWu2l=t-U~tty8>;{0J5l~+(tiXmxK zK#7G*Iwaoh6-hXJ`=E$PbD?3)5P=u#`EmnsT?QYrh7p-5GvNIVRDQ{Le<o<A`yk_i zLM5Ec<)9SBHG~W#XF$~s$uem;HdJX=Q!rJaF@_3|5xCJO{+uykdi9-t9{Vm^kIFP& z?qt%7HGg%XdRb+Vvd_-Ov|uDvJ_SW7lb#L_9Sb~3xN8z+MOdRM3ngtD4slh8hvb-R zh)XaQ=Es>*P*{}*h>oJJoHWLvKxL_<yg8I&_$Kj0YYl#c`moqZ@*iM6;I=JY5hCV; zBIWq6Vm_o6+0bUxhpZIu&jXdxePrQCOW|W!zeTDLvw^8X*hong;%i*M;Gl+APW5#4 zDxwMvtx21y!r(jvp%9HiOM`a7j)E9G1y#wgcQYC*@J6J;wrU~@rHW*0xy1y-TZ}{n z76O$l_9Db9YZ?NTz}WMX`3dR?nO4!417|qJWpL9OQ=+1{ZK{DtGA*{>JP=8lKt9nT zN`-5ItAQF7NDWHi;tq5GL{I=Fga|I$$)O~1c$TKi*Sxf(j9HNaR{*HAy=%cnJes*x zmhJZnHj)ajPepKwN6btJm({pw#P?P~00}s)io3#pl70GQA#44WLe{m<^z4(ucj4j@ z`ZdN#LfzGPBjf%n8upm*jtHiDy=gtD-n9Nsz3CzhD0*kUd|g>=&b#EJNgdRkMkGIr zccUo)V8}x!V|8H$)rFDNMEDHI8)xTmmgfvPL%&`KI9;Mf6w(W^4pf9$Hj7`3MrAPH zu=z`6uHKy#>6BRX7W$Q#W>4kWMD?XO+_8tb1azcH7-lP>?gon6g^>!^cu|fo8H)E) zNnjcXI<8o??vXKd3NSHHDm^=xAPmqv5`-9<hXMztC=pr`gvk61;m@YH%d-63KKXp^ zpSCLfGZ@0KN8<drL${tq)1zRxg}oWeMk++}aUkPp=AWzVenDfXO*v0mVG|h~!6Jl{ zqv9CO3XU~uAY}$qlyUbb@P=(!mS^hZyI;giMGZwoF%XA6Dq@@njya4)OG?VftpS}W zLP;^B5PnVoMbaYC5B;1mTq!K%1*V@f9A_A_27yoE-sbIzeg!Bw_z;1Sw@ev4p>8$B zMtil861KdfDvG0<siIV(DHQF*wzmdvArIYJ#E6>8HO({&{ecUfKfpQ~hHp>&YiP%y z+Z0@)OOcKdDga;;iX^H0+OleWpnpXk-+z``<Sd_2V{x8OO!NuY3rd^?6iX9+i$Xza zOvf0TFxdi!Mn_cyfSe#IE@~oxshFn|NyP@3iffEZsF#-RG~+dCGawJS*dXMJ$(pb+ zc853{RaD+dV7y)_lhkOTz^7`owM9%Fg77DbrB+uy)z*X`BCs^4RoO6h=Zg$h*hWFf z2*;(jqp&e}N2wS9#;egg25bUlKbP!<F<49k4Kzv50zgWp-S}I_=x`1+i76O~JgZ7U zGFPyr7|SAfATWf<x-A74P{E^_P{Zw1;WXEzcl-`Z%HsEq-+}zflBhFL;}_R?0SiJx z$`uaKiEdpJqT7o~b3e(Ee6kF){z@6<+GqaqS5v6w0rC_HDnVC`!7&c1W_NPI0L7fF z;Ht_wk^zO5^>+#_7g;O7ONS-#X^w<()EtEiL1GXNucPRM;YdTGOHYgq5Ia;7G3XQv zMOVB{DH<R)l(^L4Y7Ued&;+sn$ci}%xS}*WDvL3%hF@pd>J08llHmeP6o=}tGh}3G z1y>*A6E?=+!1%{*bt16p7u<WRQ&yQITuw*FOCe<qoFMWmOgqPsG9p&uksw8nf(_kJ zUK=G_#&^n$$5@~%Aj-rP@d9E6cB^!DryM~~ec8w&uqu)jMNn$Fks-0hAj316!c=7( z2im>7Al0%t=2=j>{P;yyM#&l?`#fr;fLft~2?|@0T2@gjMxIIlYAwfEu?&}1Q7hIo zL)2Ps+I+gHO_!=AX=6Z)jKvfKHH@n5tKy22lFNZ|#P}M%SXo;JsxE~}V{MSAGUODF z+8~lSSQ|(PH<c!MZ5Z-48;CR$Ve1i^5mJU~Ty4w7OKd}NDw${DIt+omzp)YwBO%$2 z=20w?sU}_?LSht-@uShL0gWl!r*8(eEZ|jD?=Qn4F(SsX_shct%^spsQrbCElX0>X z(nwKF#>vXmWGuVGYK5n`TS777D(obVv}oi^pwy$prNOvD=hzn+l}u@d20wu589}8? zzlrG;VEVvp;Cp{+kiIJX9U#5o`Os=3Yr-BuDK;*UV2()Aq+=onh7wexiUDE>BS;Aw zGX}e0?W9DF7!oyUGY2NK)FbzTINiN^`(%YaOW#@zz(G4S#^11p4GN!%cP~rnYt>Kn zTcQ$_g6_lgW(2t5vY?cYW3tMY`{k?crx-v92TYK<w=fOJ3hP-?Jc3^30}u$Q>`Wij zl{bZWx{rTh<;{xh4lApl;J=N##S2YF=nb~Gmb}kbeSoOSpj|9qs6%*4mW;wRA|ITd zOC&-y+($9hi<tP$!hM3l%z{bIHKl0Bhl}nY7|6Y;Xd<#G)cD7j^srJhre||0Jj;R^ z%4C&3is3$PVO2@R-!t6DWVw*arZ(kR1Xch~srgy1>XWsh^;c>`SHAI=zYdYq=tdCQ zbm>!bfgs5m$fyAYob`7KI2RQw;_3R;0?rB{jhJ92Re;m@$^Z$K<#a7$!dnor`fRv0 zilo?7Jw_|xEtwUNiL_=4YlN6H6!2jaApr$s7~;ekgtUUir?CxCjkb~Kyd|~F9ej{; z83~CHIEdrBV_7X7$_6uhk{h6eWC(i55^M4+$S5ib(Le+us&60>NP=aYm_TI1QVXO( zV5J4YT%Qg+p$<h+4JHlh>3F#1KZy#Y`SfU#=fc#=+GO`sM<W<YQ)2KB*;wwy@>m<Z zaTNql@DRtPakxwjc?naPYG0;}nQqO(Hg>!jtE5;Ax-!ugakVAzwXoxxAUQQ~^#I<T zVBx^CDLARfBY`kGz#AB!SKe6R5R<rf)3x4s??TX%WKc~Pm!AO2kHd|#c<)xO1*WL} zG6+9J^jSpaeVOPR$!R`}IuXqWV~4M&g1f6iexSmS)>%H0ae)6&mhUg99wQ;+0VYl3 z%`RiaLeM~2?3%?P7GI4(Nt@f@>v$7fNcSQQ2P*(lw0S{uu(BXoc`<bAPw_<2`=0|o z4erN+>`Um4C@m5Dry<FLgoByqbe{CZ3DVC^gxmsdrQ$Uyfhu{tuwPSSJ`)UkyCd>1 zf6gclv*i`mfYa>OVF(@|aAQ~Yky0pRUx=8X64V9L84;-5`GK?FVktnlO*{JxG{IPn zH5I}k)%+HPR2)tDEdk09#MZ@Y(GzJ>mwt$PL)Q}gdDI)&5B+F4ks_78LCe`JT+6Lx z(j;t*w6XEZO<lRA%h$Sx1D1cPQchAlC<-`4ZKX)rYNU<k(eSGx&fhE2hC#{^E8LNS z8rjG}7zq8uYEB3Kf(5TSI#m1>#6bx8c_}lp7EMD~g;4ojqiI+y*H~x(1mS$-L^x9v z4<@Ag(WIhJQV?IeoC<&7FFy;o>`WdGV;$y09AQIE8d7H<2JjExxju@gS72YQP>jzt z12$KTgb{U!n*gvSrY7wPfHeT%(v;3_Y^7jjhb!kQ$tDm96OtH=sv%sAe>ty8{|x-g z;KEV>z#<FTu0%;>kucG0lBIs9DW9i^bpdW3Dq3RKxQ#hgER==8wlRa2BkPpqdc>;M zA<3T#WSx<iVHSvLimzIVnB9Um2icecOzF6gQ@SoI+Uw0Ou~;Jqlo~-!-guc(h|9wH z!%n-VkRnLt!l5$2&xO;+oi#`*z(GtiA5&$EiYk%8xu{7$hJvv@_DvAX1Kz|t9;&1& zz)V?&hJ*|aNPodqr0OV`Ni6+yP_U+%)LEvO@Qqg|HUzX7Sc*K9m`c0H1KL>dI4mP0 zPyk!pwULs-Fg0>n!0%9GVZ}R|cqm<E5Il=JnuqP7aA6Y`>*I5f;=3ncOUJUssb#dK z8%ZY`ldVDxDT}uhj{^l|i*Zm#?JgID<tRZH-h7#7;I#%n1P-mP$%f$Yr@^6iQ-TYL zFlWH4ny@iuLl?0;fhGuHNlkkU^ti=7msoO`1doiwUf7sm6)YlUc)q;Sy<F+%<pwKW z(&j(c3fC59hGjp;1^%KGeKGGtuy7#7A)+xWJ_I{Di~vi)tY||w@h=45ja~9Dn7WCT zh#{1N)(_Ce`XU5~D@i_w*l|8L#pwq`rz5@^RG?|L(|RHH-yx^~YKXA1hKRBnF_YnX zFIKFrl3mR_j35nha}q`CF&>J9u)z0;6j4=+8c4wIca9oRW3c|p+fcL->_;*AXUoi* zuauds`u_bPV`%36hdb4M#f4u!P{q{Cb(lf*V9j^x!FoSLB>%%c|9mP6o;n3|BE-^X z23=4C+JNsrDtQfepLo<#3h@~xSnl9=%QS8xmTuU#rmVoua9muh5n@yT*bG@#vG7I6 z(xxIS(<U>(>TqS+OLaa$^9FZ&Pd*_?SxCS@2!NVMCxq&pnLAwtXS<H2I{MbG(0`~q zJ*=5DJ2nrc?_IkB-R77Qwy`rjhMeYC3THbZUSh|=WlpeV1sEL+dLx>ad%7qV$JA#s zg^C*!@2Ud)UM?M-bIU;Jhw_IU-y9W7&xB`lX}l>a`pgMpBy=pc5#b9qcjDDGVX&=6 zm_Od&#RK3q*pC%sWdI^loF2nv1~2>b1y-?|^pk`^xIqF_1{m1Gb2>0d&9!3T?&Uw! zF`oOynZsQ;6(wFw8iJqF1=b#OaI_e{nn%FUKIAD<JK#9V8}?y@IM^R8Gw-Wb412GI z)S6+)1GF0rTDvF*nttxoMMfRQ0?JVBEccCbPI2a3+}I>g0327GqHzm_z*Wxsbj@M` z)=(R%2qbU*umVp3&<h|ayPYn_Q%FxRWZT7aoWv-mU<@M}V69kPlE|9$BeVnM_y`}; z4u2Kx5Vk4|J402Fkg&lgt)aNTSBCa0$qKc7{mb(lO!U~;z677;qQ}nuRcu*Y13KTz z?rEX2`)RYS>%}s!Gmp1w?dg24{wi)<N4t$eA{F)b9{egi>a|NnaX;SOteO)N8k7mv zjty#s(-7M7xvUEGB88K&aJ$vhDyUnxEYGX(rRM-&8urb+3LN8S0d4T0w0dSvXlber zgWs0q2;l>~q&ON}S)Qi|R~%$<(kv1nL2)NjyT)Q9Qv5e(F|td+wNXEs-e5jkuGD;~ zTxp%f;HZpkW6{z2=H4@dijJCZ6&>~I%|K%CM)mMH5+jn=GTf2G@C79n0`Ro~7bzmt z8H63%kocQw4LGT+lun>jA}c1QVHfd`RHw2;-m?OxuL*{60<49X2i#U6|1G;iH^g8^ z8iS#%fd(2wC;!o48bbn&QTD5Gp}G*XZlKD2g~*WMSq&h!Us?dc`}j}dF~XXO(_^wa zTC!SoJ&TJ_DKDTY={8=on9x)mBE@1g9140+WJxhNNF@tpIk;?C?~%yB>pfQCk_9gD zAvM_I=kRRsy%@~QQAjHQH!VZ!ow0mS&_(4*`Vr26VIcK&&H#2n<P2~i0o*^MA&-dn zWepU^(m#hauqMloU~b5;G{$6y>x45uCdc6MCuoD@RFAZQYFPC^8)VMRcw<SR4Vuht zC>nvQN;8u24J6%k=ysB@d80_CRpc@Qp0`M9cqJSs!ObZA5Uker4~Er0S!E$E*9e_O zGDnfH5ju0IzVx*;|Ju?nkh5&k=zyF}&&6FJXWGb8aauN=`9f*DTFjK#))eJT`(azk zWq)kzP-7U`p3s&<7y$n|wDs@dYa%dNbKw=m5VR0gU~6ow^Z!$@wgz1dj!FByp=<Qd zixRwIb~G@W;JtUxippmobeh7*hUoMg=rk`B>DIR&ynzt)3)Lcj45ALG`DngV^U;G! za5OWhO!DbScbpGwV+|-9uDaCdkU)1TLmDcwPdHc$Hr7x_*}Rp=W14o0TlSh!ETx<i z#O|wjnPuq!<Ed_-_X0v-kpVwEcH}`7J{hjx%#ztE1uhxkHC%=O5_10!#;?4BUy)hB zAg!I7U?gY0bQ99rl?``-@_zW0)r5Zrd{s7|9MdoUH%G5JlHD<D6|Hd!v2Gp;X5r=% z{ffneYzY_bVLLuX-G*FdgS`~hfL&C;pE*>T-2_P`!d}kkj{bdFewbFsuC{QoC6|Et z5PFT9H=@_9vV_eLYJc=<cwPEw^csWYMFRqbOmS^PMu0#YsE%Gm79{_tpjWq8^DA!| zm5kP;4Po$31`$;xgrcOfTizTeKaePn_e;E4kXDl((1wV(RyOR1vXZ`}95X#U?qs;U z3kQz?vP~FN)}$W+p^VX=D&H>wgoeCTiJd?-6iO??-vNcn>{3R?46Y{-g^egQWddbR zyNcoYnE++k%dEv9r)m!WW@*DYipii#4FMsHQ%n8D;OKWw{mn4;UjlMIo8J4C3S-qA z-V)yoNaC%91UP&%D2?|!WyCyJ2qBXYuka0glU1rU!MYYGsfp)45eEn)I>u{&KnYWm z_5=hB06_?##KsV_00?XYAc#yp4HiE(>uY#`)2j5(00d#Z#@Vqfi~sBG&T_D}5`)SJ zc4x(e+TckcDZSgDNwJn24^oMwaT7(<%aJx$;PMTx>`qu@zQoIdZE44HlG4f<@Y!x( zK*c+Q5p#5(^?)$Gg%|=8s&k{7m8_WB94%y_@rr&JEg*>cb+DkSU;)LZOC9huz&X59 zp-7y+?zs?R-oFkcaFYC=1SFWy`J`E?YSKm^!DIdIa9ad5nAeX11aRd%YuX+W3S+R# z^V|NY%zaakxi6vo0Y(M_JO=(w@oxhdzZ)x8qZ1Ur#VWU|_XiW`(z79$_$HW8JWE35 z8C$7%za&%*fPn@DDsdzysvi<CDI)2k-YzjIBN$f-7FS-O$DFN#S8eojiM%dSW>$U) z!VLX1gZ(rW4AbPNsmO+YnlC^Y`#At(|2FrG?GIk;H(WE$tb}_n82jRNTp5K%VRI`I zuFEF)7zPq8Fs8&(#00A7UkPzd7W@8fZijjoO43-dRD3W}-4TfozF5f^ZsS5$sDZ;@ z+h9ZD1WG6oAZuoI5loer9A-qLQ?rW1+@l}QkOUl7;y;v!?*0gYh1`bfAKB$%8WaM9 z38=*m;(|+mXo6%|O=)se7Ext-7hLj43=YqDDC7J^aH}|!+uJo0i#9<ql`IER#l&0& zjvL#s6QV)NRKr#X25G((VsfX1dMOOk&9Ur^s%${NQ6d=+U`yAf9|K#c4&4u+t)MJ$ z1T7ROieL*nW}tWxfszFMF6y#b;iEqYY;m1UC}X@q+6=bheIz09He2~xA(-|PUK^8& z`~>vOnvM;yk@2F9d!@9Id8*LqkzK6lt83=9+enp5a9ppvCjAK1a{BqF>ckGAR#;qd zY?T!a!bZPMwA82(L%+?B`E8)Yiw$TASGCp#iot?nO9xrqag(UMq2uNosOPg4VC+{a z!2FQo#ty0gW4}`Y#+&yLA@kJ&Fqz*bhQ!9gm8NFtB9jwcEHDTU2q?W!R?ML3ju&rz zn^3G#Qn-NxoBS%k1s%A5LlNOp2Lz%f{Sy!Yic%@1jNl-Z=w1<Jl`E<+^DH5T!vN^D zn8SmNY8&s4MB0i#Nze#uDY7GCrcVqxq{u=MV3FJM))J>maqa_+E}<aB`A0S(TZocG z$d<%>i;z-BF?*;~%$@25af*P*YO&Ki|LMcUP8mZfOkc+fvVs?|<*qE?g_<$v@B9cm zD3orJsxM%`Nq~P6V30IVQep;Qt1W46FJr(E>1H5VFxpj6u{5N_NPI1pfqEU`(hZf^ zCbYF8PR5&urn`A`eQR+zy=1t{#$<jL@TYPWvf6M#4h3G%Fmo#N7g6N0{0W~=Xz)W& z<Hs(86@WBC^=64V{3_DOjH2HKX&9Rgt)ST7ZfuT@bEl34%9V!dSR!#hXw|~~BiNr9 z7j1Crpx_P$^%N0c)mRGEJc))vIGM5rY*a0*Idu7a$K{g&oD9U&z!8Q&4L+a$pS^EM zb}Yx0+)8dB!ubCzpjObMdgGq7S)29#XMIQlpo64zbtPp*MwCVwmbjA6hXetK!?CJL zd}=;VWk26kj;Oy-Iih~098q6VjsO+ouD<zP`U76iGZ%;y_CU6vo#Q;IqtKkhsnXCr zrqq5I(~fg*>L|F0`n$Q}+1D~ZDWFd@jHI)am;t937|5qn&cc|i);mmJoOrNfgvgv` z`^?%8j1oBHdZ4cVb*{(LHb!@*&B*t$g`;1~*as$MiB9GmxU6t@+{S+;4G)M!oa=!M zUz2rU;CIj<brW!s@nI${$q(#>%<>YB6(e!6vp`oM0n8|Cr-uhz{NYaceIrOjJCnA# z5h$S58^J|kA`uLLi6loPKCucVd{j7o9J)Icrz7iQiCoOP_1lRYqaC6p3D(HDT9RUb z%H()_qa6<+=6k7J`7bT~kgJy0=H~$QX640V0x9&)F8DG<SYOI-3Vb2wT0B@06anUj z;9z;Gi_HBnV&&Ev34yc>g`{<&>Oyv@Ze6RWZq|n~uGu*9Nx5E2xnyZc$^~V2FdmCL zRpb?7ep7Mh#-Q_0ap#=-e2P2&k>buX(gXDw>4CRZc)pMxsIN#5bkSYTaq83jHtc8+ zH$zw@%!1#-erG%$=48!m^}sYM%*-iWkZja=aLPQ_c&^=W2>XTaBC_~<JO1U*6Xj)L zvvS-YO*+N>O&I52&BvO8*JOv43k)t}+ro&?UDpb@9r!y>tww1}pCI!0;Z2dhSG`kB zNDKP_Sc5qb6>z@X7SgkPb0I;$Iq1;vqv{E4SzbY->cu64h1jx9!O$t}bx2{jA(Qkx z6CYI$%dKaIplFLZtc;j1;V)g8!VK3%ntG3bVPK@X4aGSpI{o*TmV+h3R*~f0<iH!d z85_yb_24#RxGk}gCjpRCeh?^^fl*sf>4}8gt3I5>Cm}_B6;``kQRN&7<uW8apwlkn zn9In<$d?q=1v}bC1bv+I15R0L*&frh-pvopB&58SALOk2aC}CEmCWGQq0%E{TNVR^ zttqo815FDDT{$e~c)w=Fvb$uu+$`=jK~c`9%Q%n~{nyE!FFb4#_Kz2F)yh(ffW~{C zW6z!a0n-G7{YWooLh}nB$vc9}WwkY}(GiW8blOY9dMocJ#K}J79dk<@^A7Ux*&+$E zbmB$J9s-T|LNz;C^ns*FV#v$wOyk|e!%Z0R`NYE})xZ;~ubc5$>nSi$AadSzShteB z#<^_eP#Ec}sZ+VIbz2JOk!Bu%(-m0^F7%*uOW+Ci?<@4kg7_4AZWVf1B3ueRYx;qO zo*RkTr_S@8MChCH1oattg16OqzK|!VugDX$xK{WG^~n?n<KV<)=0J(P32?$!ZXqa^ z!+tyWo=qGFduAPhKb&pq5+y^O$Lc8g3J4s6eWL3&lwKWbPI)7td!|eU@$JG90LS&J zFs|j-uAE@+;+Y9wabdGwVNZ__oJ%+woj83h9gLLl!4c>RrF51W-*uM{SAhccGdoNr zCE+W9)fjFkd?AC6Hm-1_Iz;TEDm~GeU1<zFOpf5&X%Q9IdG=CH3#i6Z%wbELXSz3W zgcq|tp(Js-r<A9n@O1o2wP<fex_rzs(Hl2|bP9RHqp)GQn=FMMnj!1J>fBP2iPaxA z!whNx&YLp*eG^&`Z|e~NhrE`;R*ZQ0#vC`{)rebV>1(LLZ`Q~1xml0Egsx9Qxv~-O zHl$gsXXYMjS72%-8f=u$U0zqw@4VUwH#FG7sA`soZFbRcRg()dDXtgQ!ZhyRIwoyQ zXxqdk#C9)Z3!rlJTE<q5ZsrLV+s&#d5mL3SV#%>W_3zm<1}j8<(w{h`2!~}aF|ktM zR61)0<UZ_F^R}eF;S)y8i_DyfK5y2CQma($YHPq-e`85i@~gJq>etCsT?w0@H>}(c z*1W4FPs5w$YE^2*wMfnl;#OvA9-hi+F{~A;X}p(O#hD7fkXq5|;)fgOfrG|FO{dJ} ztri$OqxZco#UG8ppUaK4_@goDq1rC{g5<uvk9}6}qS&oN-Ivs^VHf=u*PJpYS}k2t zX_#j#c{0BwcS;HFM&9=+IejD3vgUh<R{Q&3RBN*4ewx*9<@rj}6ajrU$wG#C(jspr zn>%TTbun+&+=Y0%GAPFBky8??yI>e5(gIXVSd;}QBk>gdqr8=*9GQBMoGYtUQjUU5 zA4xgV2q}HlIY%CegNY;^SK(KOf^~~a{WfC>l8!(s3VzGYAm^CV8eU8~QqYY=wkmL( zX9XLs^1+d2I8$%auyhjDk3%joF@p;}nt1g|?wk=VS~BZW4A!5dkBFl0jAKg$;4G9( zg6>8Lf(7{X1vnNMZ}p{-Y2*rN_tdbqOBWGt1Q``C^(7lN>tp#yK}=jygI+js0XjG! za9gV?kc~KdNJqF1>zOu$nF@)#Q7zTPQ=&rK=Z3~x94onclq`r;g)NR7n>GdOPKKgM z+_*0*4@TuqebBd-bVRIoQxyfYKcA{xdm!jGq7aMStcT*#^|E+`oHucKHT`{Yd1)#9 zb&tk+=2Yc~)gHE%Wa0&a9D&0|Cf;y*<YaQ}7fo0*(Cfi+i=3wc!qwsiS#?H&nnqBd z?(lS8mbWi_BnOHXYxzRe>>M(eOg@#DNL%kl4ipOyJlZr1=B7Am7K|-XvN@$dR9i}? z+&pC>we2~M81E)P!NZyGYyuRVezG}lwi~6TFo}`;cuwbm+w#XTa}JEvV=kNxf3M`x z2t4r-HLFXC8c9drb0e76RrsTk5avl0I>B*TZ9B;7X-v}lMhw}#u=3wn-corL=1yBm zhDq0{y0zAhKIN@vlCJNnIE+vHq5@a@@vl;^SA-n86efc~_1PL%g|DmJ{~ievH31+| z%Y9SDa@v7aEIzhtV0||DY+g%T3C?t(TydD53qY7623oo6xBwZ&uzFq@Z3fqZ#C~Qg z)HWjRBatO|l}{?+??bkks@tr&pE%8`*d;`%Yq=<O_@MfPD_jEOgi~vZlVmb;1pTST z#WRyEqMU{!=43~CM8)uua&pL=Fd?-R6I&Y9<c-QWDIX<v8IS-m<4lylWqYs8Wh5PX zG3CrU<8=NWA4`kb6~oMU2AZ*4%kk-TsX9fgfTD_rFx2m!5$)$JFL;i-G5V=e0wbbN z$@^ZBxI4$gULmXAD{-pejl0Si!|?v4thH5sAY@N+KV(J8agkw{`q+$)#QIP^8vMap z+Gn~olnu2P>sblU(4?+KcbqcW!jJzTh375zckJy@rK=tE@5PNUJCk^anNw*kQIu%0 zA!?Lm+oNW>a>2^SU(gYFBVV<Y%}xR#=BsvPh3@&Pp8&{<`KryjS?cn5u!OBBNk+<7 zku)6B8=9qXE2c>|W0|+Q?<YwK@?kp-WAOntOq_Hx+NKsW;JB2GBjy@peJHI|ib%ZV zgBixD(1{yjSZ}43K_0^)t&Fr^j-@s7;5FdUP#i7m%<WRR)h1P!@P~-9HH-0XW@-Ez zN^3Ep(OpX;9E``(T4WMW<Lf+ETGK1BmDW-`uf$eZ%lQ-qQIh8p3?gr?U33}yklrgy z$Xm?$-ojhG5fJ}(7T#zA(<H$vZF4TX-D&okHS$m8?WH8}n_?E@6Thtb_LZCk-O%$D zILDpy&b*@r=Z%WFTMh2E#DjCzmCc%|mB?9zU5<9~o-<LtWmL_p3~OOP1+h(&=xnpB z4Sj0$3Pgw6X@TwZ>baQ3W`>p&F=vU0Aqr8o+|A`lb^>!Tisu|d;K-naq)1Z0Ly=CB zA_GF)uO&sLX!4)Sit}WaI3BX1R%YPjf*QdxRttE!J7&15gO!tX(km-KC@E!a1B-xp zdB0@;MrAb821dm+B%_onH9Ep8s;ZL7pd}R+kM6s%V@UD9LP%Job<&1g1-e$@Skg;x zck5#b5vu2tF>|y0buhpdq3|z@a*N7`X!}rTb0rC?LdSVlT)T`~-opARjzYMkS~NK$ zqTPiFDdapu1+t0MpfH8i?U1HcEM^$mL5@ZgoYNjp3KBJ(%5-GCoA!95*1nSVc>Q9p za5kpRdMwj<E?iNOv|`FHBas4E;v9T5Ifmt^RW25P*j<7bU?tA81OSb4C_sv~Q__-J zKMi(}72fflig-Zww4F&o@hI1@U{hmm^o}asH?pa^nF_^3E;>9ls<v*)6rCyFueUdI zDc%tQOWvIF@Ok5ks?qUwiCktn(G)9}(tTd;W*YD1Qkp~iY%Z0m>Htd#n;KHR*8!F% z$B>%jk~^$f$;ly%mjhuK^90tYC7YHV72*;sN&(iSOs60&iCvzq)8RT?%5=W>eoX79 zO!prv(@~B_dDg7V8cGStrargV=<J%(erj}2rDxBGag2}sx<cI-avXG5FBIw+`FSou zb8~G%i%vA$iH3~}(uu}lIu_}qnM{gw2t4or-dUxCbsrWv!ZLN~I*pOTbQTc<XsdD; zJ9oz!)MId2iga7z=Xk6N6zOn^&Q_$G>dTmpj&VcoS`vuI8;Yg_mAn$x9_(<@x%V86 z><-gLPDhP!Mt6Dn7CYqI`RHhmyL^Ju9!V51+acX}IWg3{uUv=YnO-^}B`f)a8wu(7 z-FCZoR0oYq5Hi11rOOLqpaq4QEO{=|c_!shS{W=HCXNx9wN3}yrF1R#f2%?rGV46g z4m}p?;uPBELR~!Umvg0VQ7zQ_CCsRO#DNyU-ptHAYR)tO9=1kAP9@A%Eo$3y$xN$O zhx<lm8se64^$pRrNv=J$2h(g-scGhFc%f%p5oU~;P@ziIg{WpvacXLax0X~TPxMm! z_6DF>cid^g3P+SQ3al#Du~Ls6Pch>LA7n8SOdoGxuZXl=N`*duN?gf$FL8Bs660P= zTs6BiTE(#Dh+wVOeW&uFx7m-b(tT^2wd#eEInn#<G8e4J>wVU~I$~3(;n7;d+~e+W zio08RYfDQH$MNGi>U1>n<qzekYC8R7U60hQ)KkT8SZ^h%&Tt~SC#k$Q!q#X9Tf<~k z@Z+sfSW^A4x(#J^(Qj#}81Lq&F1(}OS5O|tC5Ht!GTz8hMVt9tHs)1#tQ%_u&f-v} zB>FW+MGqVqUz|BAEaqBY&QWn4jvN(6oK&;tsE7W&H|D6YM?N{~CrABf<fz}&Ng1E` zb?NCBN-1<h&!?wZ2BQ-^|C&}x7ENxN3}uee#<SfE5q1W<kL_Mz<B=+ggw9ZF#F$#@ zwVa|>)bq9+Q?tyW#nJG=Xq+7RkM3u5dH|ZetBz@b)&VK1>%DyLO1ZIYGlUFtZ`BzU zIaQtHdaB>@z0%v4M%118NuElkj#6@qtyiXVQF^P+5LGV@K5HFWLnP&U_^7X3_as?- zU-vZAvHFX%;dT;wr9=V3-<P@*vzlAr95g~*>y_&^mcf23e42VA%~bjhHVA)mEU%O? z#Aet!tUYqQG$d1(sQQD{X<75fKCHNi0O~a_aw&y%u2uDvbIiPEk#6>6`Zd3CeL%pH zVcO05ScZuWRgz$)o@_hs0xWh(Fo$(XFgZ0fJi!_BODc?J8io<^qk(q`DIK2EOUJa# zx*B`P)=x`^Gbci(E#kPv5cf#(fj1DRkJ}J{=2u9yX;%oH#(T+QOt3#*YEINe&yaFJ zqsXWnxSk<G1pW>kl_-P8C1@{)&2kFbqZS^lFx{_h75?6nj!F(zFL@w2iuIw?&utaG z_6*%<Ck=InRM@(ue#By)>h}OaNNJN6Zb*j$B`sWAk}6P^vA`_BWj>$Q<|J0HW1Oe) zUh;SOymzz_MwR@<f@?vHN3v&NWt=Ohev<5|mtrS-;*3kR7I(TQZ;UCV(w6y0NaaQr z^AYd=L;0Nco2i)nbzDySMH*&b;&CR4LMeoMjmMdy?rv+ddv0eX*ggYUiS3Ks8HY?w zLThuwr$<&2RgH=QHR}DpJhtL-ax})+xSHC`S&1p9xy+oEI5)-urv#t1jw2&#jdKCf zenX$7p1Zx%?^@|JgTO&Tb4W^51N=)mjX_g2ZGxO6F{&LXjLsH5S|x>E1xT<_bIOe( zRnx9HH1ccGoE+Dm@vJS|kvUTeO}$a5y6?ES%%kqCg`}Zz*D&3HL3o`)E1D@In#l#M zbHt~0w>4Ab_a`NDGd?Dn68B+LT~@P4)y3_SDVZ6wDk-5o)Dn=90$^rO+aPhx3+q<n z)n}&KUP;MT)tY-m=k>E2Y={MVkLr#?jfJY}qcVkAN#YGefPveoX-;Nx*?LM#9+=qG zSmE!;OLAY|DlwTE<Fp>xn1(|)?slC0jBNvP#1)8at_4izq&gNbwTJCB1xz7PkjBrx z2`ni6wpM1DTEXI)s0hUAI*-;<DY<h}av1TxqH5+hvoYxlAJUD4%Vb-l_>&%|*-Kq) z-SQpgHwWr%4QomRdm^MY8Jb(drKs{97VstT#iKIt<RJ4bFjP8TjCb=LAPPU9?|7&4 z9VM&pvRdxC*5#RRaFidFMJw{7P)v{`fzoEEW{)8_wD49*e#;GssG5RaJ+j!_)1@x8 z5SLn4&;tzqBekv%AM-Q*`5##CvftKCvA<F`#eS)qVqerv5efA2bfyL6uIQyY#A@8g zVY3pe|D{Vu?Y!cETE=H7pS=wRK>0!*a>e7bJW3QA4i`jh05#UU<PTJ!vxxmCA!HJV zRE6r92^UiBigyT^njJ#c^mE9!*HpK&wi&4)VUbitQ-`jUbPPH$YHWZZvZl|RRbt+l zxOBiWgE$Oy&ZnceHl9*W-vfLb0$#CoL<7s@2OWxd22LxDXD_)usLSfc>|AFLlLKbb zX)MIduOyve9S&e&B?msRE!Dv=BP~K}G5J;<thJ_DaAhXpc<9O}q6|2)SV7|$mS<hf zQkE)`ou*yMW}qq1xEUH@k|TDmgW;GAJ11eV@(FGgzADEBX%}!K>68<B&EF73@iv~C z0DT$7%5a#N%U0b4=&2&idPi2}hK#)=zLh<#<ZXb}amXsiVzt348PCkfi(`H#TvFgI zLM1e;GfQ|~95wFlVx?fclT@Oj>}yG7S%wDqV$sTKn}+0d15U57@17dqW*Zd`(z1s= zah#+jv)H@mYK%+V5sWoT*p7NWD=9nr-TF}W7j|irp$0tW=N$>e`6O-PxH+5#r$xjj z_@lIRJt}eX3Zs?lRoW=YpHDOoyKE)rE)>RHnFppL8Sf^4CcUB9WtX7=2<q9pGXw0L z8Sqr5wJpRxGr+qWE3wZEKpKLrTdiwD*FUAM|8S{Gv@Kb_@<w*o^0&{-fcK<f-&HQL zzf!rxeyLnyUsNtBoQFC0B<=8Wt@G=u)tLzv5e}J&HCqknazUkox>wqI(A~PMY3)+# z(Gg`Iq;X}8N==yHM+)3JHKC-2TF|a6?Ub1m9)X-xYC>3k==BAAozbcqM!jH#x=bAE zQx2`ER`DXilwj9KaT)!H4V<~tC}vBX`Rr?%iCdIQOiq}$%!#!lv`rZ@3l<|NW|d;0 z#v;nHNBCb60&7#Cb(UQr%dVPn+Su$63R%%EArelq0NDqovKF2|?jf;|V<}NZ(&J|f zbL?EENM0$Ia$iF$daBMh+z+cjosVHPK9rrfj2ONo3S+#1yJFXqL<tQ)(Ai1hEPdRP z%0Fl)M4l{m%1sInL$iCEm!tK1MdYaRFh-^IdiW-u*s>E&F*b<{i2tbM&>F}N*$G?k zWheeUx{J9hw5#mIPc0C!9*0opuoRFg7|WbOO}V$l4K$}vQ$Z3L+p>W;Gp{BeHV|dz z%Ld|&8|m$2q>=`P$2={HinQw>3MACmi35MFhZN??OiXPi>mSd0KooRlJ&g|5Uzk1B zyoPnldN?PtTlHyXJ-jJY?lP9HX`OUEmN9zJv>#SWZNv%BB>t%5ep$2rsO&Y9R9j@> z&PM85^<^uSH_t=4)|BR$$rRb{B~vb8XY#Yj6tUyycssuvZ<NxkRMH3}3;D1aBqcu` zCL<-c5gfjWi=GbfE?tM*{;ex%IB|v#&L<0L%jzD5G;wu-4>DCq3x`5lrHO*HvW_Vn z?=*icZntl=eR0bBe*Aux>u5I=aw|RREAF=v+Z&@VJ>&tewZ8cqG5LR2IZ$PqDxEx) z1Mf{y_*4Vml7>E|&|-h3LW})Up~b$a&>|QWN2M?1qAmPQx~OpdQ!)Rf{>DvG5N>5w z)~cjBQSoq+PBqR~RHvHJ8ZKAhiNy@ZO%9T;K*>;Kxl7t)8m|DE*>#ah3x1}m{-+6g zaGx{K7O-UAwoYA1%)E1tH*6`px^%M=2D@b5Wmrl2ykgSsNOi(e<w1>$HJK}h+zqHy zL1mVpq3jF4STgU_6aLE;qK2F0v>;RBjl&&+<*FY~j<Xv?aaqG?RdOcX%e-eK{bJ^A z<C1xM4=INgK}^R&0=SfU+n97C6YYgp&StsIDqv>9nLSq<X05X+CrNYMFxGn53zB-+ zc-RY+dg#628BmCk6h0zYBUkpQGH^W|NLy0W?Le5yiuJMF+94}j5?$L9Eob9ls2E#y zZXIZ~JCd8VSykxB8pxv*HKT8~&y{^IkhSud#4C_e$v2(-hO!W+xT;<DqlaP4OT??P zlxbMP>zuFa?_O5V%Pwr!+;WYvRkFp-*pRsim2L>NP*dO@)I?Ike&@M*j<hY5Iwi56 z);mc*jIMt%>5oAt{nsvn?Gt&2m_U#V*5j*xy(Fpja%E<TrIbDB<Or*djX_`!8<L2a z&>7%<iuitJ%@K8QX|YMngvI(uZtf#$Vomn;NG+>9ZMR`vb8}{e*EO4+nK|z#l?M;w zwVm=v%$3?p@_N7Itaz-H)Hp(`(jjZ--D3TL0ZW@DDMeCG6c?KPa9!<@_Dy3W_F)y% zcsFf#v+nk6+AgbE(st*<!FVWw<|!84y7itZg04%y6+!3my{`RM1g-PvHywPQ)>Z^f zEpR&|(YZ@G(<-=|M29xVzU<lNzLFdRdf&;S)rGX+ymkexJ&V2~d0#$R^dng`pQgF* zVN7bfHE<@qHXt4|X_;;E$)tZxCjDI<8T%`BWbBtZGWJCs8J;e{W6)pBp{-QNsFTn@ z$uIDav93c!YvN?KQr=htoCUS6IW*SZoLO>cC};q8cIMF7b;&S7;k+S1b}qk5QNy)b zB{J}RvX4%p6T~W877fudWYJ@!uq|PO-Y;XKE*70ck6x%N#U^o^ifxr{(8wAqm!2}_ z$(d_`6m?X8s$bKXV{5TeNY*+QZObcEj_m^H6)eoLezXlv2?U>nQ(-)hG$}`9^p5e; z?P*h&qC>Xg&~<AWI8zSYsWP4%Rr>cXQc2IR(CsbaHEFflS|I<H0hmVtRWnDJaoh~i zRNxBn?J{zwx3gm=Et5GJuuDfVx0VO9xO~`XlAt?(*l3)ftBn?zR!<#EIYIF+aZj5c zqYf?9+#C;Pg8UqdDY-me`$lmL$j^C}rA-@OP^?RSPD)PJGM8iP%WP;AWeg?m8My2t z)DwjOGeFG0{QS6&LZCR%(EOCF=6WWM@2DvZ69f6EV^yTG{p{R>`io~j=-4UQDLQc` zjge|t-WHz}C*Vx<KBni+(3=fzeLrBmm!60BXsc$zF(5sUn3V)hY!5a0AXRGGS~g<m zh<S7BF5G;sF-{gO?p3CX;GU7KN^QjsL1!=Wae2*m;k=xw`(}J7bGPNdCH9rHj<C(S zYU_>6JtQ85bD$FQR`X@ev0<lK6Y;sHU=cqcnqBSFfCjvk;m_mcDG?1LptIp@^ylpu zo_`*lM~tBq2HvQb!j*u3UQ<w$MI8M#5zV~COHTnb$J$><ryYaGE9LLvX+hqXJHIR! z>Jsr3ti5+%F*1-rpkOKYo|<EnkeWAKy7NjHBw?TB!g=2)(1cuADnX$p9AuD=g_4J# zeGQgc#O<<lr|krq%n0K)qGIPM@B*Mxi~>}ALEeuTkAO;MOwN}0B%q=l(vMa|@Tcg3 z0F?-WA7;*Q7C_}dD!(2{>OVq@`7WFS+hB!LmJQ*P`#vc_T}VsQLQfqIa7t|Snh%`v z2%KUWP9a(XqA5XM8cSB-M;(D%F0fq49o9mgQ_DYC%dfy%zT3h43;UP9>Rx`OclpW& zqkt^w=mWlPUQQ5#8g{{v298WA^Oo1MZhx-aItw66oWyG4<x2l+bM9#cS+F^h(QwLX zgUasa7ZcqLr_C3he^WU1n?+LJ=Yx*>VVxmp@bEnTnE{q?2Vg1XF!(glaBW+R3W*qD z;U3ZjVIi7AN`$Zkg|Lvd1O~Dc#6pRq5!&u9<C}Tpw{_~XMo3!&2|@R6jnrm|sDLW} zY-D|$m^ONZZNVFL%xdvq3XSOf<b;W^?JcS;MPt!ol{XHj?D?Co>~0fFzN~qa?A;tX ze*$29+#r_c0GN^%0A^Bco3-9XVA4;iIwe-0g%D~cP745|wy3l|cpkv%vHZ*H-K{e; zaSsaq;!m59@Rwy1ih3}u%ZxpulAIEO#u|iBE9)x>0E2a4vOWgDs1-og>!J7F1Cx(1 z=V3bPXfJ3eCRg=g(eW0uG-IY9U?}KIV5U$AoAuga1OCd<sBdQU#V`sD*Hn_)fTo1Q zC!I8<uRq%NAAK##a|`xDyW~346g7h36_%WUdrgtxPsfvS!{+3g8+Cbc=m5R2@gDSI z-lI(1dWMwPv^!dl(2F-4^a7bj$^cqC+sKW3n7?o0u<5W%1$illO*)X50KykdK$_hP zBQMBda!K7jA{}CV1bT5mLzvKuOXHDSTzpkqH|T|UNZvD>U}HwijpmUWkt?5NW0Pi$ zcZ66yN_ST(E^y0NR^U;#%IY|b<L|mWU0(mZ9fpy3SAIi%r`2WbAu5((Qu6=#OT?jV z>oTDaZIoS|3Q|MHtls99X?>kEn~7x=&4IyD?_d#p+TOt;N|niaFMtuW>jaFLf+=V` zf)R<4)W%kvC+U)ze5Zwc?%q!e`4cVVOl0Vr!e<*XG0)4%=jU2(A0-6PFc3O{XqE9Z zIU0vHEgk6dWqdl&TN3?kAu#uh5ZJpq(A}3pVD1$mu-@V<C-2j&|1`fY1f5`BxzEmY zp9v;ZSRldd)i#@<!3IKG8U(ZCmyT-m(NlhjG<e75eS56niy{{#2*~c815`=h3XfPR z;HNPnF-JTWM^C&Q*Cyh$$kF!M9RPi?o?Ij6EtM8gl2ek;L=;?u1baz7>u?WQNkn_f zE<Mk5RpPjwBG^PN8;8*}*AAtA?7C0!nW<;0@6m{EZ4Wy2EOkzfxvc4a>M7~n$nYx? zgDo@MiT0tP9Y1?eSRfapS-(O%*p4WTxpd7D(Hl-GC$fWSqxA7}QVBgK(!3H`NpA*P zzHf}Nlk-Nr@w6;@qP-9u@Q-*Npft?S>_@B*C9S5`v{|p$6{)>q7giRlPFo`-w2>1o zOiVLvPQxAZr>vD<pC;`G+PPH7OsHEI88xCI(N;<AWiBMrMBctPXIEz}9<$9ct9ov9 zlQ0A3?{Xnb<H^m!bv3s@f1a^9B6x}#0+FNl4u|P8u2r{p8aUqD*{R-%B3c>bA&bhG zSu7)R62I30y-doo*zO}KGh0uM2JCNw*^_NfnQfU`_b(>YHtK}hLbr9EQhA4jS~}in zK9kLmPs_BE$iRXJ4wJYOL8-8nU)%|yRN9@$s5t?tAjcI6a5_n@r3{~y@?yjF`>HU= zFnYt}B5*JAg%2g%KE>6Ro9teHC3zRA5bKt36S0WL7~|#?mIO(_VFjD14t%y-Rik(0 zKUkN*#~p^NKPkoEXWf$Nlu#O$!np#nQ<BZrMJIu>jmUEPVN0Cn-uL?)T-o}mVtikC zPFE%JBTS~pP9Z{&B2F_~jQ3h2tieXUXOm~@DU~HO0~BmHJt!JLd)`E+{9$+UsaQ^% zlhCOWV1vcNI=cjZ0HSm42Nuua30B^z<Cc!p=S2<FhU=mRvz04cr&|H*m>PZV#|R<M zL+p0#{gf*BYekwVbAU&~axz*DHon6sP*--{;&qS`X=q^-xY*`z{B4W^xvxKfQ84zx zwg38>4K^EvTu^Gl?T#?4JM-M^8SR8w3}}2AN?b_N$v~gpfpFkvwM8K@3)XTX90YCq z5DuQhO1`Vs=blmPdmHKCOSL}tidtVQUbDC@H{E?7E6H(wU9pnRjR@DF*tAH{(#qA@ zsmur_J*t`^5Ka71NlsD6AacM+$!Q8o+?-vaq^EEsS^na}(YyiZ&Q}go377CQS-aK( zPpS~=fw_YW<r;QtYMkY6b%(JjsWD^^&=94bfe6tB%YDvKRWve|iqVhB%u8U|yaZ{{ z99(ReKClBvwKF+-hKXNXD10p3VvYEY%W^PMBCo7WTA&h%MU>1iV?8=*7|L$FrpwBJ zN7;H+THG;iCwuiM7#eb(aXq-%-XYUf8@R@<@=^)}WmK0>>#Mz@5&BtMbKI;GR*LUY zfls_gCaeTX><J<>ft3na*&%U4JWJkf<8sJ1v!-?LH|$Bs1H|!16?!kK4vq&QVUdV; zp(KmP?M=y|-rhnTiX?mnWkJuHAlFrqqMva9KiRC&q3i#J&H5NR6n7oL_FOxG<4Pa# zu$`@2ZYMQFf_;g5aNVI|5HRI|USdfbA~Lrx&i?~e15LEhEmT82v~6yR>Jb%=fs7)0 ziEQudqA<%GBgc9nmgY7&q@`cWz2bLgj+tq<n6OafeJLtUWr{qBocGDZKvcH{B_*oU zj>kld*X7Gl68+{+%auBUzn7n0Zj45+HE4@M!xV2nweg5sGHm&&`8&8-2wYYs0)EVK zebwL<m1`q;58r2K^o5}2V;6Rdq`Zzue2R>H?PC=nd5*cRXDOgxY~7Ku=`!ykV|mUW zdl4BkZb8PJha}msfTkhwB$Z&xu;Ev*By^xt0G3=Z`cLtYlCZ=4C7FEZsAw}g&90Tt zexJbFfW=^=VE_f(i`(UIRY=;D)*_?{c__I6&erdx*v<L~Xl857t1Y)T(T(1pSSrK1 zfo9z0$567_kg@4FH$~3rHEmX467~1+6q;c60^ev77!G5*88M!LvovP;xKj3gHm%E@ z5@?=MS$}l`XY3h*UBSZ{FD2FaOTd}$6LQAAo_J)IwNr4y{bIZaoS7uI`T}r9n^S-@ z80QGaBkROxVVyiTM10xFtpf&0Ex3_e|I6fdt~<HqjUi;%=(v}gR7sw?vxWyI*+!ux zC6lu0WA-QR9g8#t_f7B%4p?+whojbV?dm(=m%6g{=&JWe@XMPvOjm(l{CL`bZwQrs z?Vgo{>8(fKR&f6A&FRZ)*k!ME9^^~g#{Iisy?IN20IcU2){6w|g*vT;3!=5MB$x$j z^?&KWFd|*4a_mOU%t`Y86RZalaXzr#FM;)*Qa^RSQvK9@sebBSQa?>SH6U!yJ?!6a z@Sr+GAWb+t7*DlR&|PQNGcW+(+1XSyj0J$dkXLLE6->3UHGm+uM08VWMqomAhvP~y z_Xk)6@0eUlGz<{mzTU9W$R3K29+16gPspAbGdxl*8+)K{iIeuJCvu3(1nnuDY#<$} zGsMR;Mkq`;C)Ao=kxVSmo+0jmQ}QYd?a{2o98omF#LS^8v9qvi+Et-;lD|`u65RSt zrR*!-@rTbkil3v>i;0w;$9ni?f&Qo!Utg7Ae*>Y**w|$_lI00u86ia*m@-DqH#Mll zo4&VFi7y-&Wr2Rx!bcCtpLx%emBc$}B7X*ezeTA*vB{zgO(orgP~nr6+wL~p4`-nY zs?W^6qINzvQt=$Yg3aKv^#%8v%#`{w8io6rlpTb-hV@z_?Uh`?%HbNRBN~8yO)p*J zN43>^{j(;{z-am-GUigDa$aY96@w?x#@MtK2#X{p9Ac5)=r?tJpWm#HVUd7h0u~v2 zw%FF>o;9;|!6FH5B=QfYib1>$<$DDS2~$&t#ab1ui;>8qw+TctjSPh0=8TzHDl{n5 zs0I<oI-G%Ypo(hE@Ih_JFiCOa4m%<We|}|DZvFGVK<L}!M)?D)FYyk57nw{S_<iEz zOPs=!WN5M*%sU;QDO$rPbFLi;3{u25u4^z1kL;I}*!2;!NJ$Dyil0ek3yLiO@3Hj+ z@5wBId+1&OzxO=2*LpZLxQCAEa&D5)(YUPW0d8~U4d5PnNgo&5jOrN`KPc!Pum}n> zZWxD4S`Gyy5PG)5ydPra1+@pRZSKnn9pvNLqn{Lz&yg%}47Yxo+8POfpg%YD{BV>f zrP~4lc^H*tS+fU>)oR9~iP&35)`!r=7&btzb(#(!s)lXxi*>`?SWqu=`RpJa%+4^J z@J0587QF-w(`!c|ee_7mi_}9LHc6UkJmZVhKX3&?Ct@C1mwOFda?RVXPJEGlQ`m`l z9FwKGA*t<<<Ow`>zoORc&zR=QrJTmoowDn>Y+Iuo_q*jhQ{Cs0NAetkJX)OPCB`H2 z=(yhS96N6FG7Wh|O@8HNI`nwc&2;E7p?He+D@_SGozSsh$%rz^+K+V6pMXASe)YgL zN6~2mE+>NKz7YKZFQ=$%o4@mX!asxKxuN)zV?GNgyQX}w0C_aevMC$AkD=%1I7Cva zn5XXs^JS%K{?~5+^RbB9(EbcpQVa~d;t2$-kq3mrXX_kRz?D#spC!neyAO(0FkgQH zu0Mh6Eu&7=SOSi3)MEbN20Y|?tNJ+27quWn0P_a{d<z2jUDamyD^;7_m#WR~CDrCM zRVbex!#fFF9VlS>&S<N+ypL*VBd?nC+K$+zZW+QOHCe@C_hCi<W=*^jzjj&+Zb4Rq zw%a7nApkb4MC1=x6A#P^nmwHmK^Fa+xy)L-XD|#P#|V(4XJ1<acXt7-n563^F+UvO zf#Ma4W3B{lW0e8ui1R4P7`vuj^8ts#c<le!A;&<VB6&!waz5t?0`LUiRFpy?ovFmD z!ql>}2@_pZ`&p$ZM47xF_3wfaGxafE@1Gu{L;S#VR9q{0Ut}UCt|0oltW^1^m2n$D z_>iA%fTMT&7aJxq3Po-cZL%#VAs%Vj(AOT_jt*9z@lkN>8<?(B6duU}NyO(wdE%k= z+=w$YnJR>BSzK27*~?YkVIs!#p4n50_w-z=DWP@YhA2c*ST&Y&8cgZ)j1;xB68b7G zzLUs!M(s11$Qdc4odTffiv*6$kXiHAX5<e<yBd3qS%{wXhG33^_$pfLW)}WB_+9m9 zVSWVoD!!<K6%h7S0!J!eH5=&|?STr2_k1KXDc8ei1I`%g3mQKgcr44;aO4&IBNas8 zNZ;49t)^^=o>(;;naJA&?gqvLl6jNFAyz!Uz)De+vBq8Wdb%l-!wIY8ottpi2L>xy zcQ~ULOVX0dWiQR?%UW0}GX*n8&YhL0u8jtB;$jKCEIgK}ATAW6i)!)_D;F2yg+~Y2 zhYv+rZBZ1@czLD})<187GZA`rdh0aWh@HqKGVsYzNmZoF%hlsCk(m$@8S4oOQ@Z{b z*H2=NyI828WYRgnf%n&RXGzodFePpJbp3V(X!VXp5>#}|g}ip;9%6$$%0!=~7^1}O zyzT)3ljV<1#OuH~z**Vf-`4B0sm@v9ui>mYDXTM+q2H{G)tz8g8-aiQtRz>4Xwq>( z*d`XEI=FX6S?9@6=YUR9z`i0vh(kGqHPkkdREK<M6NlaU*M@OW*XL`&U;C2L{a360 z99l=Gb#{3MU8GQ;YU3|)&5mM;WC5m;vxJ_2ONXO`@Yqnm#%)5D&M)r(d@wwPe&VrV zvp$5!TEC)meSHmug#+}-#v=u?cezjuu`(dR-G^;XI(U1B?E4bAN?w@&zRQKS22QG_ zA}e4qp3zvE`W~R0`HH`|Mov~|k&#_^+(V(@UVG1~9oT^iI%86UrJ&+j1AzcnyFLA` zjYE9dx&qJBc!p!?NAKdXO6&7kJeFLHEU{VZN8=HXwIVQ*%X{?4rmOnz)gSYOs<|HF z1)CMD#<&{6bpgf6YUGd7zMdfrX@?Cf?anxzTkaZqBPi*KpVu&`q;{M%nz=07XF1>G z!sm1unc0Aq3!hEJkgsYLFLQI^>~A4ncIA~UMN2fA8B$(0=2%eA&<M@m2kQB6LVErQ zRWp5uKU!Khi_@Fr8AyDd70>o@1^;9H7f_#nN$pH}G{%ehKFn9}%d{wRJ5BCDP$?ax zw&V3!2AojiemX|(vt2<bYD+biKqypGasp9_suiLqh1+3?EKw^$R189mt6GpG;k{W; zqDhJ;#wn90NffwZo0t<v6#$3qX<sQXtTY+QXkpWgmFK2p%sp^av+vYBsAhR3GCaho zySFOjt>WR!T%5+6Kka$&3+qr<9oa4k)41)~dSaD^v569@9NNPKA`>Tz#R!4OJn5PT zC27YHS)x~wu_4BivGDp(&2Sy^X(0#qmhBi=;9s?MZ{Y@n%)M*;o3jf-<~-y~PIslQ z2-#o%M%r67@V$`-GjVagBIl*BtE<#_Ist_)C$u8*O3Q+&f+WIs1&I5>ZF_p(w?hF4 z%W?g;vM3l@6E~sp?;0GwSULZhXgnb5meZYy#si`r<*JCRX#-$bMVgM80u1n1DVz?H zXh2QC)r(#V+L{@uylG4e(&<CotdBuxE^Sn+wobZ;uPq6E&(scxTF<NF4uq0X!BcPF zD8d4Sogi{PI!=3=IW<gdYHQQWHrCl@z2RkPU}0mx(9Q<0kUX;ir7>J#THF9a$A+5y zFlF3{b_P7oI$3ngk16PH1jFJ=O<1p~*8!-)fEi@qsY2DH{fY%rA|GfJIehA^pM0PI zPJv|6oKm_hq=T8bH5XMBQYOK>l6V;5X#ii1<QL+J*~iv9s8X&o#d!@?N<Ql?FzHy+ zdJwH^Ag|!sRD+voLL)UZjDIKqhzpeECi|lu^-=&B9&jcJBs)H=h7O^6Dpoqf*My^o zm~9w&03uog50r?EX&FF|#C!53Cmfn7-gDLmz<atWoxuDDtN@5~f+R(t%_(C>MGF>; zNYHy0)<aMFIHj*mMp$iaxs1^g_J|=3>xLmw;Ft|#Co8Z5{w^Rvm$4ppcMcl}iX)WY zQRA5&IYSQ3)Axc#!^Dutc*0IDx6^%hG$<EbwQ&{Nv%@9vRNi<(kl0`0)e7&9yp{3l z`SH{jW&)n5#7w{s+Z@PgJOfDdqxS^t(=4FB03eO2#S=i9GLF-DLxaySY&=y}a1N91 z+BfKF7*Qp6k&_z7cqQBp9aH9c!8UR;zQaGSWgdMU>Si>XBoKX2B^aLzqS-RZ!jJ-* z&zsS7snE;ld(a5qbvaA$WuB!->CYYL(27-_rZ*FV?kGE1Db{nU5>&ItZfKZ;OtUn# z{6;JZ86h&tgQhg-q-g=!(;}PTQ7KtmuHfhhhF76@GLVjPG~Cj{cj#v<<au__s-D<E z49m}^&pLb@kSzEeeBs=qcT)i{6|A}a4je)$mZpKj%}EfAB*;`0ngMGP&N{U`>y)!? zZzFz|C5jzekus3EQ@EES{Uo`xUmIkGhJ?}?qIjx=gjymIX5<sN#8_uo#Zh;PVVMr= zkER$Js{r+goD;*PKhK=ZKIZq0Smn2;F!*PtFf6zEqurS7)194o`OnFwJF*k~MzsE) zc4c2dmamLxXh2?i6}Fu1tG!#6SulyfI0LytVALZgW+!5OT66~;H|42Gikc{R1rTuf zg_S8-@n~e1NokWQr+gsu)PmD7Sb4fbgpX!DWw9ZeP>Z!rUvLJpw4bx-D#1euwGdNa zrT(oC`%3;etBM3Gz=Y>OMM~r@TBrzaz_GI%24~{%ElqW6i_v4(dKgfc%C*C=7MdQQ za(E}8GQR*dkfKnH*jsw<X2UAm@)(a8;a6iQNGB<w>k-3gNYQ=pJi8IuhlK}d&>Tys zu@@>)wN#QgIC*a^?xaVmTZavr@2R9)mrR+(FJ`0%6to{#)s8T_s*LG@m1ZE$Yf(tw zB<@8NS-&0A?NY^KMd?YFOpzJQP1nz&cw=NxmmzdKSKMd~zk(JX`hkqD(LQ<Q2qNfv zf_&*`ZOQwC6v#J}cMY5*S28z2#$IcySsq%Q(Ml}KEwR|&%|tz`!otNxrrCSU^H%^A z5sB1D@cIPq(FqDFQXz~9D+N(G!8vfUGUWtlHHFF4frhB|2@g=L2oufdeY%23_z5~d zouoR9p$s?0@KF0$RaxaaIvoU6;*(jsTuG%_QOY%}BJ1z`w&M}Ja;fUK)t&X~OH>b{ zlU;69VH!zJkZZzXkx!KM1W*+^dJ1Q|m7?+j8HltEL_#kMo&j?a`K^2SvR0kFSyOiF zLvVK~$O95^c?gf$;`Xj&u`X~ood6^+as3lpumcZgVrfW4tRA+I;q{48hQEyGn@(W2 zu{0@H;lG~p5Ei^p*5s(uDG;06D74#>HCE>9?$5CH5>T@yJb__YO1~-}^N#;cL_4h4 z)M|R;Jo9^L&GsX4ggAD664U!%XTz>hdBgjMOz08I3*gZ`rUtf{M8tXbn+be8Ll2}< znk?bG4B=$BN1vR*(ThMgjpms^ceIeyMCOJY@{rMkwba-7lj@kLNluz|{skTcj9AUm zBb)==rjC+XiRn`Oy}`gCp(eAAU$vX{g#MZ?`isVl{p&GkkEB1EW~)J3eigl_+$$6o zCCX-uCqrFva!@JN)YHnBgC2@fVtokc_P9Jn#lsGbkGz+6#JU09EEt|yFkmA@vZn)x zV#3_)=p2T@GET-4x^W&S<IJ6bGGshKyfWf97Ppt}>}f*FbxnzjZ*;hUi0VYT*;~aG z(Fb2;Q0%0z8hD~pG3>*0`vFMLaJ|!My9Z`hI|1Tn!EA9DvWRAJ5{(BoWFrqS$eiO- z?dhv`Y3=D#LS=O?t%=;^TmGf@r(2*WXb00iY@s-(9n6m|IkWqp>&8cSdfqiBF+v== zEZ@}4oWUl#+(X!DGhN#ETGHXl+R&IWZ~8Da=6VNCH>HQ4^w_h#rv~~+OZvR8&^rbv z9A{_wXG4<%(wBY<G&!<%Z|`Ug*G2(CsHhOpjAawhTMV&-mYuMQ5LW7VOs*v|gc|K2 zA9dVgR`F-K@i7n>0(&P%gqnTvP&}&4o3(YLRv`|}5-=z{J@nh!_mXCHnq{dKheqz} zAB;oCNgX1==$XmKD}&{ZJZd<~{=JRx{@W97{8JNd^ldg*o+fU(<Irx>1I{?K3nv`< ztMNDf#ql?WLCvQ}1p`NJv`|xCJ`xC9;OrHLn3-y6;CPKPrG|N%9**W37aZEb?)Fg= z=rT;It+VO8a+_y_Fqbp>%<^w2+hT=yLZJ&9d2~i*u_pv5V${DGu#j6A{TIStL{duB zG(?0~edp@YH`8OX5SJIG15yhmkc>m081ZjpyVO~Gz0N?VFlu9=lXge2V?GFi#;)qt ztk&%aMHJ?o#;`|MYvj{H&&~0}M%pIV#Ur(u@e68rxK5INl5?VKy6#p@)fwSZySTyK zP*!W0X+kAWhg5E#2>(ul_isH8A<5h<!2^|M12>}BB{RW%m(Mgr1+)oE0Wx4dFa;R( zO+8PaPImiQsNoi#tBbjc$;^OZ^wWg(L0(q6DAj%?7<L*^a}G#7HatkSGTjn&8OH46 zw)85iLBO)e)Y#9R#h^0@7&iT^E%$^*LlEHQB@8>V8=4sQ^ih%5`3>5#nH&|WL1X|j zgxhgF-i1&L{&i)fL3_gJ{3Zx><ZmcmoJG?!61IyVi+EQ-Ofh*7_c{S?OiP&C9C<2C zhR=$ANpM`nz^+m!q5s(XeLmnkXs+xiJN$Ec`f+H`+2|EY?7V`M&GOd{;SJAv1q{}D zttz-6&Osh7-3R2jjSs`mfC?^vJ%YOz0RtQW&fZ=Kiptvy9PP-7MW|*@q9;vBs{pi! zf}o($I6J(!Z=lft{fIS^to-G!{RTjYRU@gH+E@(L*^E-=OsuprE*C5!;L6?N2!@jN z`e{Qtib~vo1qv(+*<&|HVpa?d$1)Z1Tgh?)%@|TA;v6SMia@z;PpQFZ1C0(|%^Hr} z@M^Zt@>TVkqFaBr^otoFjwP$vQDt`4rX0p1-Eh`HNYLcIF!f3zBgh>(hmqjnCoeTu zw?`qy6X48l{0`uJz5KTfJ!;Y#3*bDP0GhQ(!~XCw4jgb!uj9?iqqAb@)So^Dy#m1k zqAXrn;AVvtaTh$RNk+hmB9npmpb8;x)-&9k6x!?~Y9OY2V6zNdmMaRUh?p-Zo?N7W z&B*9r>WigK3QXkIDX^f;0bL|nA3&S0_lG`EL|V#_aPbImRBheRW-7^X6GOlb6alKq z(}fj-1wZGoB3HO_Mh%2U#iRl^8*WtHZj^0ju$fe7Q#^D{h;;><htbi=wNGN7UMg-9 z1mL8M7K9zfOv?2EYnD?ugxmd**{~SzVa+8^0r}^#=A1Ovj9{|Zj!^UDGv}Zi?_2*U zMT%|BeS_#)=U3#YkV%^Xn$TVODNTuxKe{X55BKDV03Dn~n2&$}cX>QIb2B*1I$~?b z?3ApKN5?(;l<%pIP{%!3oh{`{#{9^##?Z!MXy-9~(t6e_a?2-szrI_I`DbNOra&0Y z{NCI@(XFf><iagX_=?Ua!}RxP<_}RVZesxd@LcbteisWe;h_zoAJ#(twWoz|#Vwy2 z;p3kf;j`UsD;LeSaQ&Qq^wzT*RQMmQ{{bdyofH9%z~)!8fBY-6f4Zmv<9bi)0!%O| z^hzuxc-*83&oZva88$6#$eE8D;&b`r(08K^dGEq(Rw_*|$XOZIM3J@f5N>DyMV3di zDi<@X2uE`K*6+;39;6Tf7mry|t}NW)d2I<424Lso$TL|CVkl~DGqiaO4>&b;P28~R z^8O%OF^34NJ0N6wm9(9wI16WdZ--^+lQFHA)I!u?*I#WlCnk7W<_)3)mk@~RKlw16 z+ww&<LF~=Sx|Uf5L57?5Y0R%Rcy72v`Breup2l^-*%&dQ)R+oE&ZyX0+>Sp^;LKQv zgI)p7iqpW^Wk%~Nprw&BL03pewO~qSxh$R|v)gepkWk4<mJ~}4#jQmJ2X#Tu^?qsi zM_pcVbhM;AGIkgeOALGFJ(#c)wnnu}$7vmZR#_uU&hXEwZ|3BbxyUe<t5MYKa<djv zAzzjfN<msq5)A^rAqS@g`GZ#1p$&xMXq=w~A2hI80p}_LY!X{0TCmorm&bgG)A$gQ zmDMDAL9$Aw!7HbtMag>ud=|A~ZVX1R%zVt@;K0H-mUvaWTT9ndYHt7$`oN06hDs<Z zP)uB|;9RSs)?y)6Jri+rJfT>gDt2`vo_62YpL<ltPa#e{jXAe!2D)J$5=kj&J%q$m zBVvf<12Iy(=IJrr@S0&<Q#=00C$R>SiiktfQ##D<Zjn)1k4pfm*m|<9ime9>YjPJ~ zgRops^0TeQ&2HACIDicI;xSE=q}*2~?^YHkRTB^mbJ>X^mMlV9ZY?69I+<gKDMbXd z2BB<6&Y_Uo#N=?Qdh}=nsN^-ygrf3P)N6Io`UyeH$X0`JS6(|(mw7=~B7`g~NxuzA zen+RQ^j;D*d=xbS=z4Aznd+Y5H2U*vKiJJWUn8I|eL5FiH&t`H{3_gL$|$25guc(M z*g^C0i?8t8QAEKAF}hP5$&8rt%d4}H2j|XSTf%ck${*_7VF4K)o>#Gkku5J)lBiMV zPUNVe0fWy%wRlFwtSd$uOC;+<SYoIvEY&t`kGM)r8^XrM4M}92k*@~}v;0XuYZNDw zp+r7vJWf9<g9uPM9dba4drH#&LHu360i$9(gNd$^EJWQ)2x49Cb+kK)R5!AbCz{9y zMyLlkk<JSwOqIZ*Fom#KJcp(z3?sGKtv4gayJ+HMD!+gxCXcXun{ik-<57m;va$@i zVB{4}gyNPegN2f-xNWX7I4nVk=Va9dsQiYF=w19~Jr@~@RTYQ;&@mV(C~+2bW~8Bt z$67<61inaiFwUPWx}XBD+h6A)BeIN(&BXQcQ=DZqxr#-ZK=g}i*Q9tDutoSm23IB8 zlGOwL5DOq>Ef>5w`zS^nyYM?OO)KlN_n7T+V%U6X84yTRPj)H<rTElPAunOlPZd@X zCPRFKY>qr<M)ex`R!1B*^+`)0L?j3?MTHd*o=a+>zCu2k2ts!Klh;w4AQLS-Z{1S7 zoNz-(J}GtE3Y9gV8JwmPE6_1FhN`c(kn}%`p_;h9GH~DtHpHKqfnLU-0)CLi+%pBh zeYo9QQQ+^6aq>@%aa!;5M^oNJo-RJ2#-<MvmaOE~pLObjo~f;2YbIz2@K*z%{7VC% zt{Y^}=j@Zy-|ajl<3uQEl!%=&n!UrG*98xM$9XR@q}}mU9r$RfD+q;sV`f!<te9>% zW}H>-*hK&<F+E76Us2JYy6vwsg`Abq`amtS#v&IVfPrVUMAb`djYTNRaBRTxk-aDe z-5}8=z_q5*IF(njva(*2d|3*2e%tYB$(Ne-7*@Qqt~L?WgBUHTw|kHIwB@I2kONVy zCL5bF(SF-~uzJ@<t97mzT!dVxIH43XA`B6NC?^T=*JEu<=K8R-5lB~rLP&#@FFeG# zYx&~DW{org<non!@)CItk*-~2s!ojX*=9^nXm;7<g$m2GB5p3S7UOcggP>h17c`W_ z)SxOCky4w%p(qxaRhBsv)-OA}RS9?^m#;k7459+ZRa2^_022=i7l|0Ou54wEsVMB# z;H>e@%}PJ3>NK9`bupn1m7hn$ejk27q(mj+!M%Wv>Ct|BjMh$>V<cfn<${Lg<ftBU zWHOjI7O)PfnijP(d0I_IFC=S`iDp&~k1EKJp1eQiS-iN8!MBX_itM6i@nQn&?Vynk z<-K?jx%0^OQ42likWJkiCYb+a<ARPuhUOT`@P3`p)cKO+I|Kbf#L<L-+Z1>XPr~Af z96kchU}uzB#WU66Bh=JwwpQB+LNOs?TScwVBs4mnWQ9MQR$<_X3VJbW=Bk4+)neVD z&)(ec)HQ*YQQJbS9L@IwMQ`xj!r{efVB)z2#ZsPI5U`C{8QSZji(-fi9k*EvACqg# z#>WaDF}TedX}X}z1`8Ndawsg{TYhrIxzNsbia$!@$qY4esBfKP&)6|5#Tvti)Oh%C zQba4I4;DK>!W{Qv&^p>7{jM}R!+_-(u<?M}+peF|vgQ-#jcj(imfn1w*B`td-LO%; z-6YH^M}BW-`AZ4#$@OsmOvU2QoQHLC#(|3-RE<&^{)xS<Cjh7J@K<ZVpkJ-q<D1sI zQV|OOdZp}P?Naub3ea5ug*B0>mK9MQFB*Wzp2ma0D~r0hOlmCP*~PO8ss;rOvq)q{ z2awww7ETogAHcCLtbP+?SdC{;tp=qcF@JK}j?~@uKa0Mg`J3n&MGN%g7#UMjYC4>s zOzJK+Hy90RYPdZcf9qB^xZNOaU(|9s9CF2fd3SwmT|sElj<*EDDfYaOe%*nX%CLAE z2hVlLD(Y?~-^cHJpIuvIY{)Dj0^Cl<Gu$3Vr)|NRA$2jXXgjqS1QvJR@bu}7cC`%f zMHWN95_ncCk!8X`61g#6hzg(9D#<k7gWGdO(#o@NdsGX|HgVm9@yOog8mi59CGTd| zD(h+CH^5*(B1GvSix3yYo6MvkEO-KXE44S46$t!8sl9<2xTY`4;F5)~PmqUPDPY6~ zwPJ}D%-R$_K?Iy4lZMkKJ>P~YbL!S(8eb!d9Y(^D15IuSIKqMuXiqyqw}FnZrSNP~ zJhLNFJqkDZd38N3+Cadj8ui1YT0>zFL^jdN`}NS7{d@3!GovzN<y%Bf62oAluwy+y zBVO>e#OkLIe|txw5=_c*@1+EPSIFQA8H4Q}e>Bl?ckA)|XoGqt`AR?7AFX;l&*+sX zoIOZ#9+|@KfD?ZufbfF+LBk+84}BUT&iJG#`jXjUW(R>Ljuv)g<8t4&4(y^F!jdTb zE)As()u8y3s7V<)XQTlenX;o302)mif0FO>LAiv)@eU7i*@3p9BG`_4rMNZb2{t0Y z*fs@hR1j?hVFK_hSfeyua>MXJhM=-er;V7?36z#cwsWnx?VDSsA6QAwu2<EkK+w<n z^>*w;4isTRz%u$-s}MW^t&AmIZZ&|7$8UN1S!De=PTmqZdymdO3`8r4w=cUSgN^*N zHm4m)n^>7GkfObUmBnP$I*(>*wZ`6xy<lZfbdr8%ngb8xLSyG&kAs?`(kW`&$(HQJ zcw{snWHIR?idDmk&13=h&lbS%>TCxsBrA#Gfl$qoB{V=aw{uN{kj@m~SF2Z;BJr^} zDslQ5w}S`uu{kxeGI$a`D-HR4Q3(OE%zf`N@!LajLxuxYZglb(oN+V1T-Ed!zK1zz z%>{eag~NMLVF_Ke`QNI1fzl*_kEqBbZuqEZ96I5DhiSEp>e)Gla(CU%EnJn!WSQ2- zfVN$9R2noI9pEJGomQx_^wV}=aE!lWfJAhVI17qqgNx8_D_spkC6M8@HI!6I6s530 z54yR`x~_={vL~#KWwHt;XmbFXyM-3nj)niLeS1D7s$^Ao8-K9Y^(PDQ@tVt~ieggo zs>yMNOCh#GGWn9op_`)GD?~x{<j_N5?QKJ)AoX4=rNE>_xr}p@#to7wuVs5qV!X>U zp2BD^A#Rby(dPP|C6{SE5{(TP9thKf4d2!#Gbv=$9yaJt87WFe{K=b3&0@Bal<8-r zW?=z6v+`L=kTMtpgH@i@hn0}GV-lU=L80KzqmSB0qzox&s@jA2f+=WPCfsAqqA-h& zugT4z#r73Q2j(`_4&1fWEU+pe?t0cN&|Q1Bk|YpN=|i6cGp>pUGz7@DEW2yV6j1}m zL}9$}B^)+yU-$?VSW-SffkV967Q0JAi*<tnS;~Z!!P1I?fddYxkiwW9$ITu;Sps`! zV(lJA2sg(USL?(A$#}*B$9^h#*DDa?dZUqyW&6#E1+t$EaRoiWO{xZw5-50O_Ie2W zCAAXrrUx;xKr-IN0;7Yt_E{{@XN?7V7dGP!>TQtW1T0ukR0(0>qsothBjXx@Dj+1; zV&k<;xrgTE!dfJlmn7EHez8PS6k~!YO^i3n1lDrhf_h|qfii(OBfcao1caz=RjGeu zxz$sZph$(37*O7TCz7VaePEc6+|pmZ1;j$sDAMGWPm=;xnHQW0I<yec7DQr^53(|L zLq>I<e?DWk(LV^G>;YTwPKg(ZG%Tgr5&M7XgE_Ha-wG(VF?DU-p@$k@*-Tug#JJQ= zNPy0<xe<~PT5Si0r;=j7KwckA^u;cq%3Y0{JfP{B#t3cr#U}^_IKe8rDX<VN*Os9* zYoqFx{}QUMmqw)axd^1`h_v_(osU07WRr9lt$i~*`|XKm;i-vd>wW%cY5#;b^do9& z4YQ=VadmS};yrK7Lp#VdgfHizg_q``#W|?lnP=yr;R8!D*?hnl*Q<wRlX>%soE#k3 zR>->4>g+Ky34TG6W+QYvvSpOo=qD<Q%IoA|mtDd(a`Q<dAkd?y;!iqiu=W|w^96M- zirZSNvf4SGx{Den^}Rq_?qw^#ToRIO3qPmAgK{Q=bBxj@IF6c*D_A}EBkg_n?ZD3( zWy%Fr)lHT6!?K0|_XNA*NEX6@Bs47^d4_E?IV{iWAU-kSdlPq9I{xewCF?^x;XFKT zc0unM+ozTh6m@kx-z~UR6wxq1R6xE`j11i~Wh$MJdz#ppGoH{C;}sSz)B|sL-n=zr zM4jJgh(GHxGqq08eV`fN`KaGf#wi{O1_tAs8$L-zx{PE7N3<&&x1W`+8{73Iw@Vi2 zzWA`;tw8rQ{5d0=!6fQ64~Z)V_@F39VUl>jSSA`mfofru#=VLW`B!cBcaVEGas3yO zd-82_i6=a27ha_%xduU5DM<`)f|nxPehtAYmt7h2VIE{gW*5iOQCQt7$65fPnjuyd z9n=X3A;ndg@zl|iv6Xzr;)Uf`A<gnda=UTK1p~+h8E#|t(0giQNH}w#@Ux&VRv(o{ z48A6qS>JLmee#(({}dgsJSlT>yn+ZR$15tfR8}x5(-Lkimlf0~3>LB!9xHy<v#9a| z_<91JDgf9+cUD(4oi|32SQmhuY?0=hDX9qQPRLwNIw*Ba?-~?3%-)qKP*tJBRd}wf zZGj3EjK5dX^HoB(Q^e8mVm$F#$$Es?-KZDkfSnDq^E&R5y_LKtGtYHJH4!)zNcK2J zOw8CC38RR4dx+EXq7S^R<XfE^7hJW<2hmogzXzfHRLPnG1vR@8W@j#h)rwLc_G>-b zP&O3(IgDLIBN$_!a-z-3;unT0_|SaNq&{9}wW<+Co=3aew5kfAs};Zs!e8;Uf>@<# ztX>eSRaKy?mg+(Rs0vK$8L?8pU4vliYP*3~IT<Rt36z4T<m&+;2=S8wSE20o)@zS? zv{hcFkXplLeF({RX~TZUQQM0&WrvN~x&gdgOQg$9E517&UD!-Bh@4ErPHDBn%BPS& z!PtrPGN+6rz}RFw!`Nwf&jVduY^S@lBJOB{8re{_D+>5g5x%Av&|#+<!Q<on``3zq zPfa17aK8ce(|8xgw(bp-R;PrWZK-pAg7HXcwR2VHmD8G%h@*Z-kyb^2QD(Fxo=k@r z5UT?v>T{c=gieam@&}VqvQl2dJiS&#>d&IQMrHvI-s0u8F@g*tB1fTiQu1`<+&tyi zIRih$a<A<8pv7U6Mnb@Db65a1+$%xf+Va)u-=(#cF6hd<5gLgMizc4qfHIc^4Cn6L zuILN7S6;wh#&8$3xxpMXZb(gb9HA8TYkG&y!ZQPnI#-qUrDLr%TE=w}w>K7TEE`Ps z&t}oqf-g9@gar*2vQNYgff>c256U6XhBh#2>-tO%#EK$uelt@0Z7S_EGr_hS{n7Fj ztc>fY)Y!BJA0j^B#-^QHdL`2)3q2VLz_?He$4w^~_e(bIE91mE+QA(?^=TN_;^X>D zL7VB&doFN=PrH(-2{hlydOcid#N!Q;V~7QIIL)tZ=MF7ag}ZTYI(0d^eO6MBrl^Uu zY-rQv2}XLC3(~fXqtbsQHhEH7;E7v($n79J7P#bQX?6;T(g5)03dyIQy3a?79HZGX z&SoS)&!WIiU`;OT=pkY}=0xMMaC@+#y>d$<5yJd&;uPiWr{?o3<f3M(gwdMenNl>} zU4Pb9Qq`q;ks7%@Ix?b2`NAL`0OjacZ9Wi>Cnz_ky}Ss@d9#3W&Y^Yf2Gpn=2URpY z$Yuw5W#WV^a{`V{MuN}>9?b<=pkJkA4KlD2D-DWd$!rWSqM%a;<=i-AU|Fu_vv9p) z+XkktCZem`3TRwn=-<;R;!&zBr3Kudgy$~5ub#4T1qrn>C!4=n4U&@Jg|BM<ZdV** zx~-`AgVoBT@~n~q*0>g%tb;_evM9hTlR#sJ<CVd0D1%Yvzetq?;kYa#I%x|06}*8@ zmX1yyYM<bs7nr!|xM-{w<;;rL%NFK#iS;o!(CxGBdnZIsn_@=Euc=3p4mcMVT6i=f zl2AjY<03KCZx!Mv88rF)<TvZt=hMuqa-M9(MykYIo@~o4+krqO5rcyS<yYByLIbJ2 ztT?yltYX!=$A3{Ng%%aY#euEVNTn}Vew6P8Ooa9MNPsEA45K{OTXk5C4I^1YpUu=& zuL@m~elvI<Ht1N4cagq1IqgNHkJ8b(d|{GaoXP6Orj0*~5ymCaisw0yfCtLu5$Hts zs{m^)kd%nGmhuRC>%s%e875cl=9YayU>YcnMR71&cDy>2pK@7KVy`d?o7FWWdi`ud zD>r-4H{)mRepR_Z?b)$>Qw&sRGEg9iYbmKXB*k)=J)f1D5h2y(%@2e*;E{OY0A5{2 zk%37pHL65FU|l?o@!IVRAHf-~ceZKOMw-CT3X><jCz{W&B5>qki)Ey2W6Vw$ss^H0 z<v;_DfF<qH!hP(<hm(&CRC$j$m}4=Xk;XA+>e_8Pf+^PRPN|cuh%WEOiWNVo6laCl zN|CL@VoM2J^`IxTtCF<ym*CBC=$#L@RRS1jOrZbsJkUrz)dDm|9J(M4*GImr&9W2d z*#SoBSNT?d3Ol*_FbOnGD_J_G=%Wd}TnXxut}ouL=jwyk!}371-%i!FWBI`|kwq@a zpJG3^UN44zQh<QHEzfT&KQ#3Ox}XzTmikD~Y*|(y?UCX)FkWob8r2O@F-<D!<ZzZm zoM9S6YhomipD1DtGlGa+JZl0|7UG$ePV2F&^LJp=(sYyB*M36{3yKK1N+n^>?gTj~ z1PVmUq_JILAdieD7%Uihnuo&!tQCumbmUvpdmof`CI6UaIq8-pkDDMOsJws46JbKy z`X#YR-$V;1zT<q9-!OJVGV6|=pZcVX=B-3o%JCM49;PhI3cddmIkjtb<M63_)s4&7 zj{I&&?!OgoeQK0hcxIH@a;HBU0|sD$!EF6Eb6p2C+8O^FHu}{>vhd18vR0;&K2>tM z-^WH3FeHL>OvlMU*OECwnJSN^05DXT_sPAu*j{Jz3hqQm7ep~(f;-rJ$1Nb$t)1{K z<Y#a|ChP^^xN;9ja18x`Z-{=;C=J-toRWgjjL!}Ln#}B3{^o$%vXyB~d{Ka`j^<Hy zLomkKP8q`qDxo}|FZxjxWSja#`?`8USqg;wiJK=Gp#jh~^rU{g`|-)yCfZI){h;7c z95C}KEQFYO2}CVKn1k4zp+B*IZ5&L-%pK8>oWiyvK_sMrXq6y@faXPd4R<bU(=#Om z1+jYLXcnC(h&tI5YMu!gcM6(eHP}iRfK4a9Dn(N6Kv%Wg44shDJ2e6;l}QzBZiyD< zXt0!$)o=`|2P#>ns$g@nW>$1IJ2LL1L)&WYTf)BMsKFJBj5iwzRVNVBVco)umIU2U z#)`;jgR)Ts^Gn_yRBV#={fiTh<Xv&|Hc5G=7_Z>wHf!A6=Ze;P4>xynvJOR64qR&z zHtT|LD#cidItdF%GfHY&;zFe?8Vf-GD{xJPL?+E4OQh;nA(9lTZKS@*inBb7z$QGl zY<6U~wm|(ziV3Un0Lfl|&s93IrQqFWJ@htP7NnBvfuHR3EN-KsX?7_AP$M1U)c6eD z{ot1c#Yu>M@B}BJxlSk8gjl#}!X5e<e0r4WSv+AZLJpJcf@@c-?k4*<t{s8Y3%Irm zG)C+w4zw#I5TW$ieU>GBl<FvRVEsK<TfDL&vNFJY^vZ#dYazLUhfC7pOnoDHt2j1? zO>BLOh|L_4mu@`4wlYTR%>gVIqk2Tr;9R#~q#J4emKW0g45q);_sOs}394nBNfcNH zB2k)zO&?iQuE|)_UXyLdFn2p_4?&FgQ0)M+fv=(3u`Z}~G+<2(iyBJ$q5)qkl!sTa z&5TgEaOX)529O?bt^)LcZ=Gsjj39w)oimhn9q%$HstbY?H{%&VBC0tXubew>#v2II zRHTqgI`}}jAms9U&D0G@QW1@eBZTBQ+djy$iuEC6dB-SwRl2XBT2CG>9R&&~cuXQt zunDhD9~R;PSY{U%kZ>W$vLg`(zY7$!u=5VE?C;>prH`4vj@EPv9EbHd@6B3a>TbHL z(-Q^NR?S3Hx=*K2WsVA&qI!^qXqq#_xZeuf?xM;b!@B2CWpNdPDjN)`#CV{u#-3xz zlAb}^<0!-GSAP6#altLe(#EO7K+eUpbc`Y){;YjV`*cMm2<=>&x!B$JGzEJy+qfwy zuDB08gaw9p1lFAncWvy3`HgoQyPu)hF5uefQ}@8N$OB%SL&3qJe`zE4mf`G<LhYt4 zf3Zvx6>GkpIDNBW#h{r7W&$3F7T1sJ8Q*4_UfG#S#0;4^asJ7|?96<lzNW{yi0cou z6`N*v)OvM4+9M0~)~#J;Z&drKdM-cO;Ch6f^+Wy93rp*SHF_VdojtpFevv<Z`Xx<u z!`hj`9nG_OU+YbIyvkBJt@ULcub^&Q$8lM!-=|?GJt`>p;=w8tStFBTEs&0+BuuS^ zI3Ob{`4DHZ8$5IJO5dtK$rxm%)g17nGK9Cna5D*61CM*ANqi=(8_e{XQvEmUQfi=X z$$vEtzJiT-uC-%L&J19qCQJvLZWdJjiG=BvkzpCh`x(^4HbiFFl2D?didTdtN0V*> z*7&kv-Dv`eKy|SBjA3+vP#~Ay4DWw;MqPMjM%{Lw&5KwZouVJok6xvBx1MktVwdp+ z;LGVu?1}8IZ0k_wPB@aS>rpi0s|k1El?iu*#*MI{K3h?k+?VTl1q~gW15`HwHJ8&4 zEVsE$-RKQC?Kpss&?DG^0b&COBgZBayAnmq4J#lperWTK4L7ZqRT#7|DXPWyL)X<| zW?*NF+JWWmSp|VF88nIk8aC8x2A&eIVLSNNxU#U@mUuu49QLACK<#guz8vVABMp~J z=u1sz-U)%-sx?KxVY(`-)b2)oy%!#c6S$8xjlEgEKMZ`#-clssD1*p&U`I!1z0ZX4 zr5#3(Qp8H(9y<IkQngV=>-}sCi!Hj=39gbTmPWWp@}3aLH)bi9ZAb)lGVL0@k9CIW ztefnqG0g7Ys_K^DAe33}Qc9|j0LXkPmV<Qxaa{&>vt>aKsJaOqj%R0A95zFwwOLJ4 zs+Qyk#Trt9vV09reKUU6PRd4RvfNB(ZEq^ocZBe6UI^ysF#^|ou<V9RJ4XI1&Em5L zz>PBJc#<`PgJddqs9d4UV9Ww$Qw)T9Z<#xh8^c}mqVZf03kL5u+hgdlFB>RmxUr#4 za6Ex4)-K;$c*xFWE39+?0b!v=n81qZdY~6eAJ>z<0t2~b)WEV9*o|D%BNv$!E85X# zBaH}D+5oe;So&o42Q{rH067goqbt8Z=@64uLCB7qi{18{JQl6NHkQ)7^*KzZY^tsl z5`>%vgQwu3I@RADL&zAhc9LCRvn+|S6QgH64<4aB2(jJ;k!NWA8ipLwf+3rknTYks zjE?MQNHe3(<Sh1aa>HFq0R*S^>N1f<Dnpo3DI>9)`i%(5P!9wa;RI}A<glWYmodxn zQkBwy(Zw_@m#s47+0Q)0ZW89|lQM2h6v34m7Z=*7Ss(iGEejiue{^d;xnilbAp^pe zwbF(x22r&mhglIwPP&;GYUC{~kilzPTYYOI$n!xw&6bYa7e0h(8&tfK@>-`v*c9tV z*%j-CYE#Ea6yz0mH{;>7eH9m&9U!|_rF0;u_M9zu;!C^4D`CAGv7KS<T1Oh3>Iv2! z)(zIq!v`9^)%9io!$3U0z&{4nrOg1erTu_?EG)yGs7)#C%0PW7u|o6u-lp*$vK?p7 z-1ES8i3-@xscyC-TRQ%%Mu1~R?}3JGmI_b+CnXUj*Se-DG7Mx#LI#zOPC!^jB}A-) zC9TGy>s5)J+b~v;tg~~f*|F3m)htU=y8+wivZj9HW`TH6YF*Rjcu3>1)aCgZ9qH0p z1TzkF=}J^**PP`y=+fYJ5)05e;y+{qu9ak49FsUN$BU6FH`p=GH>GV`qQ-ZfJYm`q za1ogYMQL#W=tGmKU5zWu_YY@N`@s5z9m5PMETDADh!Uq9+SF2-;lE<WI{(-%jq1YZ z<2=qiue~9?bEP#H3NQ;Z5x3AF9Wp8W_xgTN+K3AO^%fy#{zd*$J2@TZXXeswrZYEg z??TAXVFCmz0{&q`e*-R!-vmqJuOmUnF96H<8UdOW;91Y|`*39d5GNMN<SFZlcrvae z<_yvM+P@AAupardb}f%z#PhFkj!t=(>QJ{l)Gji_gM)n?j}hRDDznMBjb73n>M`Kd z^BNc01;B<4RY>}Gb<3mddUxR2#fgZJh_-=mu1=#V7Ap;|u274^1B`pFDjzd&w#s}F zL0Tf5P?qnO$Wxb}0AQcACIOX-J2*RmYVUSy=+m2<D^S=%9N}>b{l?2pX-BHBi;r|f zU`$E0!nV%olEKC}btGPv!93qs!aK~+@+}Hqwajo1)cI=>J@<jw(TU&BgaPDkn=<ui zvh{WY?R$PmuJ6cV_7s0;pjx2l!QFHYKkGb^>L@{rNGvp&j10jU{HWm6bWy0_3^;We zpi^;K;ne+`8~c}*GM*{k5w77WyD2ydF?xZbhcWI*bnK^cUl(=<{3lLr4P*t+1J!|{ zgo#ue2YG`Lnky?RBTv~`-EDC#D;&hfhh?iXD?k!`Z05GRNMo{~d20Gt&i#`=`PiLh z+X*q;h0VI62CSJuX-^KT7KFRAc7@la)XjQCP<&K4Y18X1oArpG1Ob^`U4FA?CvLf$ z0^chxbc*gmdg5(bo>Ku2D_N0faiCI0VYlyCRRJ@Eg*$lVTYj@X1Sf|YH)9|H7aQUM zer4-|CKDOi5Z${fz_@S&Nxlasivv~j@P;*Cj+sbEYUYUN1`=XKD8V42r(O%T^1C}B zBE(%)Wk5lb<1L)j_M%VY`9;5BKVsEjvZ2}Qg|+?_ubLUhtlU>lXtHDCu-_h1*To&c zP*zh^7;DbNX!MH9%$mA2vZMmMS4$;6&dux2=x(PrQ83H)1gG&H)a;7|ulfqs?Ded+ z>#{@GtVgUlFy12cf5d7;)+X@OD)6MtRcNe)XHiLX&2=F%2k?+fpL`Ay;}{XBz5(xq zbwF#3d9$A3os4br*H_fdb_3kWlm5u+7m!|x``mi-F#_c~_24`MN8^XdQH__s0P%{* z97?%$rz_}tdH;hHuO9^8q~zhMwr-#=SxK2hsgns@e0$*B^nU@H#6^sk{q9kWm*#7p z#dyhhLPA|HX|_09Nm*2FUGFq98G+GRltJf@vKtFnc4Tmty_k>cd)bRIUW{y!sRu;I zbnxrFPUBtFH%@y0^RRDr8upzncSsgE;=Y+>SV==IsgjqULBTUzXYE@WZ*&TPt<I%G z4H3sJX!mk`Iy!sPzg*@rmkm0YMq})((@t&sJGso$ss1Oq%>O94;KD~<%7bYcQC}f* z#|LRIOzq`*g{64w!JtxvOwOhzCp#xyHZX)S`(o<8Rg<F#$#$mGwMLMw#JZD29Z|e4 zQNkR}h-$`r7}!l^A`>daXs&65fZ_Mxn#u$%^3-Sxe1s+vg0u##P9|QFLWZ4GoHm3; zh)Lr$8KAXL*M*arxCsFu8t2|B7?gn`dox<L79vLAK=4^X;cgf6W?1&y)7#=R)7!Qi zZ62}Yn@_2+SPSNd`Vs$VVyhEbT3*kO-uIYqz1sfM<<_!j^xEj$c||pnK3w%mko9R| zY>9{4sHt)%wE4@aa`Ba^at-KVDget3JVB7f=Vdg0YZA^5S#ihfH+TAM=sfzqc~uKN z<<yZVuu09_V%U*qNg*B<i6>yWTDK4Siu9W((>ksB^8Tc|h>5)67GBH58LyB~>fsG6 zf{alZX;+csvrsh!M6xh{@}Q$@S<bB_W7qHPm?J$UyIvAy6U)yQV&}EQnLR(o)`B_G z&t4vRM<hjLGG|3WW<;_wdj_7<s6DrpNOy}5ag>+ax*}Fi!M3Cr1ach4xUIFzNS9<| z-ca9(M*>RlA|6?cl3}@C`=qdjnW+ULjwKw^AW8t4a_54AHGv~qmO}|1<6W(!V&QZy z2f`<!g)$sdsySFIW-YqH%)L24wEPrqQ=w97fMSjfx(MO)q~xTz^w0r$5Jk|%93E%E zKU<L|5t#dwnF3zmXS3+<Fa>;4jvQYU)N+tj#c9K=<v_V6%X|)+lV?3d5JoC{k)IUC z7o1K6YLbIN;MdOJdYU72E~~?j=gOJ9&}LEc#%Ms;xav0RV@M|yDgf#%9sO>abNh5L zwrZ%8J065zsfe@WmMN>&^^ZByjGZ>Jnuw5{`y_!LA1Xnc%1)bgU=@PEWhPHgy6yzm zUS?uM-foXVtVgV~^sRd>4ZBmV*t$F>!aA$*>u+8juuz;|37L&nL7`#zY|9EDyV|fg zbW`!<6ReZoTu~jLR6;U^xyQ&jbL6sF)V}7uV%F9)d${cpPU~H)(^v4=uV9_dDBAe7 zFs$9IN37FjO#4iY@Hu9P1)^ZXZ2Cy=trv~x=n7zES1v`PsX_s+d?$={XhB*V8HI+= zCcY?76=iVqVS#j~(9^UYD@L?e#a2-)IFxjLdUmje)z#PpR?+|Ag8bZx;HITsghN;Y zx2?$|%8*oLu2V(I<*>Vf1xH<Bv21j;!l@;KorSMW7Eqg~Iko#2J_N5iyV+tN-qv+; z%vM(s>jpXwqvsJ|oAmDVx|%M^@G3{j5r4D{mSFA_jSjCKXue~-N8c(K?=HqOzB>4S zmsd@D2}#(2hg)sNywO`Hyvn|Dzg38JJqm-C$nrAukoGZiP$LR%yBRUwMOW<`z|~l- zT0|x9#v9;j;$gE>Rs~DqN;w4tMbLdo-36SG;~L1Z?xI-h|61!VcPQvhECl6cT0>LV zj5jJTmC=KJ*dsb3zE=nSLQrP9Rfo_{+zKz?h9di+Nvj3=sgahm6Rno|fnEI`trk7c znBOyDr-HB(mBn3er|3saLa@d0q&xP^7UNuQQX!;lG6WjsgeROaoE0H}jT}EGimp`r zyf8r_(AfyNrrbgj|Dl9j!uv1p(H~lf>or!U)n>b5=hxcnOK-NwHdvXlr`&yYz<D`! zif)n;)m)Zs@Hjq{09hBzT#ku@<FY&$;mt<q-24rAvun}g^j=Rzj|NuZ(#rq@BsL|_ zLX>G*i{$Ivh&;WkH3Wu|X7!}Iw1ZprCgCNhX`2jNsgbn{c)S%b{_YUD_{<Qw^*$To ztH!CTN7SryBFg%3e{_0|zx84o;tT2^>WwyAn9o<QgddIJ;9;3q&K0I4LOcP!U(KJ3 zugsrY(5vy-zYF+=dERW0E`nh@%ytCQzJS?m*EeWZH*2U%N{6tAy1E6tz{GD)DUV6x zmnr2?+fTM^ZBFCAPo@IuHdM5aQQR6Bo}$06BExa{bG%i*IeMv0xZs)kxNpmwzCZO6 z__o#u94aiv?C#X4|JVQfzyIfd@6k&vfn#rcU>!E1wL=5WFRN;#<*mpX`yRZc3@fXI zbSutg6!@^S4XtbEBU}+6)O|J(Q@9!KMPUIUr!r;MS|rLdZ-+E$W`9yY!+FSTUQ$sb zqNQx~-n;Wt8_$YUbU%biLP4S5$dij(c&66!15u@VC*JUU494;cfZL|9jtwPFvy;24 zqHx$qDSO1DR1^u!s`v~JI}HsJB!UEHR7wYtzv0bWQZOYs|LD2MS*G#z_~P>XYHD(! zD38kIja)RXL64xACG;-3rJg44gT#2vti6LCSK=CLqNKrP*d<d2gRx+x0MOeY`Z%ni z$fYKebITfs&vnfV>d(=Z5miyjjdJs~2?;<7SP@wSx%{N={2nBU?9@9fNP}PwcOtS1 zN+Sg+PBCH+MsG-P%TN-Xw5k$Wx#K#aVsv58;0@0mgjAJ3>JyJp#ZimQ8}Nmd;_LTL zvh61t`2f<^_41lVU{nfQ>fRb#t72NKA50^X`I2uu)J9#%=a<pN1w%c*#Wp56PXu%& zCb(EVuoiadu4>#tKG1aj`uG~H82aGhoigi>s%U3O7K}S1dUw?0=a@M$)RJu1MZwd} zAdEb_e0iQmT+Tw&E)UX=Wd}haD}@?9uW3-Jjj%Ti*Cbh1TJeXth(NP5tt!7sLheZu z$)mt=QAQhGPIvCtajTlAkqn-M*S4oVo;7m~J;PAsTp!;d>u)v+jhz+B<p$b%n}K`- ztU^X}Q)-KcV6o8%xG308?c;ibheEUywY20b3aOG|S9js9T0}=pFRT<}!R{`{U1dBS zQ}r3Jf_vtYIuh`x4%6t&s|Xfa9g8{JbiBFo*RIT`()k9Y_9=g@242xf<IAlL`mawq zfKA>av19%@N$5Cz5_0vI8d3`4?*s)#4(YCkt$r#uK{@zy(n@k9q{RBnkFUh_C$E(l zq8hlZuJ?x;F1p=pQ$vjI_$*3a$k&U(QL6eyT#mCSVLCFWpWUmbL1jL!a?<*6_6BVi z7Xsx3$7S9;)+hnlfF<QIU9cCsI1tzGr2?YcR^eY%&t28r+Ad&?+dw7eQq^J`Mj4@; zS6k>ZE^Qt5$n11)@bu`ZbmmxCavG(znpkjvT0Wg$_Hs7n^yflu!pSa`rymeO33wfa zBWaSnx*`Kq;<Y@ZorVGD81x2EI)G!cckf&xjz)BEhUcCdIu@T9I=0<@+b<cn6F#{g zZNuJt=1s3VpyZ8yUk%{%M{|GsE#~sKR??3)kq3Jx$n3i`^kvSLobLkDeKiU#zA_4J zLC%h0)z>f`Hefu>XnPdmE96ZOrduI41=HcxJ<Z;D9OCmGVnLWrV`tC8bT4<gJPPmm z1*YpaM=v#%^bAaQMf+(GEbGs%V19(@=BBW{YWWmQM`s2;uukt(UfQZ+x%E7%iv=5y zj#|j*Sw*5n9y&&H+n>vUXfTrdUCu+dMSbnzbe2`Cf7tUQ*Do-WEJOHqBE0@)r@Pzz zHv%sum#p<S?yuztrW~vkwp|&;=5?1C%->jvhe&o=btKn!eFyV+kljHNEZ3#bl)k8P zgf*t^0<}8Y_UpQn;JkGzZ;QB-W;zgKB2wk7Cj`$CpR_-1xWAH+_9%37qFU;vXr`O9 zoR!fz0i`n8QX70s2dgE4j7Xz1<d$Plf1WAE_5>&UXO|kp(x&F^3~vvv^+f;ZlCc;* zB;gxT$43X&x8<||L@)Ko1r(p(P^naJB1RgsI)Gu=tg_>12th0moCetz>`uXR3+4y7 z-b$Z9Jn;9RPk5Fy8?%^0#-V4dXU2LoDBr@8Wy5wwJxG8}#L6}Fl28%avocTV&pNn@ z<DX?-RiZLTs=&U8`bFRr)`X=BA0{!ejc*m%C<3M?gLTs^+ldW-Cig<ucCdc46@{?y zv)7Y!$!IM_L9uDCVqu}`Q~|@Pq^h)Gee7Gj2=x=4`rzHI>l<Kox^ZvqfCnA)^|`cp z5WeOc&-6!|pEhG-{WgB+aaSvG;=0i(Q+6ayqyu!)4@$-%vwbQ|4fYV%FIDP37SIFb z=DoFM;5#~LH?c!5qR+L5>%HDF_JuPp&N9ObLIP?recCU1n#?LRQx>&04>GKgi1;Z& zMb2b-&f}Nn5-W2;&M-P|5Py6XFF(*u|A78gUtBxh3--tBJ8R1{CU@g8wKX1RU44D# zy;*enn*_4@W7<k8eP+`svM{h_zJl?5&fB`{xQSKk?)v8fdRY$+TY6P*LH{M9B9ryH zQh-uzP#B0rfld{yp8MSssptf_jwBnF#%T2P>E>n2U2=)W)$`LiS7<EM5}q&6SP}T< z@EN;+w*n0c<R+u|6W7n=cei1GcbHIoYM9V^pFgfc1oYF_ht$yZ6x@vm+>V}j^VRfv zC3d>&*V@Mz&98R7M34LKIxxz%?;0%k)jXm2(mWxJg&hx<2iS9alj<w{xFak#&^Tp1 zz;Z|S+`IX4M_A4W4cZ-Gxfj`U?_|iGU^%aB3YJT=A?i6;u96niVA0)%<-RV6eiiS~ znotjnOHdt`7_dYN`g8cl&hQY}K)twF>GYMXfm+U$Iz8p_g{Ib8XE!ANx(e!6_t~#d zi^2qSVY9h+b?W?w3!AFm_SdJd`Btn2IX)k(<)4GK1R}<n0el42`YWnKJY{Abc53?^ zu79nHL}Ok;4_E`G<7zk;H?#D7Joxz{8rTw1@yBKd4J%oR_+P6Nh>V4s>O~@cW_%l< zlH<w@{QxTeXh7vA_52(70RGV5hX7bH4g{bNlvD@+4!LWCaK<muNQ;EqmM)QxS_2;} z(vCjFR!y#uP**Pr4mJE)@CSC%ySml;;?7U)$Ts(^T=*T7t4#L08vwy{quV95@_++G zsZ2eMVQ)>A;dEvVeZYsacr&wjgSj&I07zq;#iTv+&Y_;H9O1KB$c~iI`YBiIsBj6H z^A;i9B{v#1FZY*l8}mwT>?FF=LmdyR2K8mM4!^@y%nKXQ`iyP43byH0%#bkG=TSra zX`B2PG_DXIpmDi<;T($A9(gRkP1Smh6dUBz`--oHV%GI~VCuA%Uvg&{zz@kBJKbuD za9x&_PpGp-m3YUKb901OEA6}yu+c25ui=^}=~Z}(t)QN<;;SD|$2o64+Qz<$dVVCn zsE+iPEg`U;(U@v`2(+RxUs0rfH9-oFlz$*WN?qOWOOR5x@rM$m{LjMU!d}d5)lche z5R`U*lWZ_!Dx~tAsZOvqpsC3g>&G~Snm2c|%DuO{{gFvo;#POHNZxsrEfTN~Qijtr zI<RXYcp1?(CUcD#RYX%yBf8R;qN(W>(bTu}(1Y^-Kd^^hUES~7L$7Y*5AC5>9^j?3 zXFjd1`59H-|KR55<$O^eTh1l?*m9a3PP)_Cv$YE2ul)|K!Yb<dd(IxECewFzedO$U zLQ-b!iXCT<pVot5x5=lo=PUh|^ooAVTPn~NBm93{1zKI*?^}VkH`1s-sRI4Jya%4v zC-3>>J^zHf=c!i7^h~Sd`|_SI5w};G5<hv*C-3>>J)gYillT1Xd5_}zKA!hHL;8JN z-t!gnHvMwu?I-W~<UOCf=act*@}ApgPktur$-ge=$zPm0`IGN_@|{n<^T~HU`OZH! z-^tH$4DwU6X5W<W<S#h}`K7_EpM2+&?|kx|PrmcXcmC#l=Q)l+erjyZyK<f{IR^Qc z&xrZtJ)gYillOe`o=@I$@9cSsW00ScV}4uS^A*P+zeV`?llOe`o=@KM$$LI|&);?S zJjF4{&u|Rhm-l?dG03lQ3_f|!C-3>>J)gYillT11d5>1Jd@$?zh1|BUPMu%PYxCy4 zr^<Wt9d&iTZ@!~$;}6Yu;!p1$$aik&V}<KayxSjF>XJg!pF|$L^&MqexUfEysV2YP zK>Pp2Tt7wMsE&+ut*Q9hIqKJ}WP1P0MaF3hh0cbWNpmoRBTto24w|@Fi`}gCr{#em z^UN`qe<vvs-#18bbChTsMPSiL0^t178t4RRqd>aoO@+^@BiC5?-rpfxTF!8Fs*bnt zZ+<V!>nKzADv@kDypHh}(2B2P4G%&<1<|L%gKM3agmIB`Ae}a(tL6)~Ws0(28+(ZI zh_%>tVD*f}E>~U`+Z#iRl%0BL@M~?}XY$ILlLLV*mJVNUaE;;GWY%wh1XoZKhrFO{ z)yD&N{q-Y^2(aHvR}pO!I>wwk--Ol=A-(_UqHLw--0SX&0x1ac3yije_eN{av2)6k z3Lx-^nnMpUZ;!J5|9JU6aP<Gve($R=?Jc4o_G!VXFGH+X0E2-9DC+?du$#=3n{z|I z46$AT3{upg-2oD?ugFYAyp5Noq)wq*RyG9*cpLcUo`VDo$@2}lsaudhlR2$pb6mdt zrC`RJ`Qz?qiFD|YIH*h0zcgzB{{pj7m!l(EnTpUvlgEO~KkGP-e0CV-6gRAa<Ot^o z^8VQ}tcKLL|9^X5qGLyL9QXzPhu&EjE7|IH-UqY-)|NS510Knc1g~hzX!MYeWUu-l z`j{EcSo`gpkr7cDnOXJvAZ5+SPk^N6i>!=1Bjb+jMx4u2W?N3*@g3;+fMrB*aKbpE z@{*-`22EL7P47f_;x3LT@TKtLDf0YM<mIJs6CeBAnt2^}x=d5&)tw%9F+=*qZpD`w z%uGi&cVvwl>=`d)-~ISP7U9g&0n=XZc_GWf*hE8t#PMtM{sPjC{@VEEu>al7`Rlj4 z`Ka5%_f;gz(`8dmkp+}SFbdb<vGT4f*AVhwTHu`p$Kojur=~oVTIR4<nf4TOk`}7l zGI~eKovY#9q(st90f9fh<Yq4*M|~7!c2Eri231`ziLpy&Wcu+XH>=;aieQm5BbQTw z*F=0vKfdH<6JF!#>}6zLO_!sb@+M=m{@cp?k?4bYHznG{GDyHQvU0>w0)R=N^=_Ok z{`iucO;{CIOh?(K$68AtQlkMY6bP(Cg0$@8r}X1XZZ=@`bZrVW#BrS<Tec$N80wRe zR1>Oz+(Zd1a&t?#4@s}7@`0_H=L>@uY&(uIQgK7&#)Sg@i8}T**<`Z0ji~?wL0#fx zyp4Eeq#p^4LA75cGvB((mq7`nnh`yfRqUAhh)^gc038Qe5>jIYgz}WsG~IATQah>% zGxD19`rs7_L5wN{x+2i*MXmIh#p7gag7*UUSj*GcRtFM)e96s*kHJCPBUD*G?w_ah z@E|y-Fif~6^)?8duV%R-mZZk0X{}nhSy4mEQ*{6-J0;B-jt$ipwW8yYQwJ47d`&}6 zHE~nbI~4K1aeyEuP<3(d<G4}*a_-BXlg{!$I%_(-;<!TYcT^q}_N1miFZ1&v`Mb^} zCTBC<Yy9ygHyfxJ)CNx|XQnit^u#G_D`o9ym~90bO*SJ9!yjLAv*BKs#~GEz<+`|W zrRc|(+-$&GE)h~2V0iP07k_-o%_h9oQNDW0cPyuiKfdH<104g-Fd>x6RmxSyA765_ ziQY%9zm>+Nq90#UtKmyXChrkwvmIBeyfU0`+*d7uk2VK>!2OeX<hUq@{H6x8G{Wi{ zU{l^m*!~C(xl7(WGFr1jX^qih6^2wcjVi1a%huDZZ%|Xla&eh@qI9x;TNA0H8_j)- zhN@Rm3Z3c4=uEi#S!dFZtQHFkg2zXd3Ox533z0dKR~Tht*IzON{|H8znDdv+uJ`*l zxuOV0nRG~<VeE;^GIT#I3u%yE@&fE(l;cTcHCp!TqTo31ay2-Mzr%a(n~9+St(=;& zd0h>tT(W}A%v^wjmQpSkeFv{TE#*=NqV*ZD+JMufTzpCbblLqem`1|Zz>cBjcO%59 z)rIlPI@`5%E>A9&w{nFAeB3%iF{Xe=(rQEJWb~d|G^e_&)6^-AJ5~EKBb4)|r4Ct3 zDMU&3EU^k-m7dceP)|NvI;TO6{V~eZq5JW~k3%arJ(VqKV4Hj0s!CR^RfZ3>N>d%H zQtOm|+$gA=kUGK6YgzwEBLiQALN0q^L@|wk0x$ltzNDnYFNAe)@cX1r5i7PGX}>X? zt-mmySSaGt+w-3nLzAABr*oVwS@qW!s=O<y++E2~#ts<g!vw12hvI9}C&}UYd{y%2 z#zvu={JzyL=tuX%tz9rHm7inR|Gw8QP?b%Gr$g^EOFgVq7Td1jW!3naIh2H?pL5}F zxbmasN<Ko@pq1-@(Q8qu$SC3sHFm5lJs6K)nh^z5Pf;dp4X-SnO0sBEKQ}0!Vxk~H zF*5Uuenq;7EbD6@Gzp^7Z9iK5x*C>nqBFy~PKIz<sA-Rrb@?o6*{S@nhygaGO_cs5 zp%7Ts)b|%{%aFN2$2=6_BVLP`m?Z10E2@C$eIU-MjgV?fmNB6IDTG#YEELj~JE%_H zjQxf(>B<{rv(&N{K+@C6FG0PeWxu5ZS!kR}c5Y#Hq~jx7g|p3=57L}PC?0X)b^tO_ zavj>xs*QqL7TvTYT2XG!B~l({RW~~NCiZzQHwK00=vKDc==mgJZL9@v>0-GPg?fZ( zkp*5<E<%ku1JgCC)ov}TOTtGwNtV1`r00s2{hD&u#F=(^TI3*(1#;rKR_J>HtJ;oR z;fE|~vYqz>)*?6f9&K4T0YzoZ7TS#WrO@4~lr+IKr3pw{#L}u5hD8Q_V(hlh#Mtnb z3pku}i8r3Gb;(wi)MPEuM#q{dc4cX3(eQyC1JIW35x~G(Yl**fM#gR!QiDhI0tzY# zQb`3Ip_VX~7W2A$Zgo=>18YZ(k+4_4k!H|IqOe@)80jGB=J6HqTV{7~oHB;#ITfsL z>J{k0pp2rbDzTh{cA=oIF<BL@&ciV&Uj#bWF5{<K(rPpe!?{*@yibX$*#TE-GJZ>B z^(owNG<1k<-seoNsN|Wq8*lu)$^&tZhPBHE<wPB}7QD0$=&4p@VDe*2DYemfOT%%f z@-OE}*knlXGR!%YZ-eX^JI=nI#gIcDfvA$6t_LbtTEE$6@dO&4--6XoSPR)kMVc{M zkWG(#9FT21;>K^BacGP}r>~~YddidAIOWh91s0FnTg~s1m~&UCOi-ezC%lt1D(hSa zeM+Ux9!24k3bUoRhBt$|xk6!SQIm97Hz>pD<@mcLuh6F21jhl7=YYyI`b@Pi`;(t| zh^FezAHiZ(8zX*U$jahE+S*Tejp?+affpaPje7wcp~pL)aZg$iU0^Gbn3U(LA_jsW zo;orO<!X%?h)KDgXv6oFH+=zW6eEmT*^`+wEl=G-qYV==kP{q!+qiMV-Yw<5;%^(? z!W(MRE~t7R3m=>XG+8q0Dk|<9o9W!Jkw#VXA-t2(320)x0cp0x8^OFUdp6!=@z`ZH zVKd%#nL*-Vy!GiYR;V;BPqz?nWqNX7xt9(peA@UUmCPQbi$yAE<bZOkJ8F5dU=SO4 zk<xKsyE%5Oi;OPJMh16&6|LjBmcv|K40K`prQMc`NWx7W8Lt?+&C@|th1cwFx`Ea+ z+El5j_Dy_p>}z9d=~xv0r0msg9TW)8?NFfNw!>;#$H|k;HdH-l`M~K3T9_R-GURY5 zbhpT=@$#^F)#UR4+VV#&)2w`}$_zj9&2(g%Q&vEA;@v~-oDrp0xnytoHgkdNj?L*< zB8N4eq5M1*;$<cNQv~B4<8e7QE^ZDN>^4fWk^Nkc!PMgN)<Tuevo%t(*F^G3tS&N< z)hlu{RPhas=iJNBY)G4+{k0@I5c?&(ls##aK~BROvD#(9{#zE_h~+h+nyx9LRhH21 zu)uSM9ix#~L*3pH7^)O7olqBb*KeVgg1%&SRUxE4+pUvQ$W378ISp(D0EwT^dgLkq z&EgVc1y`}o(3jR2*;}}OPpxy_WYZlu7IZUIR<A5hL`kCXO+sgsJ)H>a$a@8rZtJE5 zO&b^ztDp3fuS$>d7z81^HC#CB-q@|F9-jao>$VoIa6isRv$YEV4mNG<V9%9Jn?HfO zgVghEAc6AArGz^4vPo0S+;2Z&?gV*hKY8v1U`?ZAGEg5#FAJYLMPhM8pV9t6x<GeX zqn%uvoF$YzrbzPjLX!8S-mUr{s+#Ua&nD6;qgbi5&`uU~p0q;&ot}yiv=y`pkM>}f zT1}WxNHQ9q44T|QP?i{3B+HK6lH^>l#yh;{M0<n~T%evrK_4i>Myx(+tLP6{B=1J+ zBb&Um`D2>VfPZ5~%4MpzF4S8&cR&@qkmUPp8ST4IAMXpgK}~i^G7~2gwS+ocZHMfu z>lA#3geHypJ=MItAod8QHB-5Egl^^9&?zf740bK+2e_R%rnHqM3$863RJJEFM{cUB z#ZbYG3<R}?%F;KzGu&75Qpsf07CiF;UG8QuTHs}cR$%q&=odo@be~!P)~C(o@szjb z(<IQSLm>~e45H8Dgkg=>7y5Ps&8_bbof+nnl$Ls)7&@qPQaCiMl+s9C3%4%K3W)_5 zk3DNAR3E{SRPX3$<QgaRDUI6CO3sy@RRC<9ZFyG9^)*{dbqv?YY_2mHobtkUPn%SD zjl$~stsMs3!3kM91=5bXNNkP?X3c8;P-d|7Nve;1l+|2M-F=TjvAWS6Lb0~3?SJ}E ztU`bcNxE=hpB~J)aVi6Z5tD$8UPnc65qA-d9zqY1t$5v8`yEhv48cqq>=wk*TQYO6 zR>^`C1A&+nTW0LItgpwXFLes}MC=GSn8T;dx4-Zby3?v?ryJJHY}^Lctca#zJc1V7 zHPB1X&hDCwUG3XU`3Qt!D>n8K0*5BWmNXi&av047I^-yxLu+~ygH(z^)K`zTeG1B7 zv#C9-(v~04iv4lRV>n|4y|mp#Tey9<sXc@p@~jF+b8*s9;0-Z%&wCNMw~TwxTG2C; zS*@Ppmf<5(wvp0WQxH<jPn6Inl*eFh>I~`K_^XM*nXSoJaNA22IIg_<HI@xhaYa`J zR*po*Z4(~SRTY?7#NI{~BI|e+U!$nA-qNFh)aWTj!8+!wga~g`cMeSuij=}>hE2UL zaMO`=2VhotQAVtlAV7-vbw~Cnw`m7+<uYj2o}g;Tbq2-mIJl~9KxUte0m|<)KeF3K zB=uH|Lee#S;w#(ftdiPVpU5T^GbvGLACypS-jMPkq{&yra};f_5RaMqb=8N)`4EIY zYEg_5(h$1IETW97pEk=ujrt)cln_uf_u8#=Z0ou?FCtE04=9Ssio`gpmf+<uf?`XN zS1_JM#g?}f4IpS)>7IaZN!6gZ&66uN_z4NOvO@B;nWl<5zOs@^EK_9fl)$Mv#I}+x zqliiYGp8se6whAuW)NdkN1BR+DGXxS(Pbp7e#qKvPN`7XO#XEqMHO)w!G5MXXC9N2 z6|YV6t(ts@06#}bfU6Nu=gyUaJlKpUzYD*08NrRgaR4P=dPpO&r9B0^DBBAwf2$nl zOnFKmM33^gM#;sk@q^>HGI?w2K%1qz2UC`akpZgO23O1oNW`CRMv$c0ncgd^X9&m@ zXmtZMF_FS`CX1I@OB=_)holqlH?iib-q~;y0*-00UPy+(Vz_LFHMEXHv;*4IR-L@K zR<V`~-CHj@td3m_3zS@pItO<OnQUld=VjwJouc68J6dB;`rRa*Nf$l4X0NDr$_m?{ zJD)c2dy=-uq&M*j^*{2bMx{IhbqMoHDcA2_VTFW!I`jl%6|1kUfHc+o0t*li4ZJ86 z2BO3pq!Xh>JHJy=3~J3&_3<ivEiV4|$$|ArDGoXmqY^Gx_pl1r+3i=tJ&@URq%og7 zYv-r{?bMvJ>Qt&nXSM5~SRGWhy;62k_jU^1K~>x-gQwIU&Tr|a<-wSg+MVKhO&{JV z+Iv-cuPq<c@SUQ)Q{Q(A`aecS?#VbIEfAAgLs%{*dx)@jeDb_+v$3Z$>CAQ_X$qQc zOll=mtC^>?H1rRat<HEg#@q?3*LE`V*#y^_*=F;dG|;V>{yO8{Xg2H(gQLlDG%EJy z%HAM3SUNjnW@jOlHqcL-MfOQN;wMSp`r9dF<PjuyB?e`QGWqRV_==2BnL}ShaLW*G z^Sp(b0#NGGq_j1@Awb1YP6h#v-mc{#daS)ji)Zq`ti9-23H8&n66*hX*oz*_tNcl_ z`G1tXs3mszKH7`q=nnRx@43B55}=RshYCU;J5oKQYnv2P(8QVAN_sj|YDtS{D&Ny_ z`D#2@+#0A1K5=`9)If#MS+aqR(P4!-SdU*^*_cNe^5o7Of*BV{=@87=B(*~@;{rVd zGq#Qo!Hj?OU`9!t55bIwV8%b=U`Cmb?hwp)2xdG4GaiB&#pWG?8P|sUg9~O1;)ouC z84tmXQ!wME?c*7`rh`d@NBhW}U0qJugUiEXTpk+RdT@C-xI7$O9u6)Ke+DiOpU}pf zpA(Uo|8#|O^8*In{CxB7Cn%izpkek;Q7%{1WBWmu%k^>^f2QSf6IWUCh4`!&A9zMR zw$`m>jzXrnn9FO%Aj?tFw+qzUBnr8V$u4Y&;!XJ>X1l=oQf*uie4|R!YAoe+eHRom zro0H<)BPvPd11M36xQYf^OPGmzg2ma+q-;=%{Gn(h=l2xX88%lAQC`b3QwiQFfL<5 zA^_E7OpQl-T;Yx}2ZxjjxK^(yfa_%J<xo0Vo`e;KQG5&bat_TL@jhOb8d1!$lt-;L zl=a#tN+GRTX7ZTQfOBo&UYrW7eV$KEgRY&pm1HEr={@4aCrd^$l*!gnmMjWfg%L?Y zx7D4<MVd01u4E-4$sSSfKPMpxO_oVIXhQwCx2pudecPUrmA$1i^}K^Uq8JZ0R0X3l zYw>~HB%R9QF$a6nfpjk=-+57px|J4LsqHP_hFN7Jz8!Ty171%7w)L!qo`L#Jkpylx zJc&Td#|55~)M7`D=CWujGb#zK9O}5MvjcepNNv92kV#GUer2UbbAYPuNk_#Y++vjW zgIxh~9UCwGK3uY0zae(<lhOBM65n#ip?VDgC2n#@gGHyu57GQCx-ADF3PsuyLAHuh zlODLvw20_QhKM=cUwW^_^3xfMb<P!<h1%13(~Zd)nQ4GLL{<j{W`9y^hbll6mRcHO zEUU<)C%di|P@Yf32dlhi;#xS{twj-irOQ<|X>(8zea8MVXwdTBNLyr%5-Pt1Q?D7& z8ew_P+H9gV6qUV>7L3(;6K!JNa}_TX+KnS#Q7^_vJK_~kDw?>8H$u7D5%03hg-uR+ zbH0i=Q_x0}?k@!iWj#EVZZpowYe241Mxl5Rtw3vIcQcKbxx><OF%6E%C3zm%r=-#u z8@w#p5hKS}qpymQ1$2`q6De6)g0w0muCo~sC>&rs*WNM}W^-5W(gvE!l0ZNf=p;uj zR~?foQk5s9Wv10s?3DBnTY!O_Gri<#l=Dp7Yb3e$A{w7wcoLtI;FO4zl7*`IhBPt6 zgLbg?7@II#ppLy#h$9KETX(WD`oPm1M-wxS(*)N+AohGBqh*^t^_Z$hu~XJc8?GT} z=7~s?=i(sY{OVu=`HtDFWT{nU7WYw-EVY1YMRqi&Nwe7Mhm{AIv$bGen<CIkg2d@^ zIO$DyLDB6Vd_n7pHbJC%NNoKzY|Bnf{Hu%yK{a{G7$pc&WakOQt3#IlmP=xrHY(wv z=QA<B&aRM2l_jv-I(-sD?9fUosasj+)y441Y@&_TZD|Xys!z}sUd1klt9Zc)ojOJ% zRyln#jD@}1U1H;jpk<oq5m{qhJ5rz?^8Jw7;|XrXCT<SNa{x=(M$AfNw4jkO(twjA zS54`$7f7U0ly*c*YliODUmM{`Ma}{n17b%IBxPkyrI#RkAt>_j>2@_L*Y%sS+*Qp9 ziS}RxK7?4f5d?fwns+p$?nVONC_@qgd&C6N1PMV~DfZXE2dIo!EWJZF9AAq90v~Mr z6J0_k6h$2IS%t0PK~#Zmi#^Wm7?kjC+6!8jWAMqAert=rNUE4s(0)B*&?k!(k;2l$ zu_6>OvBZklEU)PpE8=xKNdGlrMIKWtZCLd~9kiDZ*FkHxW4}?lbAJd9q|KW1w>m0y zt)28pcG0QMG_AQNE~~sn<HDus&K}Qo-7PV))(EI$ZG+|1MP?snx72c<@OCqzWm%f8 z&PeEwJ*zdAVGJ`8Z9@oK69Q;rv=o(4IEW6h_ep5t0|qAPN~cjQ>Cz%Ot0p6~Ud+W> zk1H^yw8nMVSO6=B&8I23^({@~3eX?Z3V2p22NLdAw$zRL#Et;dmQI^bEvE^Uw>Anb zowJ%p5!Mzq`{?A64m@ab)2g<XPicmRvgpq+M8juK4s{-<4{rJ5?dg|t0J08+fY6o8 zlkV|fVPp?ks_T^hbfL%(+ME9*0m#i(eF#AQ-UlEjPY%@}!E8UW4<E$Rl_nk<q%0JE zWfoe_jBCl8#|a)7%c+B|0|{!73_byipkvTl8@lYaiNqj9F<aKlpb(CXS^R*U@P@>a z?7&fzrp~#Jxm}X0qApcfq9EKdcF^QxOp{^VMGcNrUgmAIxmRmA884(XMdN0)#sYUY zK{@ARVN4sV0g1dwX_;slv#ivoBWZ9wS<Yk{U>n((;K*Dc1(@JjD@oP@IiH-CI8kyr zli9;m2Q)1+X0=hUa+fS)WrZ6wawsmv%eI`4pnX>~BJVicr1U>06<|`NJoLiZLE$<q zYp9j76Eu`H9L^d5$wo-Z9ichQmOvChsZtQiy2zSnuLvsjV}bLdQcQ!2M$ELOz;je@ zKI>_H3zS%q+_YeYs!CX)CQ^YIIE`)L6OL-kv68x3ve44nyG~0QDAA{<OrO!E3CdU5 z>mYTgmSuHZUX`reaYtIjKnpAnOHfM&RzfO{nbSnYC{JbTYU%`zS;8x&jSPE9nROwG zEH%E<LwN}`<*rKMnB%iNyDv(OLS&7?C{=qpzMxH|<KmJaOF9rW^j+?O?qw~l46UUj zCt>ZKL{BS1@tWBRLXkP^EYS&T%>-N}w=h)%YGOK*lB%~vq*&3xutJC8IGbvUc+Atv zLL2lQgdQ3vl52Wj0WE)7LA<<W`+JR8vrRP(>LCt;P>Btp0?4LArnXk*&~<FhT&1>) zy)0Wwb1io`aAt(y<3QW0&V{~(q2r*0ify5&lp0oyN|IEB_9WGC8VFChw}aHub1sKK znw}s@b>M6O*^s8EBT_xlEH8i?fon9g3?vg3B7Y8PYIfBF1h<a*O)^$yp>7sWn^w|r zNFHwt)h@^v0$mwv0A4*6J=A%2L7~k{Qp4gx?kSw>h)w8jPfy`&=IAhfgQZo=D7v#j z^CR3SQO?9ak>`PmGR%nRl;`Za@~AG?hoJ+Vvixm`*mF>lig8GqC*5_l;$mVV+v=8< zJ^?Eo>TY$!Cz}b_h>w*VnR5hXgPD`LE@%yGO|?;>R=kCg`9y?5bg<welO-ylt9jJ8 zC_^VG(X1d7*-p^qZg|POrodDJ>41{#+;Y)549!XgXu0SJHC`srHcVeKv2!+wi(|4K zu4|_v%(lC)R>m))wGQU$XpO_n&tbk9ycxolkwOR6!O3UXk+~P@62Nq_jEkhe;&$b% zjAbJzpBa~xxN?faIXS0w!z!)~GiEM^m1~1gW3m&M3N!guPgK@}$*6F}{+fM!<`b+A z-Bo~O);hbbyKr1~OG%SSe;FWofOa!Qpz{uP1uu2qKJ?&n;O$yA>_};CAnn?Qg!lze zwO<>*5Qe|IIe-0jH>+fAImo~kHziRyw27{8=N!HiVMsOqaNTmFCuo@l-YVP7X7uAr zZUzeS+-&24Q_nBZ@~xYC#%5rSv$9a$0=3AYO1$`^=vjlpt_cre(Hic-i_L%?H|_Nm zQ04Q87k?Bz8!u%KXZ^!yu^A-AQ7%nT%R%4rTl`V<Y+V<ti+RdBym_T(<RgoaljrR< z%*9B&_@n6AS*wI~A=~&cUTjvr6>cyRYLU)JyuL;=*0qXNIbAr4xCYhHZsJuG(bs(| zpk)0V@p4TOVq_Y_=c|<m?=e-<X`ZQzG+UF0BTLsD&KYY>wt>gSwby5XmTQl1lN{3` z$e9z&{uGTAxV$H|3N0g~dR*xkNp9Bj&R6;rW~>+yP~G-w3MVaG?hp_#ok_ts-P-!3 z0n}QN0zyE^GSVONXee(Iz5&(?9fjqxOscxaZQ=E`)<gL=3T|9LRhVcA6r`YP623mt zHVd}dP~8(suD^xX)!~7UkD6(TvMhT_yoSVV@P4TW)tTIkD5fUIs!)#(t`aZQh#|vX zr50K>Q*reG%K|uDY05;FtM36&?2tNxA*W8GxOXGn{5&V1qQn$N=B`ScNcD;1*lv%K ze>q*^OQRP%Y8a80Z@EN7CaER@H;yl%e<~+1VS~)9HtVgS9s|q1G0EeT=Fl}R4kV)p zZfji&4^W`8+dyEb$x}Iq^+d|P`V`hH1fK8@un1dEeGL~!0_W3wn9a%j(u0If-fW4I z-*u5mi+kPlh%DV|VslLw0lEOK(KAxZuCQoHgSwb9E-7*~8WQ}YjE7b1S87O&<)zt? zT+bM<QBBB>C(e#zk`8}Z!@*J#6`isbJiT`mIhH8Rkm<z%@>=K2gr-$^2;}g#;MFlU z#vC+0dUI5^&^>b9M@1|c`WsMjFdb=W`$rGo5P{Z5A^lKZlU20fG?ur}g71RgL|ZmZ z#Z9!9Y{=_qHMz=2v{CrGp{q=XS5Qag(<WYUuX9^?K{@8l7G6lkVB#iTNVqki6)S~# za8_>tIB#$?;tJNpYV=jCij#`2poQt!u!%O3;$|H!L?Guav^6h<*+L6u<hY5JwYiG@ z>B{|z&!_h_;UXf7A#WPzQemkzu{9eB>bL1C_^`8cmPTEQ?JDUR*8ek9oT<b*^Mw=k z(SF2yM{LK1BDrS&8;9DxQ{ys#a~`UH`vrsF9T09B(883ke{10jp87W7^rc7_MYN}4 zzrR&k!>}X*nS0?=FOs?%I*SY(?uQDUs0g37Q|xTsM5>!B;*69FTdg4_K7Rvg<<+-v zDjv}aPT(WCn&*rYx%>^Bfg)^HkycJ|3uj{G#v0B*zFn(0Jy&I0la_1sNj)HKFss8B zPGs>na5@$uR&f@VDw_?QVVq~#UO@{rJ6Kz^P8sb)f|b<oD5Q}|4XX2|(f|~mj$M{3 z>Cj2Z<fSD2`IDtmqBOV!_7NZrZf<&3bJFW=jI@erF8#SNCX)%PHJI=)YGKJSODqN3 zTe|c%2z4B_W>gS(t?7;-WPkK4P_hB``|cu%?wE?&<eIMTxn$JhvjGcVm3HgT2HJa3 zDh=z7!h4<#2y2er!;o|mT1TDPA2^YuEfwV{dzSpEuCEd69F|}L&UWd98l7JVu9Io3 z=-84%D3Pat?J^rFGUjMUX`f|MU&D$}M+xVGpLaLn6<Xh1WP&H+g^@-zi6j<}jIzWZ zCWQv-s980jS9-=}bSkNNP)i>8o`9vL>T8uhY)YLa$WT6T$eO%`myMP-h=lC|YSk!g zft|>48s@5!wJyo9?Hni}xUwuS&ns!kWwKmSHIE9};OP<tmTyC@st}pj8tiNcw9ap$ zMGhLWzGgq8)no_h35rHl2bx%g@t!>#s=o$ev@=HJo<XUmS2h+o-~pwpwmURJMU+XK z?GU8Rv=~>IbjB5^NB2&n&4ibj>zWQ$rxmExqomw=_O<rr@U4JaGrfCD&&XYG;Z2n< zSz$ptVN0rNK@PB;z_gARoAoN<1`U-rnI2rqLCif%)pT`n*i;S3o^={k;tlHA#?>D< ze9RkOp^8_v0`P-qsZOx*VP)@K<xr;GwYrnGq}@STVm{Ud&!uN<*4sNIRE3F{;Ez%k z6LuB_68xs1-Fn7my?v)a;Z{$?!~pq6s5WFu1o9|e<WK4m?f&8!#h>bD&+v%uCk|!J z!^(cps#O`QrIRoaUrI~vB1S0%GqD%o6zv{#igusCDf*Kn@OqBh^CQ!HX=3<RouVI? z!0UN#&yP&+g>FY{PSKw@f!A{!pC6Ol3y0r1Mf*&f3f|GrvAAR6u9xH;z3mjexY@=& zQ`j?{qDPNiV`QG3gU4=#9z1ptdhpmq;P=pDcM5KhSsV_*4GTg06u}LNq~0j2lr7G< z&TTqH&n~-KOPcvda@k#R%8gpmzJpipLK_cWxeIi^SMKQEua&GWb#U+JEBy)F`#sJ_ z@=u*l@5g&RAN+vD<Nm|*1C}oE{VM)>`?I5hQ{?QeED4{+^sFq((_J_QPA#s9CmFM; zK&>I67sS*~3mCE#R4c<;{s>E+qJATp?A{C#-UgZG!6derQR-3Csm>J}@iIfDPKph> zQFHLU&>6eMZ#bkGYBRgLDgoUPI4Nfal*l2YUpuO%{F6**sF1TlFXm-Yg|3e4(j~o} zL8%d4sJYx;bOo}&is-WFGl|u-EnRIKziWjdFcYgt3e7OcFPX-1f=`u5v;g&Fg?^mm zm~DJ;+^K*;XPP*AiL%UC=BOH_WL=1?jU?$l?#Jh9DPR!eqVogH)*7}0zCsYRNDonX z{l-jG0e3GtgHnwNIgPt#AluQ14P;xfLne!)ZK-ffc0W2@u4#4AHO(Ef!HA&s<tOdJ z(m1p#N11lYCeC+9={vY=)@lJt7l<Z%Ls`H!D@9eKKfMiHXrkrihMioBrjevnvyE-s zze3YJ`2pCh#~TP`7wH(**IGluq!nNsAKb_`cZ6A`Wkg`sv^FVFZP(6KTXQ)xO)Dpp zoqJFIB8KDuncLA=vQpZ>)kGxk%h|~sSANanNkzeBff`9nBPo)qWi@O`bEycpbiv45 zGNdRR#SA;bPzq|ufX1T><@{+0HRS}z?5$?;)~G$FsH9rM(AYgIJ!BSD!`1sDDG_|f zXz;2eMQI|FunGs;L5)mLm-xjm(sK*7TVA7V(o*D2tP)hxq^}aDN3(u;dfIpxYP1|| z#@&xg+Pa$0t>N@CP64>SK+Wl)3SFtbB6GQpg+y^KR(JK~<cT~vsXM4n(MU7NQr^Z* z6+c{7(=~Td@{x(vKxnlr{Am=bDJ*zUzSWN0w_|swlZ=#bwNyAZC!Jl*8rtSvh@7lw zsFqy!BC%;}T^6mYQ-_o-as-E}uH<X`-tQ;J27AdH@w`wAVL4#zDX!?5*VSy+xTyX% zkzU3JiY>45Cs6PdiF^p-W2+XOME5)_2z8|=@THxgWtMK^NvgT@^*T-<HEE?HvgP0! z<q&6<>NoG$V}-m<^3<!V`=E1Dae&3j1y2|gJKtC|<!UYE?@T~L8Cq>jQ@0isD<*Y5 zOvvs>H<gSoKZeA;Vi=G&aqDFbE%1k9BF%PbXSSu+YLc81Mmn;vhSE|QCXrGzv@#rq zvV3Z@d8}g11zcNeN2S_=pXQIwHYT>b*9-&g-^>D`ulUkw;qjZ>SYno>p`6d0Cyy5J zKN#4cnuB;^w)x!z$4OL>35O)e3_(E9|BNq$ENd<v2uCWPn)efFVYYT_hYRJ*<b~pi z$osx^xA3m!5=U1H&VwGuRVeQa%BaCk8To9b#S<$ZmqM8J0?BNg0%-Kaw^FxITG`N- zBTC40sW(x2Qva^wgb0qYY-vj_NVOw+oaiwJe-IPZJ+a+|(KVrBZEQ#bYGhZ2-6E(E z+W_UD2rk6gUl_T|WyF3#M5+h9`PhPp%Hy)6?GYy+ab1I8F(bVXLd&K!>AvY2YbyoP zC9t9Lt=Wp{<j9l7cP?#GCCzE#%hc&j%-c(xxk{NP^PCny%t>B1Yotg87zs#bDWql_ zYi8J7O>1VH)UjC3LypyaOq2#ApE$H4v$k4lcN51ra2ahccrL|dH<Celuca_AG8ub_ zpoCT4+Oz_+gY*G4I<nX&lbx(I;yGw3Y`Q#DWh;3Dc{G`(VAkeDM5MfQGIY>I36-LR zu5+pABf1I|xl_+TR^F?oXoApyt|*piu~;=nAQ20d-S)J+rlBd+gSwDcW~Io^-poza zfi_8~5synv%dH!F=-5gZMAV)vP=l3_7kL&lbb>$i{7QtyG(1d&Mho%P$R)UrYZbLS zA(8+c7r3!02l%N;m!Zgl#JEvT&DUZFD9mr=fn6675(Ef0p;_az$FRi3k0L&Ex@tMs ziz%1ZENdq62hai-*}Fd(&iXFPNiLc-(){nKCY>sahT1+ybT4iTK`jL;A$E&ByGA0S zvb?^$F4_s=$UU;FYfpU^v5M4TPG(Uhn48pLtyfzUMaVB7FMUJ`+N`OxH;;sa)cM4E zJ#-|7qS$$SePeJgLAP~mp4hf++qRt(+s=t?<HWX~*v^S<+t!!&t@>`=Uw39zS4~g% zRLxZP>|Nb^t-X7~#L&@9Wn&v!Ya@_3V9C<CMH26%Ml(QWkcrv75Fv*-gxs%6f&P$F zh|nCWs4NZg2iw}Lk0|W0?uKW+II5Yem~_-sxY{dp4__@U(QF0Dj7ok{ls_@Lrn}R@ zv@ju<9o<8BByEohO$-lE(uVqM!}+$~`|2UM@o;E4Dvg=@D}>Wa+IliiQRw8T3Go>i z$J^^u<cyONg?pY?0>MLO9O-j#_4y?hmPw<bUy<VhCdE(GNsPLQoDtt-FW(rAbo4T4 z4?Pz(yNZKal|Jby1n(+HH|-beAm7-+7Po`31L{D+s$PEP-(-!BFsB*nYN6E`gRxwW zs{(R9ol7{eKZe5-Q0**|?B}Cw%HjfJ=FQlh30>M`R>2t+2p101s%S4=)JsE{!?%I~ z<CM^W0%=bT%l#Of<(pBrMA@NEsOjdlR)joK!ize@qs{CM^2L>EF^Yi+;R@-g>Kf;! zbT76eyC>S_CYTkF@U&0Z6{*^g8QfuTi}mO<p0n*jj;)dB3b4DCeJeO+BEL~8#eTtL z&{qq^U_G)f*vkbQoleyIv05gRJ9R(6unBFvn7JO62?K9jjz~S<B#?jqJ&;I1&X4#2 zO~ex$&g_WnK8!TXA~uPsB6*&c)u>Z{UG+goE2p>flKC*wA*H@%t~IF2hzNURc_h*Y zLx#n|8v5MFZgu0GlgWd?`Yc+2g1uN-7U(gD9v1}un?Nel!5wJNOAzP;oB}G)0OA1h zQ08dWUHGTA_C5a7&n4f6yTa&FB-TfftyoD#c|HmzLV+hChzgZ!{A$EJiZI6PRyN&; zJz6_4GeTQ3fpCHTI52AZqR(Q5gR>&Ry<(BHR4z`pIqA(sKH|D+`u#SLJ?w!^iFqR% zn^c?rxNd5aVkYL)E2FdcJ#eXsn@W}g4QAKT0kR$USuto<uCnz-Ww`#&vDp*i3?;LG z{3GU`qgmIUT?S!uPZD&|8(CiO=M!FVZ_UWMFpojtIph&$(*ZL_6z}i&Knl|yKhd}e zvN}8d_58c?-~LT`%s7Jo<UANp$aw`$%)`^LwE8F@Hhokzr>uJA3s&rbZG|{YIHy2` zI0&%R8?ozx<*VVTgY4cYGZfHW?wJDFtoyiIf}8VkI5ntl4ss8#!8dvQP}%7s*`kO5 zzP6-1o)<#dpyJ6%i&u!iBt3j!(Kkb!V9`zGUxuLK2#bul1Ue(G)~iBa<<eCNYeCf1 zr;LFK8&6u%kY3(!iws?wiMa<LZJkj%tk0Mg4AR%lxhFwc^{{i0WrZC#%`tdNM`yDL zSW*v7TC;KxGh0_ydKts;Bl%f(FfLaLVfi>ED`ELr>_r0e`B@@zF^~n%#1vGH$$<*` zyjUIgx5`6AYsW~J_XCysfg#ruStJCHvXkO|`jO$M)IdBa>PKRwcn!o78Bv~CctJ!E z<zDYKq7+6eh#^$IHZH%!F_qGl7ZImtr5+%KOGnAiOoO!DXq;s}5-vQ)kdnnrf5M9m zU_`y@@pA^LS5r=k&=&p9=L+LqadSiiCA(7HBjoq^mkW~An+B?9!lkB<Pe@@zv4_WI zrJ`!rrCsLmePR<?YDFoO2<HOg3X?Fmwf|G+H;W}ZD}@@)y0d>m%C1)>N^vP9@s^tM z-_CW8E^~VcOJWqwlSY&v761?uv1kWpQ1xVIkwP&=p7mKk-|e*IM2tgc<paH>QIM1O zs&uNpssiJ!xVZ>iDEq;3*Fl#qv45&_VF+Xcv@vpiMc{+Hxq*`L-{v22aaIbh!lXho zvn)d%e;zb$Dbox}&waGt!bpY+f(rC!-Sap~1!sb=WtrgNpl)jcjc39pD>o9|UP=y? z;8tV%a*lJeN3B>|SK1#pe;9JI5np%FcBP`ZH1Fm}D6-_MF-~QukqI-%V-=9`ecDf< z=cJmtAPI^hQ4~o-rZ8pz^gE*5`*bXt*|*v1a~4%lno?2w=1j|+@v^+b^4P^Nfnx<# z;;)%G4==b_Oj1)vW)^oSAE7q(o^W#kCZ}!Z9|3@eJx>bVTn*mqQG2f-W#soGt1jDj z2vOPmh^g&;`ppZ;SaGs~0vJ8FD6#HtLVnWv{HVojK9)UIJiN`4<*B0+*9{b{RqG`i z2LoqUO9aYBF^wb*-hH2rBn{src6gu;akuURY)tQ*M3B+L0_?En4>B6CqTo8{gK1%C z+Yn0xMTr_H?#3PZjaWF0tsRnuN1JvFlW@>2lzR1&ORfZ}E|3~mb4nu{=R>BN@_t#* zYi^GG>AC7k4XY4y+;Fr^Kat13R)eGlyX4eLm$Ahr_8}!?4FbzB>Yy2#^#<1`IhLlw zH#YasR8>_Tw3l-Xl~FmW8(eeH6yqzE?1k=WiqqygRB3`s5|Ks2g;6?R8xP%&i#;b~ zR)tdE`7Im^8jp-l49Ko~eokFL;>f|m{ReS-@+FjRiX)WN5XB_oG_T}O+BJ{hOp$Jy zOU26v{~oue<tgOl{C=fAAs5Mx6I2ui?D4BZb~%!y**Oai8EaUE`xtg+=nBy)C@(i9 zvFT1lN@y^RTi$U?tMg&~b<`E?lM7qCC52DzXEw6{M5=)us4x@BF3!MU{^sduT5Ovb ziy6Gd<tl8J=ay{dENv=r>Grzf(CCN2=cA5moMe-?CVp5;>OkTH5G^-1MQKa(^|Hle z!+6uHlQTHt?cE8|_l|18ac+k^(5S>l{r$b2uhS}DsK1yKAK4h?ulMKy*`xZv6z9n4 zh?Jc#;i&M|Y4Yb}2U!6PL$I0ao++!weLNmveAOtBxAP6E@Bn52gpRr_9lu_%D)mUC z?EWG5;~z=ol%!!E-wWHF-;Cod2L1YCT?-!3g`^Ys^zJPGTM>$IZlW=>D~2(5D2-Rm za8bBv*5w0Sh*@bj6{`9x`fR)CB{tl+ut7F3`T*)VRS;<PvBOXk$droa{jbbu<T|~{ zU6B3kXKTuO$<t`%BtA*UfDz1WIE_(9x=3UQ4a@OkkWf|PI{HHT{;@&9@j00+$`XA_ zfiyoRp7z+O*b&A7{auk2cjie{<J}zkxrl>q)pP0m4UAGhkrYSQSe3H&L&I=<iY0}7 zhd1re%El$a#*9@3UvP@$B^L3x!0p8b&I%S`_}IbV0JeXTlnn4(sm^aI8&lE0I-Sld zud@kCPuu(T;#i!Jh1BRA;@NefrYc~%!L6oxS)E#et;P!~3NIsSIvIyM4!Dv{NyN2+ z4TTKEkja__NsNkY5JYxp($dFT_*8ZN77QmzNXU|AyG|Zjb%0Pt_EAxZ{z8!kE2!u% zLXV5*W|%1^(!*Y2SjZ;zIAWq)`dLf*7x>{OYdUk<$@UkBDkQ=kda}_D0@GVw5QLua zz=PP<9rHo+heLMM*2TGlJRQOTVz#~z%-nP|S;opVM0JaF)<QmXm^cBv#}eiPPmK6y zQDuYkG3qUZNCIp`qLs0W57|Fb#8i@KmhUQZph@RuM?0OJittI`O0BRrFr3!dPU3?u zVTDdAK2u{lVW-ICPU;FBt0lW&{7=k@BPIKYv=<Ke<b<fkfE^coXK;BKC&qMA#TuA4 z!;V7h18AzMd3?%9H4jt+D{ebEqEow;=qc1rx@m+9E^JjNuM$5@_OcWWt!Dnau}t=3 z#D-tC?D`JMvO|HaRE@Jj6kgNhVZ`4i!ge~fmW7tckO7J_uvQEQXoUW<5&CiCz#*;p z1E^@TPtjy>3FWFHIO|)5bfD6x22I1?2-tg2aKjXZv@2Z}hm$Ruv{A%G(LXmlP478@ zg6+e@8+Ifk`9|x;kj&~u{VKG44xr$~f0}b98Y6ZKj$w9CMv?hw%oLDF7&_!Jj|Y9O zKkr20Zf;0uiIR`d^!-kyiAQECpo}UNg&Dnq%=_@u4OZ|I_}fR(V-WFX=Ij?kSF%Ad zDUVgCUm0nwz1PM+vg)u&>bX;7I2DB<39GRjHK+lg4ENgO4hjtKKoCawmuW6cHD|me zOfcqp%qfzY`WOeg9CPe2xiLvxLd_daR4Fm0L-$aSu;fP*qm{`eSccc>qly>1#@pL6 zO4Zypr$_N?iPvmSibV0GO6lNWu{qS(J?N1=8#X${!#S0CHe0$vqN-0lqtVtAMb|E3 zQHk^fR;IWVyNxa^Lr#b@I^R=4@cha)cGAgNzEwTV!FtW^Hy)>Zz*b{XE=!M60jGsi zPo?LU)VM^cHgXa6Cskkwi*`l*;@u_geY9AW$DjgrF&#3lNNz<5@f>joUeLso>nm2y zWU4z{cJ30*8N9<2Ds*XXJTRS;x$so3j66fG9@|kWb?qDD3BS+{!e655pS((uONk-| zyB<eP1Y4vqT=<E!a|1T$wF~CH<kb{z(st_XQlP96j~U7?u6fGRx^inqrw5>lGlgUr zbh0=1RE0}(2E3JT%3k7+#f~jV9_W)x(rT78c8oR50lux!o9J@B?l{}sxz51JVRPdk z?MPaw_|dd7GjX&y{oTVjccawY?}Y>WB`ZlKiRU04%F_`A{p^WAe5iO&OhdUr*M)QH z<6K5<%Oj;_{)EC8?ZvsqkmuuET9+P9Gc?Dlm7K_p)=!oNpkaHM?@WPa)_ojW<bQd= zwpmYzUXD&$5h1s6VRZ2JP_f=Xqg57~5H6gnf}4^~dU0B{>VC)i-m1&KBE1u{@AW8O zO#F3P40`HOMA9=Xh1Ox<*gztCgwgYu8gcFn3(r=-OK>hDc^rwO6|t=f_fk&h`jw}h zlS?KQqwyEQG3%A9cpgDXp_|H?xm4J~A;wFZW_C`7Gl74>w4zQ#uEh5Rfi2^IP$BA9 zHs<nwqRF(EbHP-*<xDZ@^uLgL^7>yLMF0Ifv}XIK_`!G~o)z;Cs&%`5uHb#bGG)O& z6>5LNc@22Gh*5l8%0?b;AJe1P2v}4&juoR$|34z?@r`l)-h-nZITwtLPl#}%8K(X1 z=*T<c0*xh9HE0dX7+JyONly)&p|W2Z;j=ka39NcWz*2X(p2Q7rO{vDRpXLDa5I#PM zAR=Ly2?@fu6^On9COJV18+~di<zrImfrG*`v<##S{f=6l`Rw)}rfJIKwt69dUyw=? zQw{B{5b~sYWwPxWb@Q5xY%0<|IhL>E?3PI!VFq@H4IUS;2&wjhf3Zpn=t2x1MQr|3 z7Q55#S7)$dCrxOG+K|F3^G!>M{WM`w1D<mPgJ2GD;RMaIy<%^E?#T2f5XSmf-O8xK zGVIj(DnduP*Y=aTP0ZUU91OATKzKtuBBsu6_)nul=~f))twbP;=xZb<27Z4;Oa<UF z8bz6<1exM%rGrhoQx|=7ON6stNiLLUpY=kA)Db&jvwrVkY9BRQz1b70^zY<%2^0s4 zyk0st$2A3+<^6%2Mu3b}Ugn>y{MfsIcY0aUBshGnj)eN@2+#|b41*+EoCA^}I?Gf~ zvt8@~XjeKkU&TaMbzEa%abU8IZO2UGzfP%K9WGBgm6~OQ6DR1`+ICoyfl&+P!Q=L7 zf2%jaXN13NCB=1ztmHelM6CiESB16B(%`cRB_X>)R5TC+=!z=rR?z1L9XYKv`(&?M z>Vlj_SNdUOUBk09O=1!@dbPK%5*C`lHrw$xfh#c`p0XrCkHa-Zuq%4{A?8#u(HkRJ z(a|^UjP+1itTlZfXV!aR@aO$dXjIYQvNZLkpxOf$g>pyfs*r96Tajf9%*NX3(n5Lf z3X>a>i*K<N_zUEk%_;$HgzwS|EHtf5Ht?gZx&TzOzjA4Ad`x=U{mVr+CFv#5Nvt4p zG0!LXJ*jpR3nvp(M62?-45Azn@U31-!HJ<W!_Y86cub4TJ99do_)Rl<?DtpN$;~q? zlOc>C;PM&-On7SPe+}#K4C;&bC4Crtur2bPNjOv*nJA7H&eN)He6_jF^-uZe^9y(- z+3iw7Hum6dp#xLUb)i6SvC_9SXKcbp6jB~wi7bt{bXUAqZ=tdH$q2haS(KOjFuAeB zu_@qoRf`~`<?B>4Sf0$}$bWYQp%x<MTY2IKzDQQxI3`mvVj3S5)%0eOHT@VRR(cU% zgMTDMYtX+BIKA2f2pb&yglO#(f*$yk6XvwUYnE6|hMvI-YJvz_v+*M$QY6)Iv<<YY z`UzcdQn%5jQZikRjYK~S1hQx8UW|afYB1(VihIBA0t%DD4VP@-#Yafa<{;#^&tA!R zKyE|Q+tO^xqk-;>huJ>G*$@@M@YAx=6ZZC%S2uZq=|<qBiWEDnkXe;d8HHX56M}WX ztUUfmmrj?bgZW8NNvF^<q_4iAOEJzQ-jas#-l&qSXQ#bYjnW5wR3|tA^eRG$x>CfZ zb&0=g|GZ=CMd7ojQzB&#tjNdzp%u=3-|>tfnp%Ugja4cMe#&Z91^v5bML%)p7!g%z z_G^4_lM!`)%d4foA*`6F<>m|<JjN7c(OukwU4#_bR|fc6Pf<$q1BGkA21yAl3UETL zUHp4AwCP`;z~X?Ls3Tmzb79W@ORP{BeV6=uJDvzMBcPdnB)*5^Pqi2y#PZWgi<_yS zZG{5kG=4LSwuN*sFZMqsED^OT+mbZ{Z`=gB%3OoO7pcj4pCr&_w<_}uVjuQ6NZ@AA zwdtjLV&eRJFwrl|VJi%99W#3v3#z|1$B`G!)kEou2(=wf+@f>GkoTg5g`htAmC8c6 zN}x|B{rtE1R`ZMQGABg`R-5a&6pJzkv6XkHgm5HzWWy?L=t@ngCUr-<Z4IKp?yO{R zm&$WVg7a<^%qS42Lzu>h(Nm$AE1YAXiP2&92`=~Hv>JYgegK6jsXM&6Tnwi*dm>l1 zHGfd58)7e%@*4U&9nCbSD{D<#Um^B7D{8sMShXBdJofsvGrIb~MaAY=wW>pK4M$iS zRr_&Il*$CO4UN>XclfHChXc8y@>H%hVeQnhA-bYSw0CPsm1?=B5Vj@e-#VHT%&YK4 zH$FIBA*eo61LSjxu9i5GL=q`mgP9e4exNijn~Bf}TAxmMqgF3PA3L}RI@V%#KSZMi zL^S6PZE^ft2gP(Dvl+I<k|eKRK8R$BXPRaFVB}kn^!-g`OOhB>xru?>)np2C%Z{G? zA)70Z^bTm^fgnZEf<gJh^%HEZ`<Y?GBqKPhtAY@!Nz7pF7yScSSmHHcT|b6>BPb0W z9q5rdoNik6B6=kgEm=~#Qp_KMi;vE3M{#K~Wz}XLRz*uSnKyV#@RTwpl8G)~0w|DE zUQ$UtcpsmsIXXcxd67^<2;V*V{YUf<qh(n^8*(Dov}=io%Q!1>xJgHx+!`kHh09)o z+~bFgM?IRlB(IskJ`F=u;c3H*F4f#X53{5QDrVHABbiX8p5-WWIvcPQ!ySliA#^7r ziE2(PqoK?+?sPdC*}<45-A0xuuHVdg172C+qY?70l7wFIYx=k7tfC?4@E7WBx5)Uv zeu<cE<sMO&+j+-?a0ff1$7E(RJQ|Ea-J#4;Xe%`9pbK*vO)hqFBh3)TDjxdv6HeqD z=BX)g_E>&1DsBAK$t!)-?%HDCbsjGRmcxDKxnfdNKZ7yxeN#5XBp&mY`hZ0Rm#8$o zR3c?)E=GxJAS&=>!IJ{hs3K@M%ei1m&<fkWlNJybBQbB=Ak&DVzlf}3eo;hv9gi}_ zJ-qv13gM>*dvV4_Awnn!0h@agX?FF<*h(4!!?MRq_2;DfsG&O4_n$!1#prDfEb=no zB|O=wBx7wlM!BJ=NLEo8dL2XJ3>8v7;AQusnzs_O)r<qnn$bqKhf_<PP|#@gmhb*{ zD-(sBRe8DnwK)4c^w%lG;PcYwMipvXt?PR3QEs|;&+`M-=WhZFY)k!$5c4s@(J@lK zYV{0OR9Y?*FR#8@|70{*W@Z?s>D@KlM_RAlYp1ufd$`y1y7;}`&)y!d%6cc#9^yEb zIV9}M9L3&iL(+ZqQy))CB@A@^n+G<zyjpp@eO<osAt5+u6W;cqK(yUj53Ow?d`+7d zN3!0t0PX;st8;^9f7N-0CKZXEP<8ib4h@NA`z^sN0E2t&IZPX{TPwh)heqP$%RG#R zG|+y!W;`y0`upkRa5f6W)7Q`Y>2T=k<nHb2?Fc<JPUGO@%kBB?WSgGh`}4#?;!skA zIR@>eQU(_O0@^a0{6r@}C@~S?>Fn*P=A%a5N<Xs@a1LmU>M}r}3%z!4bw5tCa6ha( z<W3=QlMv|W=x(Ro)=QoGVv1%mz|Zhl_rE*(C~<LfeEM7U^fmK%nBd%sL<{lm=kM+2 z?f7No?)-N4b~g38KDRTmxqeR*kh{69cTGQYEkC56Y@U{8p;2r9w{-2K^89|ewAQZ1 z-X3;*UgMbq1F&3rh`Z6r1Mq^KT99rW8o1eoC{452&hFmY)Z5;6Sa&jqA#S5AWvq<4 zd%wBgyu!h(2HNQ6@kac9+Ahn(ocgwoev|q%up=+g#)f?B(yib8t+%1l=`6sb4Lkb2 zi3V}-d39F0ZFFw`eFLc6)-$4TH@J4wD3v6#PxGU`cte1Ix6>@Wp1JCUZ4{)htsVc} z&FxQ?sTxOz3tg3+C75=sQR;p@ZSeW?l7OnqG>+ri?JM~i{jN2=i+EZL#e|>Gg0ssZ zyO(_3#(81i@muPwYVOgY$K}%IQm=qpDnd+uqn8opmd*D@@LFxZ?svu3gSYO<mxs5r zy#bKdw~xn79=o40wbzlYz^MQ*+wAUjF9c$kNX$u_@YkN<%T9MnHpl~Qal)l%xMqO) zpm{lBu?j3bviQEX_fsu9i8A;cnel%l=<&O)Wbk{PF!*>msQo%B!@Vx7Jh$(m)9dCJ zs4TtNUg-J0us9p^eNwq9xR|<XadEuU`2MK${{a63^Cfe7k#<P=aW=I5H81dWWOf=c z;;z)O6Jwu5{qFjhT8sR7|4_r5R*C_rY;}F}1KGT|vYXbQl{Qyp!|mGY;sW%v;c%?% z!!RYE%4?OL-?{6>`>*JwL_M9I<b9vo$9-YMeXzW$<<x$N3N_SBOcWY?-P?cNM)iD_ z780bG1^VwtetMjRig)6|h6M`;>BVUl>s=}?KYIA;)opF{`1|`hyGKG+_SsEuq3!_g zH^E&b^}1^E-=9M=(IPe7uAZ(g&eXbwQdISmp;P#`bq%(Gk-d8W9eVNyQkU-TYGDs= z1B<JNua$0ZX?!@?j0suVU3S(}Bae-rh+cm&&k^6QYxwv1+bgf9w{d~xNMW2G1kQUL z^0qFgx4QxFpu7{?zTVoo<LjH71{j$)B)5GAS$VQQpBix;cfcL|^)*X)G~Dq8K>*B3 ztK*g9^V(lcRL6k(rN-t#0|2WV+XHikNMdmds0<tNt6Bsdh_k}?f3@<4iGkHBxx3*U zF9Ja@MY{vjU5`fWePZHA<7ehS9O;UliS2w@N8z3WZ=S9CP<;U=%z}O8b2Kk>R5(0_ zX!WQD@5pMLk2-H$796LqrQzdehi7#L+rK^xNq>#xK3eYW*1Z@<QK9F(OvGJV*(-_O z!|%8eiMsozO26OZ|8<YC>bnJe%L=k(kA2jk{WIr8EEwJlCIHUv`en0Mp{Gk{Z%Y)o zl2fZg%N7KNi5s|nA5M^nbh&fmQ*?;8!bWTP-`!spKzr-AN4V@^&y%@ri|WT3hl{9} zlM!0Bkn62=1R&b2>kk9odM6jJn~<0<5vKw>BhCHBBPq*C{VeJz2iXzyJ2LA#^LG#% zz4_cF-9KYp&tL=N;_%j*R$kzbuse*iUhKoC+%C^qP1knLmY#nM$rX-<8_>yz#pVo$ zMOs=)4jqL(*Jj@DLPMOmeksatIf>grT%iSX-Z6>t5BPQ%Cr>r!SB|!@56DrdZuT%# zrAHjYj&aCxTD@1YoRvF?SF$t(BHkt+chfqlfX^d=6O54_&bML$H?9*x!HwM9o~;?O zCWdh*KToFXrOS6GbNQYlnpMzinCO*`{<s|9bR5E9%^Np?Z39~Z#6Lgo)-$_i?5Ia= zH}%6iwp*sTLT^-viksi76t2^E+C*(kioXsf=7;C5i+aQzdgol1ilO(Cw%r(A!xX!1 zS~dDyxjgxb({@R>Bi<p><w6NT-t5Xwchy|KxzU7K(DSz6`|iWj^Kl)g#<B+BYh?a; z`8efIJX8*Z0|jW#!uj{p1z)7*=x~=gH{hc?euO(<+)mB0H9PdMtIuFt7u69h)XUS& zIk2A@gnk-k2)(M?F25ftg{Q$GTQe#su=UvhUFoYP$X<%tN8<_P;1q{5W?3VqwDa@r zf-mk^kEp{(u7cGd^xhlDP<7^v%H-c-rMv5|kfhg%Q+L8dwNRvZz12NL(86g#FY;wS zec!t>p%K!5_6~{kXQ(kLp!=V@OeqtOM^(JXt=DcC7!wFN+o&1sFzR=CYQ}UEb=L05 zM6K5|`m>OfkgNed7%v*y7l8BUoAZ3s^rT@)J;8UwPRlfl+N~UelzV4CPd|5W?WbG1 zhp@FY>kEUHV2mmfB%b8wg)ec}B!`->z!qA|g77!RnbB8)f^~cR*`ooHHJ^3L7MuH$ z3(SkV--SVyJ26JIH!(!C4x$1<-`7`1&uu7`NP?N_L<H<a+j}XehR4Pf3a7G__26U1 zd@osSDe_6dgXK-3Ldp-nwF@D%PUUXYV}KT10bOnMybFt0bd{#~pHuJWcl~z$1BHSs zTn^JAB8CM?H^T$h*04YV*NR=9-e0!9`D>8#b7j5xM!>w^`uh1<fRdrUO+Y7u&7uzB z&S5!VwX2$0I777b%$WVx_m!&RC1F5G^!4%S@{jd;f2deq-VQRaioc?Hh0xvJ?&_)K z{(Fb5pNavWJm{_la99NH<^^ni?k1c1?X-;x=;!s&sh&wVnfVp?8~c5PO-#&R56XPo zpKX8N+|OTgyCL`$UTGpfhb4t{(^04V#08p-vdCTsX7Dlc^kLI)3<Kx40-5iILj>r7 z{gX1M>+iijH`m)nc;gM;dDl@kXSXfAl>jp$nNo;*f_(|rW!O4`B=uWv^@P2+Ue!B9 zjYPda!)q{ZB=3E+wAZ@u`o0>te5FAuvYhumEno+xKl+?{q%mDNQ}Af*D2YcvRE_C* zIjnuM!cV(?{S)Ydkg5O9Am0Dd^7;9=_}#|Sv8vWQxXJUcR}a+<c&mH+n%~FQ_x|mv z2k-M}vxb)c8$dgRAjcab6r#Xy9cg*>-B|cTBXjvIX%Ut~rcB46K`K|bhm~*yo5X3M zVIF&}e2;3(3gf4WzM>;B?H#+WVNafezZqiq{u&a<xvOZ}{(j#6dV9F`d-ebN8e%w* ze*E!8vh;RYqB`&QDsU@JydN0MH{f1xH*0V+&!f&;Zzg@eUXOo0Ev`<zt}g14*ue%2 zF}&1M`%D;b0S}>M>KU(4dpu9QH&*I&0u^D@_Q+5bjs3>b+A0sZ7^0^`Pi@7&byA$3 zPQaj*(EFgp^7#P&&59L|PCixzB-E}bm@q6Rh>JQt>f?){X+d`4k5=&bu<Dsad}v>4 zVNjqRt2u|D{;0UGVb)K`qe1P|g0X^FYCW<5n$f(zxk|?O=!#YAX7Nu6yf4Z{<C^6e zSV7;D2m?(|tvx45s0p_sYNQ#Y!iDMp+y^j()p)r)3`W;O=cL$NklWqS)-6^O%^D4} zCyp80(a8PP57c`pKKi&^Tic_r_Ov_i<n8HJU+pb6u#N9oYaJjtUXfcJ1c_{4+;@{c z*}M2$WWCgb`7_7u$N7EKFk`^?H&@qN0a<uHj%s5wtB2J<`dwdlA{Ht1tX~M^F0%Yo z4tGzhhKd*D`!MXs>fiA~c!-FXt7(tI*S#R_D*s7*ZzuF_7niBsW<#2R!C)O$_75@* zigVIkE$hc^aJvtLGWi5PVXrss&Fee$_Vow-e!jw<CSHf@UN1ZZ=8tqxJ*3yHwLb0v zyoE7?z=CoHYrt(M&ILf+Jg!b1@-;D^LOnnpW~aDG<PX-6=lX-YBkZHDc~3@wT&EPy z*dhaadTrZUx|J|Ra1FG+Iy%3-U3}DF_jyRy>6;~W^Y&0~c;borIUvbU40J^K88%d) z`wyNbUUtg?F8W~8c@B6gT4>vnZ+K1eHWrNMXMFVvy0gxRB)Zb8^*N)ik#Tq_ezAXS z>6}}fd~QBE2}lsO!&Y^bysvS%P6*@1av*Kw8Fc#j0~g>(QfJ{QG|g3U==eT;TCH!Y ztvYfIx=sd#UjAnM$AqJv)#ADvsIP0#vpu}ICcqh)LS|r4uvAx`ZSN*lLHThIi=T06 zU-WhU_bcS!Bdt=7Kp-I0?GqC|ZV>FpYqbZeTsnpzsL}5N&Dm^4%nbv$hm3i+`_@Bl zE+2=KcYp&f0aJF}uY}}iZ{Qt(RW^bwd<oFNiv9Da8kv_g!*(Bv6yT%3?64h>-aNj( z@WWa2wYx-yu@=prPT-FVM^_)dwUv_2N$1a{T?lTBu=&>bADUy3T+UJ&<rT{Wc*5gx z8m>1J=mW92f0ML({kIMLJYC)Nbu5#*XD!)ndN|-m1-|zPsLQZQJAie2w$IDJZ+th9 zT0P^fv#=kJA|Uh;TCe>LT)|12cc_JTyOi85-_V*9ZfGni$KSoR(j)pPegm_ZxUBg& zrow}^slMF0t6~31;-uU>lc?)!uFSgs(H#ezzkO9erUmN$y{XIgQ=O0f*HG}dbKT8t z|K;G{zT|}5n0}N{RPt(17`NOc#hdW-zVq`7hz~Qk(QF*{4P|TPWC5C(XYsg!CX_Y| z+KBWFC%>cmm0xN7@^IuvT2L@H^|-0kdSC*I?}iDSkG$;o(Y&UF_YFe}lAE$_mffnR z{3WGptwMi0^~%8ulRtI?5{+*F^sfHml7D72gyZI}mYepCs3-#o1x}+F*i8Wp1Q>(> zQj`G&Lj{8RIaQR_wSoTEfd)hfq-y5uBIN9B=HkrYY-H<TV@B^_YVPU*3j_@IpO*hE z)KuYtAoD);EOAR+EUimiEHB!?6?60&=%WFEMn{YNt1J4x%}pXf2dKWBovW)Wp<odQ z=qsd+_Jgbp=k5gWZ!WdcD}&Or{;lhVEB(!`+^faw62)IhhKA+`qJIi4eZEEhm_RTB z<3?8_@4mbQSn0=_3o4Olkmx|d<|ihEWWWX-`f7nwTA11k+1gL!6H0&rjc2uEXLO?g zYi4|FF4QsKGdim~v9oYEvo~^hS{Q!@%LoD?Pfu<=AnwwBw@nbt1r{LKJ=FlY<yWPY zM<E0}a$p2xTr$9q7+}{3V5668$KdbGFl&9MOg@hQe%1Id>I_W|^-aC%6}$g}hV)+E zhGz-*jAMgF2f8<S1dH_Ukgn*!ZqMvOk*r{50Z#v3xpvRP>Ye=1peD0`L{VeWz}o>J z23nct)(HLvJkyDN&4qszCwx^O0ODk;qeXFfU4eSQ>zx}}8i3kX(y`jL9)PaZ*8$z< zCm@FJ6XeqfcCr4AyK%sZXk|w>rq_Ef>*y#9`DN6Klarg{gR)}E2YPLp3H7jwk3Txj z?@2VIRW^E4*@3@Wu8+bqGC0#Sfe$Ay=yd6Tt7LI|GIVuwrlK#9c6nKbQM}C{(iMeg zK)K(bkKWshs89%D@`vhq`iT<GNtb`U#pVVz@y1WUrh;5n1-6T)>ebpO%B_{LSnQ5l zQa<y{6PE~)_=+H7N3LL~-P<kR12Xap`V`|bQ=CMT2RikA*tiG~*y&4SOO$NDYj~s2 zK34|N6IsdGhTfP*h_w;h14!+}H>>~Fz8%u=s|aD!Y|^9lQ_arn0nbkI{8LN{6xa`m zm~iZ0d0TME{O~`LQ4ZYK<b-M4^gflA11A8^QgRY5P5Dr&##VG9&M*-?iRcZC77l-H zCp2YAB^7QX7tP1oPmDhIBk~ky7<x>d&)bV`q(77+5%}zA?i1oAk4*~qz#A}H^p0xs zJ?~;VX@2k;Q)e^+PU+hPXOn~1&B6H-!b-OHws>I*G+rZd6E^UD)ZO!%`$=H*f@3MD z#$mF&9lXsVD~L>j(I`+NCOR}YG;}H&V^bZSQ;m60MN6v}xc78jYHDT=oXqYU7Lrnl z5xns32}tj}HZ;9{%bEedkzfT{#9g?o_9LJQ2>B!siQc#OIsxMR{zd!UKKx37_dV0` zA!o1jyM9}=XVKy{N$Yyv3L$aM_)a|b`!AiM>^+};db%G&g;#r9=Bm_s77tL{*Dtec z-5y)V7AF^12MC96rgCV*-4BV!_OGIXg2wWUdw@vUcgv9Xk`hy6otJwTM)M6%*XsM9 zimbxI>Ws~6LyNaY!YhAQ{O|I90ugW$o<@J$Z|@b&4|zku(`Q;sGh!QiBWnml5SVX% zcnu&5o_Pa>VYJ@fJANcKr)1{$sh5$&IzUKC%BgozeIq0AVGQp#v*D2!!RMCRJwtNU zb<Nw2M$I;}>Na1=?eraF%qW3WaNsB3>BkmO@8tO4r_Pi2+Dq35{)Ra%5PGct!xq8o z*>%-dTrvb|0wgsj=Q`FZh+H(#r2ojH!q~TgV+71M=&}IWeUC(EW7aA`qd%us(BU-@ z#cdB{Pf1EwU02kifAlvn*JPD{Us6hARApIl!u>T%BFo#%7eTjQPi@=R7~8jt!UqA+ z?abS!0yx<E_se=h#%IsDm#O)8>y-q$-I0GM!HAh?hLZ5r*0sdjt9?0%pRfh-d|+n} z$S$JV+Ib1S0SDc>%s=y8F5O`&Imf-gcd(;ZseX;>>DhRwK1&ti*1qjGyP=7wU4fOh zTOEL>6bw9w*YyNr&Y4gpZWn{ny@;P!vB^+6_Ll6%qn0;nC+Fd`0U475iG*{@?j2V$ zvF7iyCr|Ym7AXDW$?KeR<%8J}Eo`We-H(1mKEw}b3szc!)d=?&KOTqzZdjxDM<;N- za&g&Q`6#qWzU7EO%YCq*lA}M7fw;RbLAIF>7n+2yeNoJT`7=ZPP{>C#L8ceVS{tsg zNt)eUO!2kqmAWhz%kaqQ-Y#LC3PN>B0vcIudtJz`-GcV+kns*Z!^uf?ovHg!K?VWi zi&9Kq6R-&x`~Lh7oZsvDBd_22&;H0>y5IMIM?SY9_^!SoyS}~unY@<5Tx<v9(*zuT zTMX7Se!COJhP-YI<Fc?EZ<E9lHK5lhK!M*;9gxYQF!WCqsyxdAF!o51uqWD@k{9k$ zR#w}f2rO!Q2o)3$VXrV^kLb$vown$Q3ebqdh}B4Pt;ZIavuDGR&tb?lhDj8=W-R}h zt69fhY-1m-M0KP^^;-B2Jb`4#c%VOp;q+$5IhK4qVtu7i>n!zD+K_!WI(@WSYp41* zmK=VS=Ba$quwCY{y<b<DXMC$pIW^ROwP%{WyH{wDFZHN5(%Q)W)HX1GCUyDOn1^iY z(&1&7t8E#8=I8-mU-x61n?C_Li{prshzE35^uGiCp1ikr0|MV3;YINWVFtklu?B$$ z4?nFD_F$C3L4am`u6csfyPq`$(*@Io+P;TP4-FZf5Hzir@X^W9%}buGvNA$4QgV`F zBQhc*BF>&?3=m4b2~e+*t<KDipA6Q&t|xyIORBLy^~8~MX?mXfl{`;Q-N*0?@v;Yx zAowUsVaR`TSH*1S@k=YD<EzVjf3g3LCk2x_3wpK6VMxAT7!t?dLu1<yFQ2IciKxs8 z;!c;G6O9suB52gE;;HTpV(8qY%dDK;tS^|{uC<KIC#cCed)TKwr$NR^jyNb_DBVi^ ztX&p-FiY?Cbdw2sIlZ%nv`CP1+JeZ%@zgUtrI|K}AqXDJwh~E3Yf*rC2P(~@`6pd1 z^PqNwOl^P>kbM?JHrSRL7kzglk7+07N!k=??2bBLd_d5STT|S@I>0R%-dYETDGB4I zi`8xVurJ06>AO)|ddcq5c8Bz}>^OOQeMt25{N00)4xBB!p)2cuJ%eKKg2)YPz@c*; z+aFO>B-#tI@#nSR4<}sSp<=v{7HVIP_l0fnm`Mzel+kQg9E2S<YAnnF0Z!Uld{mFq zi@2jYcL^VoM;$5WV*Oev-5Yu}YqVlbySv7HCYrz6PI;}E@3<S+2p9_Lj!R(!z&nKB zXA@(?f9rXIybu(P1lq1GAGPLf%*Ijeta2PzH>g1Mqsm6`E#e?mTNF#5)TuY_cjxJp zPnZnpBm>ycaz-MSLHB-f8eFI`Dp{@pQeGC__wE>)j;QjE^96<28R*MyO_<2B+$fD1 z9%lMsi;O^-#$&k^=j|#WNkJ@&c3Ci>l89?<Q-#t5j^k_}m_J%iZE!!sC8YI%`=W(G z#SL}ACXKlMnMLrRn)(54t!ScQcpcIEg&l%EeLn+Vt-eklw%`i>+$Ws5+a1V19FZUe z@+brM*HOCLp_~1lndBk#Rv}460fdo?M7%(`MdFI}%)pMTdkOBHT{>qOjO`oC3naA? zUA=s9)Px?WFMPC`QjOlOvgRU;vDEC3T%GBkY0oxc6cQ~}%w2G;X&`JgDj^u2e+T>M z6*R)j(Ta{5zh+lMcXVNdq+aXCHX7`Ju%U!q=svv`NkTvtf+J{*MI*4b4aKuvZD$!D zUGR$;w~*INkX}+Q9-(hbQ4tS1D(|K9u1A#p4)vKi;Q`nhc*WiS#*;UbDj#j_MHE?9 z8N_+WqpiUp#8#xN({eWdP9R();qTn?)@0?3_4nZnLTW&o9LGTUISAWhD&d{lIdi94 zXd)K{G8W|l`yS^nqm$Xe{-L=UWHY97;7pGL-GUS9NdqyOju_qk@Xeer(;xNRcz=!H zF=*F^W8L;JGT5o&S;!dx4)p)~E+8;1B+yge`pJ|0{XRm?<=f)U1|I2fgNHC(`L?5D z(p*5vJWrzG6YE~nhoM1)jnq!K#_2Q2OVI+vc;-MHRpd!1BK(Y6GzR^yIA+H(c2F96 ze4i^^havjdf)X5wv3F#!l@7sObfl^=ckr4wD8Q}S{VzivO~A!k>R>;Z0zSw3f!5u7 z(lyn{-aJe#VGM6;r-Imh%|~y9qp9?Fw@KD)^%~sMO}(ogW_S7;s+Wo)t3&v2dxqNU zyzd9ok@bVRIrF0i;opBV^9<A$*emSS;+*Hnf2onHV)Lj6plhS9+q-`)rl;tkX>eCG zc3?kVsRB9pLl;IykqsGi+jmF~{3;$1fE}~C-3L^nRO+8E51upwxwGdYPG#)lRl1=k zQEy${5!O0BDIA<?A3O)>!#o9j0D(J>!VEN<l1)Es6d>Y@y@x{fZJE71!;v}IQh0R* z{`$AJAf0b!_)vi!`5<jKRe{t#Qc0tk3a*mnR^=2!voerC@jDiu+odVFF5Ir{txY@g z7ff!m_(K(e$s_J7Z;R8p=gP~mb3A$<;OaomG5pliO9z!j8|)r0^jLjO%fA2PLMSQ7 zVSrnMx!S7t+@MtB?*eHP&G~ux(vNO*cMt2tZ?Fc*34a%HCSRrRFElr#M8aNlL8tt3 zT*D(*C13^y>BGGapn5~5O^4u}$ryz(uNa|&;(&pRM{CX1@Xl2WRRKYJ4(ka-s^l;0 zuPR%9kC466hP;2lGEfy&7p0>DQGvO>=hpi&Zu~{-5{jUJbvrvjoe};#csQ#Cp?k3> z&Qdd%jgRR+E=W*S6hH)F4tGPC6NYHQYlmuFQ9+OvPJeXV&Svok1xKWK%u*Q#(m{Pi zHsg$K$vT>VE#?_6`B*P3PELRgNG`>1KdxD#%cvP0F-BGJ%)t~{ARf+Rwd`=cHkjnd z&UbWOHC>fSR#jL}(T&n14x{k|LFGX?yPgvqN<h|%>$-4s^F2eF_tKFz{k1XIjDHa@ zPMyDc`CX;h`d9VJ_L6F%5to9Jv)&va+G7MoQ7W!k5cp%^5`bmZ3a~tk-Z3bo+=4td z7)Z)v+N>SG4gKNCKw^B;#eT#4g*b~2vE<z`;{y}A4CR?|hAP%XjnD$p6Y-fgpkr0K zEsTDVniDXYe<U}-5UOroP*25&>hC8Sv$YolzdEA+9>ZFQS#qr<9i<=w6N+-BMLJB{ zEljShB;uYm=7~LEBD&z#D!Q6+-~6G<k50t|vr2%ggEp$6=6tC<u=KAzI(!}@hVrfe z70N0C!j;ikAm!C{K_NI474SfPv%K;UdC$V8WwZM$GCRP&P)E~`ONM9sA02cReCrER z6%MV5uuOXhYF`$&%w?p}nrra8pGtHxSfQlt3t1Ex#$QciU2_blQmO-4STfEAqhstq zLhA@j>}1w8=a+Z=u2|WSG-(UVlpWpysEUv!ThT_=&JAHdDSESzPPV3aMjnDTw>0M! z0mB3tWHpty&|9O_I)v`>8oefK6b;!7=23Sz+JiOvapjjAQ|S<mh}MC*OgsK2=zwj^ zJqv>-UL&1zoz6?Y{0i|-S|<^hY)FlR1MBa0Fs|~Q(=8TQuG6crduM24<^CiJ^sKs@ zdJK^U*2dBv0qSK-724(e?XZbX7c-b~XKdk?<Ma-bO@X0@!1uE9w%r6M;iB?dLC_Ix z9}+_Fpa!gfVg{|uN$mE{WSv1^b%wpw4Vf_2&nC}-g%_FzV6sL=ISw8U<$voQr*5^i zSIN`>vqQJ6bYH3MwEm}4-S~-%-<b%%!B-8(o__CTjY}JWjg4cvwYER+rZ!9~IBK7} zmFp*!LS38`)3@f4(gb;>J~FH$lG6Bf28nM8<Ox*kUh1rLbHQkO=kd|(->crsn`<59 z@Dg6>h)owoa%##}yuGTyZ+TsC(3#yjYYSAjQPw)hqp!*T>?76Cw*Og8yi8k&le+`t z=q>!xBlfYTdJ^pB;W|~*Z98aj$jA=y|Lv4-(0tc&<+@YtE^Aa~;pE|UVWO|q+o5;W zfv;%|0>eqS6{?85_?lbZoV!$Uwqka_%~_2~<I_|~tj~Uc_N3=SOm)_UMz8JA%BR5} zrcT(cW#9eo)5=e?$|RKPLH3C1PQW3xa%S~*^J;3fd7j<l(bITJWMdHTd<U@7Jbn#* z-a~O?YT)qFq<Wy6-R#&lnFxBnpSiTzf(D6td2Az8I~gGS2EOlfZ67q-qa3@3LO;w7 z;u)Ww(>k@{z9Qwi!<2^ko!cmHAGYX1-wzOK98?iUT~pgK8Jw)jim)z=-O~DZW*2w3 zzdt$AQjiG9YBaF;$PtNY-1_HKY29hTp(W}*`?D!Gt91^rMjdGmcbC*RDqo@rMcBm8 zs@cRxM_7fWw@so+%#I@H>f(7>45FSm^O~&0L01y}txRVL#jD1TC?oF~+5MYOSNlzh zaoI8QZY1^BW1hyTXXAoUBV4OaHex`;dx!q`Y?&BmxuA4U#4mx~f4O<G<in#Dn8>fL zE^Q0Y9fme6#?K{;5;(C}F6ECiBUX@Tl^gz>dtH+0f~s9eo;8S={Ufk$4J{n`ho#)e zTcGfq(*|txpnNG}hxIW8E>K|Y-)k<!)Q_3t?3qko5xu?j4(*E0Cj1qk@2aR?*xr%a zC5<1U3NRU{ja%C;n1lP{Bv^ngLI<JBWD;>x3MORU1GyG^8<%JJpInBTBIBJbgZ(y% zWGd2o5?XgOHe<eNeVnd#&8fcsDhK*d?nTY24DTjJ)|ph;BFVT6%1}!FmFSYP$J+$y z><%1a7Uk|)7C}6~(r9GU+M9*n>L&eq$@*X;56tHs$S<Xe(k~j@xYx%r6bt2~#bMrT zH<gVw-ns~!4(#Ux&TLy`djcLL*<|C>we#)`71CcxW|epE|3c#;cpI7ne<YbFiJd7E zTqq>!=fdb;<f24gOxB-*(Td@l&H5-Ol(@)XJbe5tCg=)lH+*(&#P#+|;MY9ja#_e# zj2uxN*svg_>aV{NUQ3Sgpnc=OI*yUaY46h$a2&l>FmRNyJ7Cz0ouUU4;z@Pk|4S2Q zwiMAwgHpr3YJ*?!%G%2AP`5{eiAj!gKz=0!`B7@=umQ2f5CaSGWJINxI)Yt@IKjRs zxPKky3`e|Gs`FPVLXSA|?H3#z)r)y+VKRZ*rHzZJS*?6+l;4gg2Du9Rhb6YXxf!NF z3vQ8m14F9cdNB&40G2DKsJe5Kb$mp8m@WhjT{?@No+|yce09V63D%IUTy){4ql|s2 zp4p;|6Q&*Ga}14YL6LPYC+_kW@9u4d{?aPZm5<XZ)icdnTEeqAaBLQld?=IJ7i96# z$IUz&nLmG*HW#t3bxrb_P36!oEarpt%lcZXdJH!1XH7hBVbo%|h7pi=O!Cr51u-<d zMabLTI-E|BxFHJC#B_|38F7eC*p$(&h^mQ})Q~dp19lD)DEC;OaBQ}0?wV#~KwxG? zMf!7%Yq)0aH_fS>zM;SmeLPDyC3KQGOZ2dUJw&6A@={nERKHtv3HuTxynRm72`zju zc8fwvT9P3yTOl*!=u`2rQCp>?IYMi3f(&~FEAh<j(n|9&SY0OS;PJlHRUa9TTF~0k z3O(%g2x1Z1*eliqZ`u3x3I_ppHM|B%uFQ=pY!Bj(kaeaTu+*I^-`ImPE$1e~IJ8rf zi_J>d!&+O0c`A{BQ_1bhuB9uf;Ibg*zQ17`*$mm9$+Xt&#tK9e`bjR$e*5f^29(mU zEqfR+2c;mFmYVhuJv=4{^Zn<U#DpfbmMcIqBx(1q&jZ<}0**ffzD@aGN6K)HOE~DM z2P?p|5Zl!ziaFpR2Wp-~8$?x~h!P)kMKB31>YkJ)H10!LD<`wv7et!1d}|l|t?Sn& zR^eP)*#;%w%5*HFGF$w?GcJ$T2}iYA)9RE}1_Ev8>4Qpr9OCd<mxi+W)S*OTX;U{M znbuTiNo41lPK*3n&0@bI+-*x>HkNegv(B&q$vIbs@4=zQWDnSuqpS^mO&p69HKW3u z=4vzjX=?fSg3<CNhHy(cY18=Fe2Uld(7!$Q>GQSec{IDDtgxsRMt?k8SyJDI3!B6O zM&=L~yGFi^9<Tv2mEk6Cuw9A_>2ed3bm=i{kN1RM@w*Y_NWxasR>PXFC^0RKMMCZ{ z6(E58T--D-e^{)E3G>6id`KHvicJBFvVYr^w^WvSFIpRtx*rq_PU7!DI*(7HaAME* ztzyh-AHfs0`Mu;Obd7rrlO|31&j&z@Pvz#z+_@O(bV1KmOU7>pihrV$NnfVfO~v8Z zb$Xe7Hs>JF9D!O(--&dcL~&M-X+T`rjezIAhMsUOE>q;M@uGrIe^lIkd?#13MGu|i zvsb&z**qRjo@KVM?llo#NF-e8+slRz!by2yjZjb;pP8kqQ_RmqLT=08SLh>hQSq_0 zvuy-U>vk-lJVN@U@#La(QDvuh`S<@oY!vc>hY<){Djs;#ru4%NJ!-%^kw>$vu!p3_ zfza<2_xJ0gI$QNO$M`zGfqIlMgPk+C(MuF&IHbb_dEaEtY)H7bpf*A8#{yQInnQfS zADRUO-VtdaNLk>*EYCloWOsS{0X4GqcH9u;jRZip92d(15QHUOM4>!3`u=sk;9?!~ zgLA4hwM{Jiv%Co8q#T&ic;8QQ@&qOST(rbkYt+i0P5ru0%?I#8FtaB@icZ`vHERJC z4S=SCCc2qfqMg@le%~9D<>uqf)i!Z_sV`LVk*APqw{dOb<`(_vJbBT^7^$nfw~9MG zZtU}kl{>J#xTO3|>8~N1MqC<)iCGWrh9$&~g?TSFMF--;!vu=BJ+b~*k~d#bS<Hgn z>Vv*?hLb=BSNP>ZJuKl>RmXUF#YnuZPKvxg(SJR~M5Najn)s}AU}1EaZp<HWq<65S zHVz8c(ghBjX(5EGYn{$8i>(A$wI!b1Xcx=UH|G>_xdtl#hQy~;GRFT%iwPF(gpTMa zxS^r;#>I$?9YyMP9A7aB7Vqq(8`2hoHO3#pYSyPeHo6>Ac8$3{i7RE%Wf=AWfZ1Fk zE!Akpfz>1*>~A#k)iLk+;Qk)~NkF#0X6uFPx)$^j;LzzYoU>6DDSj_%%y_~3el6~) zQ=7s=PSASAti8cYDl%5I%+oS@;n5l;6*|}rmB$QdJA5XK8q@j9+BQj+3xY;VOOL_s zN<99A&?Mmr3U`lN$lrCa(@7R?*Sz*K5j{A16d8{>oZPpnXug^A`{^+=v+t;wuvFzc zso6t?vk!`7N|T*GU9TUad(5#b3fB2u2Pn{V<qI)R+zE1RW_5Lbud^$wE^Bv~G8)*$ zOj$M&O#mP263G0x_aUY@r3z)@YhiAuYGxet$45cDa~2M-Wk+%!uLr_M3>PBO+-0*8 z8r?<YhM7Ph$4LbZTP+d#54a~nnN4^PM*Ce^W~ms8r2Sp&>Y#AlZ>HBY+O#P&47O2A z%WaLFp%`#n<%QY_`UVxrKitn2+Z0r_Y*b}&zJy~3MvsCOwwgUR6;8s<un=R3JpQcY zZ`78^RT))>^0AMc0?v?pg;md$AO6WgC(Ds35><TNWEmb`%B$t$aV71RCjINRM>s+; zZm&{TV66dqnPZm3B)mw9VU4LX-()gb<ws+8=eKtKG7c;(y!jcW?W(~?JN1utyUC%C z)AHAo@HvAt1-|%c>7gPk-e*Mm1_qLLDMIrmn+&{5Gb)XC7V<Bfx3v52wh!EoXg7Hc z5bUJwvIbgT;1rXve9CUmMnz`Zf@vC!?+UTM*c;w)=w@@5%a&kUNkC~LXD;Q`tN+j@ zx6VhBwWg<|qqQojWWmr#`^mxhP}(NNkT6<kZDS&STMu9jf-J6tq*d>A6zBi0EVSoe zSn4+RmeK~u^q+*iDH$lFeZ~KAohYMiM>s`d@nnO26=Ok<M20g{vq!7ot6s*88JJ#( zXGOBwBMWaP?rb71Z51NS$f=f?tcJ5YSFq`@_hj8EL#lo_mx4c57Lhc%byQb}m!M)* z26}Fh@)p8F(;75v>Q)-jJ(R{+>Uu0(#sv1&6}Z}=b|<3_wIv&+ren<})VnZz<9Mf~ zNuGjT$(lZP<6NdTxFk843J;frR;r@o_|4L&maU?&V5UR~hfcUmk*WS#*eXp55_9bu zQT-d|QQ?m?B0c1mOS6)Lh-zKc681!6bbbnTY^$79>2aCP#$m(xvHF-Q()s07WEd@x z7cP(N5<U6Z9%u{5OOk3+85XEiq9jt@RS%Bb6=mcvtxb(O+2-wwO?k!RE92@1R#u&f z?6QUC$yOQym3BUDt-UWv%hAz@&Aw*GQ08lzJ4s2EMb(K1+TD5U{uvCiJKx=!-pc@p z;6=it?AgN|;A<a#wpY5gP8uRue7;n5o|-{WAOBZQI-AhY$1}3?rPs3M*VosR=8+%) z!*b{?6=pA`jm@FW%53fc-leAtUN=qkwVnwF_4(UK`lt$<3xwB5JAY<8)n+fgATHLJ zX~6;ySp(7Cdwa{8ta!|^25oZI40;B$FA7)$%~_`L<!7OeaF^P9YX}kY_tzZiYzb7l zaEEJqwgoi}4Y40T6l#>$S(MHgC(%B2mk6^4;USnm;+qFe+j2bX1ZiczY=}jl%R~Z( zKB^tFR0>keXV<9_TbPAJ)}FL57s^bRc6bwody$hho1STFirTx?C3(BlE=?I*lBG%m znX&3QSTkR83kv3}jp`g!%<*+}_2(M9gl`<=nrcE%*|iU|%hY5Z!waPgMM`tJJFW#N z&bmJsYiriJ#;t#_V^5-Q{JDbgqW5S5uwpjW3xSbVD0Sm$6!V>N)Q#H$vW?$Ap6rm4 zP+@)AjuiKkE7WeNso2$|1zFBlk;eW$SomVv-_4T7AVGFA3-jco{zzFS&R;cpsmeY- z5BFfw*a&xQA`TTK;w4k9nV3W~im^Pp^<>3hyEd~P_!a=Vp?%GOMRmLQL);fW#u2Jt z6Dw5r0|$O8-fLZ-p88H?z-!sGQG?~~ch2l@cPRajq-(%Wd34qgX@OpkG!j*e92J~L z`Y+kn_#uu5(xviC4zieNZ8eE-DhV14MP>%Yv_FMyDwnz^vc%>txgYG?BwlfhV~s(- zgrN)Iv7*rOyP6)NUk*JE3r_MqGOlb@+Rf>8Tk!hUM>V|=oho$k``X~E-tji5E?5e7 zE>YrkL!OQczEQ5dN-h$$3qLh34&3ffo33ayBEO(Eo_~?I^;?(!v{|&WpvieJl)ce( zaawPTp1wFh$x$0FZ~I^BJ}EjVz6*SN;|Nw_?L_|7-JSd+?#%^h8-upc#xp}gdpRU{ zBeEmldtVE=Lo|lg0SQqGsBh@d?g79zaR}3rpX{d-g>fMq5io~1<;SlUxYJ~VO(%Bk z>JLNPc$IR~L)+R7=zAC4kY80WkbiN7u$dFb%u3lu!*-wJXnk+@(v9bo{4%%4{Vw$d zoR3j*Wt@1|36cfV+e<gxb<g3KCn&q|D|1Y_lBhI)OnF?XX~qz{a}oLXZEdy8^nCE8 z;Kq;S?C>sMKHDPXk;^FMe12t!ap~H0oWLfScnIvL@N(fYaOB#DN80!4{h0ye%D93I z`_nqRHaz}Mr}sgX=<=#IzoWINfjGUj1pbsn17wXbhQy~tF{i}91q2!JO86RbnOF~E zr9S^}O6ZZUIWTNkQDAmhA%^tgAB8=kjBbTJk$dD2kHBs5sD;^(SwjPKP&^~^MIlV4 zK^z4jeD;T<QG3k8$>}?`c06J!T)b<zzjEea^;kQ1jt>jp-hqZed^a;PAU+B5x}OI9 zbf$0+;{Qc*U#Lq>A=@b@EF3BBc$8K2q$f||K(QaD=<zeA#_{m4@T;^s(-dx;8+2dD z<B9%d^4#ye6(F^E@Yg80h@{BF!IkKg$HoIyD<hA9uc%_mi|9JsLhD-kq(+Rg2Q*u= zOv9v}4&umsSx_{6H7t-CEj(aNaX1&K6SKj{RH*xiC#PDm0wQcn@@!JO?pEN@<C}%^ z$M{!2s&~IHjZ0SeZ!-wF4s;-+cu!Q+P0mmA$UeH{lr!Ob3&Qylz#17x6}=Ud08zGI z6)Df4h0p}cz-8d(ueRxrD3npVjWQ&RGG_f}7bHy$A1q-Ka56xx6HnY=K3@43hG(nP z9J6hr*5PBfE)p4eX74hLILV`Dw(^^ZnFvmk4_Xl1=7)LOK~ZxV?|%+a4R(mVQ%^nk zzC<gYM=4$x5n*{U4WWqb9v;7{fKKPEGU$&+(eBKrIuK8Xwn>OChRx^=vEouEDW&#P z3ielARN>a;tl|zbdem%d%f9X4Y2O3);PJQJJGQT_q)uHDi`I9sZW%wIb2ePn`O7I* z^Md<HjKjDEVy;dZ#4I9XuF1ob*v@y=7(;^w7U&Ivxa_!aEgraA1c>%pi-qAQM4?^u zFXM1}anbY&Q<T!50pT$x=lgdKq{%Yq=XRnBmZ0%Zi*(cFWjg2v=$Zb+r21(TtB$8! z5NgE3WAh*ZbVIBn&JZ^IqI{!XncHracxj{@QYf-6TC^4Y0;%NQj_!hDC*REMc{HPf zmjaWXeaKBR3CSgYbwC(2UgmQM`=D)CeshAo^d%<F6*k^rnvPAdPa7t=_p%e0zM^Xx zmem*kI&!$#Qkw8(EDogBDs58y?0NInZRb|2928siYCz#ryzoNZ5?{4dY6b+V%2jK^ zq4ml(yKdHe@AIQN=I!z-H|~0+-PJLt=JAIv?ZWW==kl^aZA1<00qxeN{cj*Yf@ed@ zGyAl%zR&*zDHUT@iSt>QPmJK-C@a~z<eKPq(RR8g7{NY!Mu@FIy0Rc1f}V_w9d&%c z*|o=IUT39S4MBk2pI<~NH8xtGxc`w$vhNkUAY9TMn4~G$800x9c_DPxpyiEJJs#Y~ z?nWYYhI&=d6&ik5tLZD$kChgJ+n1WK-|9EMq(5nKF4Op-G%Ap-d+hX((t*x)36BUI z47rI9d)xyw>M8++UAHp&qB$e!plcdY?(^vJMqkaog!9*g(ROi{*S$Qz@cB3O6P$Ao z=xOeejp$%+poh%&%THKasS)K6eh!=NpA&RG#~jdzeL=2V6<PREFX#_+#=1mZt6l5! zsYJeLJ=%95VkWhD&1952qohGg?}%KuW7sq)KhNDfedNQ3ygZYAcyOG3o*E@oO!YlI z+WVlo2C-7DM@ZsPaDmqe*{UHxR$)3mDouVr6%gD`+m!(KVyGWXK5WM(vc-_-(dVq9 zh^`g*EX|&BW%h~Tr_aF-e-^10+Q<lC=jP}`n^*Z>_C-eW1J(FZs($SNU#-ct-lH-X z;@+@cdc7QzVjzgukayMME@SG?NnYL=&XOVBU1Su*V04F-GTMo?K_s+i?QA%cok$dg zug@!GjtaWvMHTu<q>X`B^K8|3jgz_?ZhUFqt+Gj#@yJ$N>DwM%dfKBve)=4X+OzOP ze$4TJ&PdJ=-U7vgS9isba2Kt{FIf{R4Z$^e_GI`qN4P_96y&AvJm|zH@zWRPF`;1a z29SL1R872x3<~V{5k)ynWWUKFVIGaP9wbEQU!0yDrs*2D(Yqmkp|1kj`Vwl0d562u zpB<i2uq|Zaf>)J1D(a3wjvu^EeQ~}m$?M-7cF}*i{o)NHkeE;(meLTk2;(xy*DjO? zI@7NP<dZa9$64wQI`}TlE9QC-;G}@f83%H{I&eHX-haC^9%D#+6W49X6kDtgT`No+ zXa4Pz-UR{Z2=kjh4j~oQ08_;YWm+`qajRFlksY*@gE-xUs-76Wt-5WHeGl}{`SkiV zYOj4$-0|(EWp|I*UrAaSp9r75v1?bE4xQEyNIRXj==hE{eYs_>KeQhclB2DeYCunW z(qohGlYits3^~}j#hFM5UO|51Fu)=yTf*Og84}02yUglZW?VcX9H9JARl7Q|u#M3A zpx)%wKge)mxR@PTyv1tOM3*HukkIAIMPy^lON#2w#)mIcyf|%0o63iSz-ILrI6Jb* z$D08&IEYLUc;bJq<ij{Fu~ly*cpO88MDYs_%VmA4@5knlIW+H41i6T9HgGTI2^qxA zf)B&wX%CF1W73m4!<g*B$9zk=iItBK_Q@ADc>{HCz(|z?Gh6mCh#t#hJq4l8rB;Y( zq)1fQeTsDgDfp%L18qyDJY<k96AvK*L?9?fpYoCr)2?DD`Un0xNkHmt2w7=S253{Q zUYC?74=$8M&Y-2EJL8t@84{(cr?if$3%uaE)L_U6AU#H&$~VApE`_gW(1Od$**sHz za33x8Bt{aw>jPJ+HD2n~!h^~U0Bj{aa!9lO%b+lo(mb|o0O`mD0`GQ2C|TIzgCoyC z(O%JP8~~orB*4)Y>jX@7wwJmh64Efj6k*5CnBU5s@<4WyB8Y|q7eX|2wkAw)*HBfN zxaG&WEJ$>U*gol@BiM(*y}VxX?{bi{!NOnU$+uBZ77cs&(ZVO|Nt7}WgYaJ2@S|(3 zY@uTjlKsD$)L@rz6J}9FwnokLde78w`2ZHlQ=2)yN%+=^R`?<1eM!LAp@;gU@F<jG z$`z7{cP*~PL|_X}U=a`xM;v;1$VKgnQodtC0+qL_zc}?83xo}XOpwoY<%wI~bA{S^ zRZ~^F5JTtc`6`h3d6LpMe2S#l0WT0qG309;cQ=q7Jtp9Y$>y6^X{#71S}1j&iTsJF z50a_iz=SYgq0^2r3)Tp-gaS07Eg(Zih|Q%)p1hywD2ztf^RXwV*OV<o0lfWCRLp{e zL)h}dkdFqy>IpqGUkgD5`~6`Si2w)Ms1m#yl><a}Jgo0kDa-V##)@k%=DRRyg%oj2 zz~oWijc)XgJTww#e6lRfXPyfo+DwF})+rPY04mAFvI4ylcBmeJ$4O6m3kPXn-z2UD zShM_5U_x!vM2QMXr}s&h2b6*YWx#riJJ*oBb~#U}0Pv;daFN6atv2_<l`ASD$(%qe zD}1}<8|hV%d(CVY#xP#Y?r7*{FpmIMU~SREMSvqI4$M>9)`%9>8Mo2ir>>s4AaCgp zv6ch2ReGq^>LXo4lQ=!BT`}W6ngp(WMFAzzLP=zM`g*LjG@9!2QRWc5RN}Pg2Z)p~ zeY7yPHF7<@6XdyITk+sD%<w!W_(7FD`863)ilVy_M)~(r^H^IadyPF{4=SZCf+zjI zK)s;8ktN?cePbs89h)<XE^ja!y03eA`ADklKSwcvypSPDOGLRJk{*Q2N#Dst04ti| z>}{eieYO}#D1~N(NZ3*qYH`6Tg%F<#9-=}LU(@sPBNCMZ9Qp$_C}L)gC++75Gd|Qk z>lHWgT{NPmo%qmZHdJE)jF@#H$qXo$5gZtFas)7^5_7TS_Q2N$6hk^EgkEBpgn^a8 z5U#}9px%yIPAtXk#Gj+qsfs3yD)+f+Fq(UZn`Pf`c4^WER*Gj(<cu7Z&k$PTKpneo zT9;~nX8q#jkyxv+h$O@%Tt7W@_o#0qG?}V)tMTw0d<yN{rvHv}ii4MJ8s@zioh#k6 z!8&(pxQ0%ae^$%v?wNRl5RKruDs+Y5hUnSOFWPBKRe_HeD!LB-6-I6-Osj)ra&()h z|2x!LzMk*Y>A^LE=O7iKZH$Ev%+(2K5#fo{&_PS_81EGGXtbxKWa!XpjW1^n;U&UN zWFO<1@ZA&_!6#86lePBT{^%Pw1cca1o({kZbzHTLr>XPY><Z_^Eh4gOd%)r$)Cdm` z^y;ccj@p7yn8j4Dy9a{%b=ydp(I$&b(XW}c>3vG_#cJ?RZG-&%q93BFe&+sCKHw1= zoBp*r!^>x4552;Cgxe2wh)W1{yO>d9oXQm7CTbrI&%xe4O2!0v*J*Nwsnxbd2;O6Z z0G!BPEkNxiL+K{FC$y#eBzY0`6rJPWF>nt1%GOP_*+KP56Y#fBO;cLL26n}3mrzag zeP+NPpI+iM52)Dm=eHGqrCS!$`^JE+?E5#79PqeB`WVhaE+5W8-uN!7d$#n*K?2)_ zT+@NxTc~a5R|6+aBINnU!EtLucB#4;v$`x?N?8)#r3H+-bDLoe<4`fPaYlrA8Fxlb za-Ahwat5^U6Rk1rPppZn_T3wu-GXQPJj51!=iU=f0{i@vS1(<YPZ``zxB3H}DTKcq zW}FjHii?tBp58pJlaX}Z+B2`mlEt4*7d65eaC_?Yf>hyx%R_+Ypm9O4o=r@~$}l(( zBC6ntj;R0!i0@!z;1!!{fsQB`!6_g?IS}AN$SBL|eQEtfeKPK@HnU4$5;2vfaN$yB z()c}%<;>Lmp_nmNpT4!UsFk)+`m7cIw6Viw1)a2o*vyp&AyN_Y_ZK!~5{WD^_C^Uk zd=3HDoI2S<-=0{)2cq6wuBf0JLxhm^NI+Ra)TEFr0ZJ4;c=7VI^4@#4<R5}+tB`O9 z>TXQ@81G-h8b_*$mnlJs?3TOFX$3)2;fLsb&R?Gz8CO{B85$i=P}Ni>GTi8f_Qi<> zBcDS1AWeUZp`5r%0oHQqCsxl7!d{w%2Rc79Jui6$-mya3-kz60Wp%1KBJ@>tNk~T< zjI5Nrf;w6qRU=MCL+A=@_>|80Wfv3IwmJvg6Xos<6{>d_;E6(rTbltF2^}zO%*Sdq zeictwmg0cv{u#6DDHEx5|4g1aw{vt1|7~Eopb*o;Bj48Z`MD4?H`lA%Fp%r&Q>hfg z(=p2YH24eI6>53>u2OV4GXmvxVXX?4CN`&%3RS<)FGeOaFA5Tpj^m-L27JYx(n)<C zkNNL&v@wJTKXv%AO}l;gp>Y|O{RR&PPc1m~U^~nL;aM6beZqR_>qE?~O$tl3R1l02 znZIan>#cd>lUc40t(TN+d_O{iBZ9^%kAiiD|JW7XqnfpuWxKKgzg_;dz1dSqd<zeO z`Wa<c7Q5@r895m)aP!a}Wm84Fw=^rMsStQbzS-YpCF+fhz4hELyj2U^W`t!3Gacjn z3m~)gxd((}E4FT0<ZBMX?HGSWG0N!yEK|2lyy)`EbCB7o4#z-fFblXG34+wGB+W<K zEH&1lAHEA?kg{ntyRQBuhagBLSUI32=xVT|Kfi2Xt=V<x`i;(cwsFPDh<ESub%=Y| zlN~bJuZiWUe?dV8mD|J+8w&0n76z11Iua;7F@kSi<Ztj?TwOh>L%Zw0<(m<M2+yQo z%YZBSI-rUCN)Q#1(%6z&WIKi{@nY71ATBeimuUA<@MyV-8&wYFBohl4sl0Me*}E|8 zH45Gk;V=TiA1`y4np{GP1F7YL7Oi>Bk#>eSrrTHqgv<yc81K3Y$|}cj2`z{O3_yEL zFRw>?tFLk|jzqT-_(dnnXU0ZThrXO93G>gW?M4&(qT=u#V&i!*NESc`f?MRi7z?LA z!Jn>y5hvm*>+;?g{n9ASLNwV+2o@bpE1&Vu%NLNn&WD+8nAFYNYq2}6AWDWay!SNj zD~o|?>Lj{*cHUoI^6pD}uD1T3H$;nuCG%}4!Wp}^CGMk#HnwbaM{WRz=UO>AnQRJc z^s`lK+K-xf`|Qgc3J_#yR3lqs>_~P+u_}lyS1OKX!wRpv5@mFwlRiN(ENXv;l|yd# zg_UI|JT7iqGrrH9$%%Io4!K_;0O1lQAX}7OQRaeTJ^RGd=Q{j5-E(ggc;dQMdsd_| z((tf`tDE(!7hh1cbw=f*rBq5sPisD7Bw?W&#atQi`lW*-mm!=OmWDKx%QY4-R*NoS zF{;=(w_5<Yh8r$eWAeBJgwc2GiZ(V(I(UMl`n!^@*{-=*^h)GlOE_0!Kvk@Gd{&Y> z(Z4>oRnL+0<+TiR_kV)t^(%534wKt<o=k5k6?m&wwh2i_WpV3v!O)^wXbw&q#Ja(R z7hu&L>iXnE`3nBDca578Z3t(OP4bbyaowv<gMD1r`Q%`P-(bSP;l=Uj<(s0fl`FwC zr)1wP=XIk+Z2*z4@|fg61cghfkp`ZZ^YG{yenVIrG0V4cnYJ+cA97?R#a;QzFiv6< z4*iHgSbO(Wtpu=!?b291$N6as!rM6&Yv<YA>5AgUqMS0=IIx3+vOAIR53Zt^O0Qq7 z20#&{gGnHmjY0eeVV0%9wtjrzr89D(v2ikTicBr2DOfa$tf?f&vU3ROHT-sJ_X-kV zeb$uUR%3C``$R$BLbqn$m<>tw>H+giA>!rv(IFQwt^3(suE97DG~r|+umK&4JQ#F@ z0j6OYGC%^vsi_VgEa|N-=$!gqu<ZiWQtAttP>wt`4&Z4dlf;whGs48cv|pZbGiGT* z{{EY>`R>?u+dlH1CNkb6P6JPAUlyl_9I`_}8m0D0k{G`~4O!?67^(Fs{G&}#kHj!7 zZb5g4&h#kXQfctqSVd-HxSmyoOwTD_k>s74yddlsgOM-Hah5aY414y)e$Qx%e)zna z18aEwF6bU+vDt0|Sqv%~rdJSR<-Pog{$I<evFF)2!ctiD?ab;+FN?f3u!kk7Vhb{2 zV3XwI`E$?0BA>No-VQFQA@lVkHfb746J2I1@lhG2sbe1Y@<w=eUow9zx5$WM%^xK4 zHAA00BWvDsYg=$RsHRK^<|@eIxKB93jSD>YMO__#+fSFD9|@!B9%W)HU|Rizvd$gh zK+UwJY+9w(en7n5xST-Zv56_V^Fb|{Ofh&nZY4&f;bD-vh0U%@w|lUJLc_|o^lIz= zJbpTz6uc0N6GLzLIXn4B%Rq3O{$(5M*XAtto*Ak}qm?~MS>}%d4GlFMck8Xi(u15} z@;tYt+INoQ_5^kks=$cR<vnT74@aZwG~bR;N~%}84KE+!`YFm^zbEefC?_N;J16=~ z{yp&%Bj{>T=DdSE`9sqWWi~(l%hF*TFn#mqYaxg6;^14^3V4zUK;{P0R>xTOSLZS5 zbS7j8A6H9_No?PKZ}C0Xg@zUt0v$VoD4@Q3(?g*n2L?f96Av%QC%6%kco6P52=iuX z|Isfa%0BQ<T7Fr5+P1wkm}YziJB^SeI#ZyOFw=O`(Ecxe)CH@|8hN;I_S=+`$g6XA z7l1&jY1hn?Oxp^d6RzFKN3M^a+z$}3J%q6!1E9=oP;^jIsJ(<i>uBFV;_uJLbKl@L z>g)7mp`YfrASc>C6L@NJK6g>5BbVyjoBC^|hn<;td}=n&Meb?!`10IpM4JDxPdMa0 z4};bJoc-(AeQVpHlyjSzw&kd<DV1ax&SYU^2nDo8Zj_4&s%?VFa_bVJRM2e+`)+Zf zUU5Xb3`P!jIj3GVcZX1?GBY*oIi7gw=Zg)*1?HJz+yIzL-l0LTvlJ{vFkBn#$M~_K z)_7pWH2{mI3}N+}F43fZZaBJp`FvN<)Q`?<2baKu&w`!aubLK|LV(V8aQKamI!Zoe zixihXheh=Ut5ju{-ZoYJ`x!9i_E?UX5A7qv3Y_jpQ?aWFcPGMiuui|D3+9ixVd)pb z4fxMw@yJuB03-x|6hZf&4?v3)@_Y0AAd&D}Y^14vnr<gBvd?NFP@5`EwYb>un|UHQ zmgidxF}PP$F_)wq5bMgg<XHr*ads~KN5q_pe7-^?s<%!e`ng5TBWT<r14vVAl#p)z z!=e!4fj%v(8`;?BY6(OXWWo<vBsgcJ5bQ#bO3UIf@o$qEsjh@yRw`e|ADEmf4ikW! zUxgEqkmb}c9&ZF;r)I&DzT9UpyX6aG@U{9e7HJoF7)+>h9v`7^BH1Yf+aC#S*8W6i z|3+z5alR<@)5GQ&yUJCb7}S@bi&zxWCQ1cAi`9@|ismyhZiMqEqL~X4BT&YVs4S>d zJ^iPxuU;ktg6gJ|EDtpn4E6334e&{t#%@h>ZqPrm_?M+^Sh<T5=`x)Acj!~+6|S8O z8X|MB-Hr>2zwe3D4j7Upsb8-~9KEP6YX<7n1Qxp-7h4CFU{2iNc{=$*EZaPvewPz| zD#fw%)@Lp7;dyNDly0p#SUmc6p}@cW3t<vsp<N}dGaLNqoC#W+IBi^7kR0jGq}D#c z$YZ-_QdtnK%&Y8!KpPLC+QaK01F>zR`xx$yfPleK{-fq(hKjOj2?G!~?QA)&vWNh? z2{&R2aWaH?n`v$}zO#3vl7W&@qNQ?-apW5gJH3Ohv|Y=^ZpG()WoIqX-XKXBy#d{I zmk-qR<>?C8xM)_f_&RKBP!4xzJ23vpTjuh_*QGnylI%-3XVdw`w!V7Iu)Sdti=Ir^ zho$IauuVf<!CFz@2FedQV4gQ;F8O44PDZS2@~-+b#ekN*@^=O}kHACq^^bkFA9yu4 zFxnM#mL+d;&0;ep$=#I7Rga<XMxJ-54n)%%7>dk+jY#I*y6EGH=*-5>R-!wfKreOz zK#0s=GT|&uyqh)%f4SiJN8C&1;DCdyAbA~}bM3@@29Ym7lt%DRTBeNZ*CE9Ngui_p z2!ww7%G*PJ27=xibl?K%VxxauK^g*FJKsEP95`oqHt$O+bX4jw+e$pkv~D4XS9{TS zL`Qt`4<76H1(xoU<E#Fps8pF0Mz9RAi1P-s1?oxF>^Lz@sC5hc^lY<WTFZ%)DJi|5 zx9iOl8r{N{rdnapGDN@a+Q#wi^35}W#As6-ODg+rz!4!dfyKq>-ohZ0ZpO+`x{4p) z(0ObhanmhblZ*bz{bYIcsd>jcD;;vDlo)TtCENd^JsZH<{;Ge0!5@~)OiMLoW0~!m z^mv%U%KF7Aw|XKe6JGFMrs=xu!LvXCXH2B&U?gsltWVsSl0m)BfO&G1gr(5z+pl=+ zk1Qg=0#^7#PDWno1*>*Jh-Z4mbbS5@#~<3DVPmwLQjce<yVD#?Z$VR#t07sBniW1J zk~@5v`_->FnKFo7OM2z7qNwA<)h$|T@j(pXDot>ECU)MTijQOn{Od6i8>Vlx&$*RC zaq*UBm&k3^EhCP@^qYTe$C+Vu++eC2#~Or6XL76dVaKJEXoBWu>;lfDVW*7sm@V0H z`0G@O6@wd~8}QL_nXTN@Bxm4L3kj}=eUXENiQJ2l0GJ!A;4sNfznP6+1j}>{HdR&n z{8O&d6|22`2~KXR2^tULIU}t&hpKhc^&ZWaM{>sY>U)<o7?SS{=(DD71AY1_Vkds- zrJadtD&-=M@`t!b5iM=~nXF=G8TXJcFMvsdK?-Ph1w#-~tHsh`geDe&FQ%7%JM)5Z zmuH`cWIy0VMyo$(f)>5lv%I0U;p5UEWh_&2&Y+bc2}k6hR=xT$JfgfLA2f<ttij6A zgD}G*m`Cg>oab@-3Sm#Ji@U)2#q7OGJ_&#@MilT-VWc2zqJikHP5{D%Ky;}Acb&XU zpQTT#`{-x3hX?3foa-;)YJOc~IbAz}N1w8RKn*N0XV{vinHHqD#>U%V>5Md<n%aUW zU%n<&Hmyh}M>y8K(4x3}fSHuVWkE1R^}3xI3gFG;u{!5XzgG(>$jJgpTZH0;M<rQG zqO7)Wo~pjv9V}grnJZtP&~rU%F5Ms8qex!~`39w@Jk9=58r`oeOgzZ#S4kh{OI19O z@!V`g9I4PRmOFJpXJju0z|Lp1QbfK@{8?8FVlDCpHcI<w6TBRTO~0tR)d^oBL14RO zk2+ooB^KS0S-JUVj;pg^Qal@4+cm&kS^VO3Fs_Q{q=MIB+LHNAZlQ<N&WV<mTRcJ| z^kV>NT}(b~KOf%$>GJ?vy@=kIBNFxP{=U5FI?b0z)Q_W-@u{rO^u2|$&vXtU1>Bh` zqY4r{ZQeVY4{U@%y$*p8N_C#x!O8qLLC%$m=f;6r{5V00SH6-lu#3AKUypUdIBS;( z6p)C0I$P>`5;F(i&Ybj}7bIQqAMT2F7JwstFPm!@GxY=rca;^i`|EssFr9+bZ=bPl zepO~3xL)qt))%Ch`YzGBQDG-sQM1n-sETs64I?!s7VVGFJk^>I-|p;~LP9xLmr^)m zRFsp73Yb;RwX0c?BP(X!SbWV&ltMK8v3No!$&>Y>)Y0T*_JzlE=1}Sv6chM-BoP7M zu{k=`Y^G5~r7E#=An%GFFqF<wBdbi!{zYRS@hbG>^EJ9fWaE4yF?B=XQ<_RhNvjX+ zuyu)xi;Mm2ox}<3oNwfys4NKIH6soLm}B@GhttbP?h8rhV1FCRfJsiWqTn1WcMJW` z+Rw2i(+xdm+7ciS+hWvdFm}wyRNfkUG-)8UY35<04UTEgOWZx~3p8w&COxqLl)%Sb zR-aJ6PeURc1~8L;H@5wm)##3|1LI13pXujjI7Ah>B?_218#_`PgEwZ;6+CihZ)D;n zg&3e!P7{uOs^@hgmLM2F1*p7rPrxgyk82twr0LWc-~4Y{n^$vn!Llb8x`dX~tyY3# zstDxI+VgdLwl7S{gt};4XjOIn8FDL%amcVesNLJPCRz|(ZsF|%;q5_|5>UQVaaOB$ zAIwB?`e}z_hB~hQm@-u<%5!Xb*dkXkeetyYh~}QDaP@2DIpc`TqYYCalD%cWMwctr zIU-+A%bhh_+ijK4H#{MaU2O;PzF9nZ`w9lV-89ku>VL8Fjlr3)!Ir_qPTttIZQE~b zCvR*{oQZAQwmq>iu_m0@oN&K;@9y1O>#g0YuBT3)^K|#0uKw5kpnlTwJj{T^X!Dc{ zke_X>d@wcie&gxRlh^2|;QR9X!^6EZFeJZ?tvo7ic`!(`|M25@Ofb0k)>z7PVTbWo z%;ze^t&!D+$9f6xK+h&cWq>)N=<uwkjWMXJHuPW!!~m`M%KJzi4X8FJPQ6+`_UD7* zyZP(>v-$^8)Uj}=0)<{<I}WVxy@euM8OuUu*Gj#bD4|GI=0kdRCS$($pQ@#}EM3&r z{sT83pWoq$9zOANo#JmB)0x$E*E+)9BK}J1ucvm7{f{%0?ySe%IU@&_vskLS2KHng zKgWpZ&Sbt}t5f9d_+BuryxTAlGcUq;v+n=}aj)b<Oc!j^(~0y(H%|D*MX}IWbIMZV zw(PL2{7&~FC4UnMq64rebJ89fR4rz3+K*3q7g&k5E9Yh@Reh}*@Z5|KBqMiM4b#-$ zAMA__`OhTu3(|AdSl@E)iqOTa-F+ldh4_Zpgb`r4gH@WDch1b~GNO>4Jcs&_iEi{F zptPJCy<$xsh}WU#&IBmlP?XtLb^phkxc`3sM300;kA#zj+kk|GU5|u~jq4x4#-m5V z!NdCxVr60Z7s&oEkd5_UKC&8+{KpGsY&`!p(Z2@&2Z{H8DzUTtpDhCOvh(o%`ywz8 zD>uh~w+Ia5tFE!}$@{D{HBG^uY@Q@bWn!5@@huEM67($rv1Fb<1dfw5G!Pu(2N{Hv z>O9Sp;X-SzHWj4Jz?G>E!c!lXhk=$><K-D0#NRyE-@K@6%U|uwk8g9?0`~&Pf=79; zJITZoD5JP$9=<2q_D2;_xKJN<?d(^X12_RiE=xb|s<W#1ap$Iu6=-t=dX0Bm<5#vr zdYV<L+x%q>&Lyu6e>71W1iz!4X|;QMw)Uw`ueBlI{1TpD>T;SG^;{;6VKkW1_BA${ znoz9QyrMC^z*=hbo8Qu2y}2At9s<opJwbC1p#@lt`j^lr%-R?(ws{Qm9DtVyo7yc9 zGESYH-{HOPOt1BZ(g?ZAZf~skx;|x(J4$(9CylmsRV)2&%W^hiTeM=R)m!x14yr$9 zf1-WW>u7RcpKNpB-kkOt6;<tXmo&3o{JCQtlk0*(^bCjLYJ$_{__WVSJlBr&l~tOV z(eNg$^HsCEI#!qY{t+a8>71VhO^!PTkP7pG_Q<#u{A2%{n5Tj9O0Bk(D9t1MrsJ*A z!_sP~5Yq{K^QZQ{@nvUDWfxd~;Ay68K&d}!)`etE-vAf=^e`aXP!*6{bs}W^cRRkJ zMy-WtfJ*7vM<=22!m1Kw^gM-t`Cyw&xmP)#L~1h09ZvfDP`=gI@9aHyk1^%#@Gtr@ zTXXLBCBK*N)5b5)4_ez__gUcq;ipmBm;cBaANOSfGj;EkZ#S+iN6&WC!oc`|A>Geq zzet^FQ>^BUkApJ(nHk{>t*NIk>bE;r*4B*Nd$ng$OV;RrK0L)|U#YG<5C{B0_t*(| z&HPvLpQsTA%l{0&y0PAP*)9KjA!FpCf79!teZlO%q5tpUr+m%#XXWjXe^OF&aYn_Q zd{Hb10aBW>PS=1XY8iw?km>^GGgM8`ZNc_a43DE0!ke`pbILd0zb5Cp`$zx2B6O#h zd#(mFSp?)iD@C;BzpM(Xj8&$yLw>2t`+2{Afl5D!H6Ol=XfMWMpF!8ZO)vwLP4Yg; zy^lYe4gR8JzcSlj3U@UJH*@8$x4DemtysvXx8$^VsowuA8x4cHKc2~D|E{U%4jO&1 zRx4M?<8c1@;%qh+Q&&|(L(Ivh&9(nyZzwD+4G~vgKOuirn46k^>i6b>oX48|EtYG} z1Ze(TJ+%2V^|MOXk*A!iX6iN`H<^0zlaJ@jhsS2fu%jxD5#wpaW~65<4YA1lmosIE zI-6GsMf>;g<~{F^-c*0bmrnTp_UO4RU8LUDpGF5r*Q*Z_isvpZ5(4N##5P{^1~ZsD zEcK6?Vbz-4p6V-_1-(kqom)mbpxN^|z8NeT1a+R(-y0LI(oTvrovGsdn3hr4@krI{ zsqRR7v})D#^jktkv46~tboETcz1J#Qj|?bYr)O_Ho&rh^wwU<!RPY<PUhvQUsE04} zsh_FP^YgX+APjOc3Xtr$?n2SWaWU)Y?=NB_xG8SD{S_w=82-5K(cgYx8#ep)9N<$^ z&UD6VzS(an7DY;wNp&bcGtd2idT{?&!f5ssz6na^$7Z>v+Qt-C2RVZ_Y6Tp9E7>tx z<^f`4jz^|ziBIis>a?mRuGikKbxa4N-I??F_0_)S+gM*m?U_mgmEQ~<b&W$ts-pK? z#e4)cfv_u*W4h})+JSfOtvJJEtVn9rLr|Y9PE7#-%)lY~72|~mn_9URU7k*XX`A!n z)}K(Rm_<fAlW`mHX9b`s;Z`4P{G|_ntHjk_GgNw0&LZNy6c+|LB@1bHakVwIbBBRX zyF1Npzdd85vieb@ZEbSR2}hJ?KjQd%Yvm;y6T7k0w9t|9*mWw$)_qOeVVl9d+MnS8 zOHSr%jrzL4nv;sX9h)o5CY(HUM$#qLOOis%^msI#stR49(aY-F#1EPDtp%ae=Akko z`}IAZMQWc}6pvWBXynI7O)kxclU>%>vtq)Swx{;D%81SgAskKxQ{J(022OlxY$2!_ z5L06mlVgVBt>zp42dDo<;ckizD;MkP#%o;u6|u0pW^3EVf&tq>2H+@Ng>Kq+JPodt z;ClnzZrW5;skH4W`2_2jMSSYI|3ZCST$oasWpwSu)nV3rdcGP)9zn%zIQF-9p@q4g z&s-|Y$C(PoF`Zhmj(e@;zr7xg8qx+@o^Qc%v&Id@txav-G_#W70e0fy0X~mT?JIw+ zm+`mGhnq3hy@dQnX*fz7RCE3PSC(c;gl%7I&I~+8d#q+E;%M|~>j^b}Wrp^g85oWR zXKA4s?g8NHWg^nbNKF<eyFH<BZC72~v&7|BJ)O(`DlCra_@#>p@e9&Oe^)_mPkv=0 zJo;u~P3TK?*Q$291+vC)xgfLRRvY${H&1eBV;vN276QSKLe<Lk1k+;H!3uP%a>X?h zY7)(D=Ym|b{#@-}<~oZ$Gu4(_FC<;k(E46V`<`^ttQ3<9#6uJD@deM<oDph<J+&&Q z;7}rV&o9Ra{&<!xZ5O@hf8?AYY~>{LX#iYk_};TT#~YiB2tx>RX%ATj98@%n2+O@p z{pgQ*hu-5hJ-!FTjbMqk7q7&N#9*k+Y~{>m(Pce&xO>i3JP97}7#$4hWI;|>A&)`b zxcst;7w=qvXmyH5ZeLxE^lwmUt+1UY(lZKirNx&>Y~15%LB+NQr>tt>+wUm^3O?!P z8YMfCyS1$Tu!Yz!T#mMBxwk=SX8kNQ5l3#VoI^vQt2mW;Kv@b#neF2J9$mom5UW^E z6^}0~P!mQq0g{|M{}`{Te_SNWjB8e4Mrh6!h>iH$l_P~@>B*5CX;QhK=H<%6M2xhr z2a@lL;C;0-Q$%t%l(&z>8fd;WLGVfWWky$w$-+O5NB<gp&3IBp^I8G2w875)V-!74 z%U9cKF5$r=^xckd$3gu!M0~%5CRZd0D6*|Fyhn=Fh5ipAX<_x7=GR0YQP>*kj=$*_ z>oXI9y5=wE9&!Qxgw@|}J=}(_o^BcYUmj3d%xdpwD>-r=y<YTzBVoUuvfF_@bRP$N zsj}d)ouh;Y?_MD^>ku6$6+A*hj^eR2p-jpPrt2tJ`-1S1t1T;D;eHtkx1cDjX7Zk! zHS_yK^HeaVkoCWA;R7lXH6w;P7s&0#R+D6=l0Afm-2oLwzMxcTgeB9&I06K_fD1ln z(8hW1GD5@pg0Y6Zv_^PG(aNf1Ipb@|&Ef#7;=aC<9T5jb7=}aser@gT%D&BHx#pX% zLylBKJKVE+K&}_2LgB4KW~qV38Q(CLRY&Dg$B<M{M%EeLhft5`Pcn#wi)f*<qOq_} ze!h1?lglm5LYAz#!A5*~*x$9_0S3h#V%(AVZpE7I@Y~Cl(k*}L9u63|f7Z@WQXv;Q z2E9~VqhddFwt`RpC?;<l(%T3^6~J~xF;M!L*6pbp#-FHWbkD`7Rrsl$SS2d1&cdVz zC?O~DX{MOxUCr=YD)wVWP%%kfq4VLY<r9#^T9{2noq{x>Z2gvLdgHrMV}o0+o+ya* z3xBxIC3<70fvuRYOF;Ldv8YOq2}dJD`g^#<+-hQbtS`!pvzb!Be0+KcpG((W%H215 z6QZLDn*JfVly+?yZ;W@omspy9Xn)Li_!o;C`CaTmln`PFVOamb&<rK-Y)o)=u*V1+ zFb4=j@P`YEmf=jOM_zeNA~Q@8$a!deh!fQ((!=c^SiJXiRu?g@x6a!0iohJE5o=(J zymJ)*zjTdc#D`WX(KHu8E#Iga#R;rQGff5918Y)DI{~#ohGf%9fP4ukai4+~OTJMi z%90jKZh=Cw7=Q#^l5Z4=;-j@G&0ro8p#3AqDjl^BoK7l|in5_qN--@1kkVSpuo^^J z0~JzDqX5aJ85AQDv{W*zhEdMIm{ijkKyhhBQV}o;o_4YnhjK)QHW-*9%PJOyQG&xX z!a^G+r%ERo2@o&AVUTPDNCFX)ObY;zB{V5TB2m7ycO@sxk|I(5z=u>attcVjp-dv9 zWE#Mq)<=FX`6qp-bd({`TrQC`R4>YncCo}sHjz#;3ZO)rR4S81rV1Yp@SwE=Qplh& zhibq_11xFxOIT!0Qht(z8p7uSssK>{eRwR)9=)g`AVJc80pPd1vq;o+$%|%Gzszkc zz)1eqiuRLYL<{IkJAw`LWg4*pUZn4<(F!H*#{+#CMx=r7qERTNFTDU_nOlBZfBF$2 z+MV=$LE4?veL`A)@{vto59LTUu!nTy9N0rOQVr}O8<_(3P>e(adq_s^ffuR!ytH|# z`?$1uY5S`{0m_kNpaAK}0q`PmUkfNeHBt-|AR8G13Q&xM00l@!K7bc#rs)6!;1=~r zFK~-|M2Xfz1}(8jEvf<FDes&P@RV~72W*yh7(^M#IcEdf<(#7d-15%Jfc}JiDO!gF z(`>-1ymKyKRn9pUpe65|3eb{s4h5vkJ7)sY<(wk{*z(Sa0BkwuAi%M_a~?pilt(Md zwd5pW-;Q=R$ut^}UCN^d?|r#<w=s0o8a`!<lD<mBR4=G+_`Rd&$?1P1XvvUX3+wL$ zbo6{Vd4KKQeGVOcgipPpq(2ig{eKkxYt_xYySAYt`|znv<n(qzCP#k#9gmKl%YPA$ z_<x)LXCof)_6Bo#7pLI(a)ITNK1filYG>+2v5AJ7^U!j&)O?{J!i9;%>BNH8#A%m# zyrN}^YMT03Abq4}f~z-$E1)73gu4KwYx+?UdQu`IMG0bEAS<#g3YAbyjDc4nFU5;E zi^M`*Mq5Uoq0W+i`~$Q>Ua%|Dk>HeAmY_zTp@2u5A<0tWhy~Ft0E#9gk|U_l6-n@v zIhgi|5b)$VsP>6q@D$ZCo#SCNq_!|bFeQ#8ifJ4vmJ!fXReRASs8Ny1lZGO~fRDf; z^deG;kjSXYMzSK&rAd(@aEZ_*ZE#hg<tg$rWdO;U^in!adIbt+u6T-~y(QY;NFTLd zLS)R#_o$C#lN6IAE*PcKi_}4j5&DS_69wu;02jW<q=`(46q&;U0sh3;95{(v3C+o7 z)Xd0znmGw`3O0$wvcQMLmP!)BL^-8UU`~YfaCaoKt>g=-93jPP-U--|pLC^T<fqsJ z(!wg*D&l-TdEIG&u<99o5p!f;LC+lRBkqEKkuvQyMv-vRy;)Iw#HYvuDdu0nQlWyS zYnn&BB0q_1wVm%0*Gcz;MZZyd6(6uLy_12CsJ%q8f@lxA6z)_f8bw;;f7uq~C798B zMI`g6H{@rJBl0MH!cMH|?re+7$Ny3+U`WJcT#~+GruxPJ<Ix4h9$1b9B_2q4iAlQh zLEH;WMND+w#HCl1UEv_=g*X{GTpD!QOr$dkc#LgDH|&L62~Sje>Mp^gV6T|~+1f2B zH~OP(F*o)FMTvfruEZ1QB72EdHM3P!`c-rTac?aQ14%c^1x)ol7dZndH`)ct6i?Px z7qo@Y6i@JlzY@o2_LO|-a(UvF$VJVOvt%1$Exh|Rkh!?dOkla9EwuY~5V=Zjy2H2- zt<pKLqwh-*t}Gz(1?Z~2yt7=f7N&hWuv~@ZRrFd?UB#BDidYaOXK!#7Gqp`D&$;MS zMPsSD3!Ey#f~-VzB$jILKi#<0OjWfbvm`=!{vVn#Bu`#2Tbv^sS};1Rt`J58BUffS zR~7|cm7YDK3`3DT3r`j~xJ)8x1cORCY2+ynAiMJ|3rBVqQn7&SAaYbP$(ecAjFvMD z#KBulHi0jins~@q5G8Y0S#T%g!VglXXoTlTqLERT;vh?kc;*)l0uGVK;mxxY6{3Z& z;gw2IqK$#(6C#T7IC%Cmpy<ka{^?sZ>413=I$n}}R7m<5p5b){lF9Nj?}s0s65uv9 z#HvO%4F7bnDzd7_FsUVN^tiJ9QyG`vQbxM&E$U;DPo@N}ghP>AQA>m$(>P}19Av4~ z#l0x4gi?`t5k-+i)oua2hs#C;dc=NYjryV(<;-CWIU5>oB%(S{nbQ4GJrY2sG#tF$ z21OJ!)aElssuyxh^6)$WzRUm87kbS+z&)@!kiYkZaf5l+C-I7~>$=NsEc~7ikxz0R zFB5?1`|Tb4g~g=s_!({{4<+z7ct6zB;Iq(+;I6?gVMzd_KfV`&7ls%4C&k?PEu=tw zkWsATZ4Y|>fj6!f-0R3o;4##$w=wfwe#rIu3uT^FL4MdL=Y!g9w4m}R^PK?N?+b4M z|3WL2vrqU-L1+Q^Z{5U$$3p|+10gF%c`!Bf0?&F{J|23T0^Na3yFxG5P*<WmN{5$$ z%n)u6Cc6$(6M5YX=K`L(E8njg>~8GZ?H;y}-_bjeIxst+I@XhpJK^3DcBPg&!Fy(0 zl8${&&I{_H>Vo?4><vQO>Lm2E20VG4aGhwK;G9^U(9R4Zo|ssa?{XaTE_mm9=9`y& zn~(MHYxCHb?dEW8BCRl(Z*z!jP;%RP1>I~w;-G^kB+@BphxOeZ7XKky{5D6g@8T>A z#)ibY*nAdmUGo!#oQ18Mt3N#GvvrbPES<bSk53w;+f|1e_SH+m_4}Jzw^15BPMBJ2 zbZ>Ombjur9x@fwcev%Qj8BIlgl3t+>+Fm1X^nkYD?Cvh&^~Rsu)$j!R{bW0atpY6! zOI?0CAnRXA^QLZ2suMp|?w>*n%aX!W4xYkP{3e1`3}o#={u5jCJ(sTHu5y;4mX7(D zRkW4Jxe<5l@|HiuHm!b?r7IvQZVGX7beaP}=<gWvqv2F`#Kd@7Y*ZW`ZyEC^NmVM8 z&~t1TxI2i;OnfY~kb))-LRIsGZvEGvKWojd8s5;_vq19CCG>vw);+#1ct&X+HXDDf zt7aa1<l(wrpX!@Rh4Nnw&yFj*N{nrOztg3eD&Lk>D6zJsM6y?LFjbQfsno<SC-2Wy zHt}}OoI2B`=JWrxEOTK#j@cBgg0t{&DKD4vONcfq`o%uWY|IXE(5+y%@zP*DdBGw~ zpCf4C3tc`7k3S3FJYTcEoST!cRs5kO#-sBNj7$@9J=aX*wejU~^>LTjZew&+pLucW zo*yhI>khS~0b*pdyDU$NxZiyH<MsPCRNP(2E?}o_&2G!`yp2{ApU+YLhJt3lm|ql$ z3K0ir5&b+&|Bq*=2sb)JKDs)_XCak3v)@Ql$Tnpjjoy-yss+X99jXz)IZJ4o^KdA# zDd0P;w~jU6msqt|Ex|_8v;W-!e{tV7HO(@Jn3E1Vs~>%ZD%W1v@VtNfMR_|Yzkk8; zF6KgW));A$YS(R-qkxbHa}CxGYz49$>^v|zsC59(n6m*M1gQxz6{Km5+W^ppXaS=J zj}DR)VQ)YMLEr^J7Z7QKErGWV_!<+jU}r#1LtBD#if}rSv0%W0vj?6Ia2V6EKxH5* zKu|$o1l|tt7&EXy;~=Snr;0$SAjd#RL5LP0;(+IXA;N@#iw6M<zTrS1LPrIW8KbhG z;(!4lphSccU>;x~M1%{N6A&K2T>|Y$5N;rQ!HIXF1VorgFvh{QMEDY*I|9{7pqwBk zM9>ppdBFIMA<+Z92H>^9*im6Jz{rik9s(WAxrH=Dz<CC=A;aT|p^?F1g06!g2RsMb z2aEz81M7o?Ap;=#Ao{-bfeFC~K|VqLGnBvrz6n7KL41Pw!oCx|fV~jj=ou5=2mnw( zufN?8-7wuC-{9}s?=tQx?jr5F?{e;H>|*X(>{9MZ?*8itx*@n>xIw((xUt=(-Id*i z+jTZZxuM@>-BsO1+cnuG-4)#h-}N`<Za_GJxPrWbx&rrr;17hIhx-xK9n>AjAH*Mc zIdD0^9JCpz7o-=M9h4nt1jY@)4YnD09&{dP8)O?;9aJ4iA4DHG6*LtnA0!_b9TXji z5QGqTA9NpBJJ316D+1%h<%HD$wT758fhX1GniCLrKj-|(J1ac)_n7C4;5h%_{eMAf zfkl85um+MtI}L-y;S8Wb@|c22Bkuk`lK)=9FRppc`H6Q{Xl(tM=Z(NB|KQ?Z$uG6B zz5LGQ_a(xYOnkl0rm+!)4BJnE(TrQZQDh_EX`>hgljwE1mALvDJNoVn!RZ}Kgf*%P z`gJZ3gf~irX6g0%_4BWb{DFs-A?ovVmTDhj_6Ca4E)=(GVPAy#QstAqPMk`L+~<n& z&7F^R=e{{)qb+;kEejcQ%UXw?JM^A_{qQc7-PCBeXX8Z8Hj&L1JR`h%e&6Rkz4+{q zN;|CVnLiDkHEGKx??^S7j6bJyhIQA_+tlS5C3nPpxkx#QOHmCu{92aSR^V%l?d>r2 zV(T?eQWsLj_3BEs8aZEdr<5$u*J$koH&H+Ii@jIKt#Z>05$w#%O)Zqn%5CM?ytx|L z*D|$R87~+-p5n`9g^KvrcrWy8?!7PGiI?=^Weo!B5!NNwP|_RZ*DWsKFQTj0Imf)2 zSKqZ7&(|K;*vYPeUUjP}<9>mHgI6Y=jos_L8~Q6|D<G-E9u8~QwJ2Wgcr=Hz1+%Pv zPH9V9@=>PI6*R(A-52F+RWo-tBFPCw8rj-;z6eb&0&Wa!W5km9xCmgn&4KXQB`>}3 zpVWJ2#rVulU3ob7p6BofiwoVH0sI?UON|QrLRo|Q)4b2~xRmX((ttq+Q*JXxhvgLW zyDbPm`fenvH;=a5?V$SNu5z-z=<Ui{{S5ae*v&x?Q_5?L=SHTPFEj6esebaac!Jvt z)9&?;HByvDX;f>Xq4Wm<*xy5{*F-bYr(<jN30S2xkKewdqn%klA%0I2oFkI9sek$l z05UhEuT5RJ6QMkkz2W4CuOYmmXhYyf5`TG`<<*<quk{32xbg2ioK8=)xd&|amc8k@ zBiin>I|cPXR<|VQM(3}k6ERK*PS?CK%3Jbx_p2TUx}x-!ItuxkJs&H?S9AjX;8c|? zq%<d~nq)8TZZd<;V6+7sXld<e`j3gMBtvQEUQiuK;P3a5%}jIBVeI)RKl>gY*uMNm z!fLC`?6BuHbu71{HoeyiJy9+hc^<AlhZloCdUkXDuCJN{I#*S7SwO$(-=G0qArq&! z&#eVEjbD9frppbjlI|&yuY(<FO$DY~8^Kcg7C{faLA_8xz2F=eGz2O`ghJtAhu=m( z3S2MWkLgGJT%b|#IGla}^-~V6a|=LyMT6o}6(P`1z$Noj+`<SBEh9c2`CQ-e0=tLw z8G@4QR0sJu?vqqREz_MFySIn+^`U$A*s6tsGsV#@(qf-@$I6S3w1vb|g$V_YOmud& zoJ{0{!uCfvn7&17U!ywPzn|#KEOtsdX+ELrB`1hsb%u2<{zJZIRvSqdeDX=#iKc8+ zd^MezuE_QtmJwWRIZ8I?^Ae-$gxfHP;M1Q@Pgxm{1-%{;=dhH04J@q%13A|&rJn8q zEkm=^!ToC{(Jnoszb_hW-WQOgjYrTfQaJ}~IJ;H0?Ajwy036w>lNVxW_YUuCBVELB zWu${m(8{eHzykz*$UCIGt;#$VQyF4Yi-zGP;8+2h;f<Ve{!<+B368mN5kV<601@vH zhoiuWDecy=ZI5pQ7K>4jDQIX8L%s0TssA9NS*FI2nKBh+Uz?3IH!P5LJvr@6o{csf zrV`7_vZ-0CNs?C}D?6#zn#nP#vA=s=FXJfc!1lqnnQ}Whxo!B5Qd3!Wja2Uri1QT7 zKOl0!PTgIq8C>4&2<?mUqp9Y!^D2b8s{P?C-7->s(#=%<_dtdZs^gc$9}{xWHT51f zXmm04&{#j`y!!|Av*&AQja>k)hpQWc9)|w!Rtk=j?cc2=2-&R)n?<I^pF6x81HL%1 zjWoo_;cJCwgN=mB_8&sL^z@nhd_>#oXtPN6)}1%OWiy-~m~)+T4n&!!YL0gnnt8W3 zqt?ev1U@&-;IZk^{Ud#aZ-ISiAM_^ClGh$jo_`*l-EXgq^{-zbTn!Dc$(m(&wXgTX zdH~T`nZFX&?HpIQr;Y&8osPz2X-thROMQ+7#VzWHgC4%loi1bb*@HJ<`t5-7zJ-iK zMa6q6ywsuNllRWGOXssadQ7t-ZpN8p(6n=_*XvsY$j{xkfOBS*yO@@dei_7i=Jukp zN+2*~qk-fM?fx;?9PgEXafylGQ6b}9rPc2i-QNDP={_CqgY?G?6`={5mApGc$N7rD z7=<TlxE^$f=;~&2WQPkr7CsbKn&y9CFB3Z(hLtGS7y)Ut9^UDts5d!0z%mxjNOQ{g zQAVk&sSt|gDffL^GGFL#)z_LVs_g~fwjw<%D=Vq!N&CuHVfF&Cea>3bYNH8W8jEqM zt)6-P$D?w+psR<8<?Rpfs~)@j-ch^vB^@3iuTyVwDkKGYHdFMaj&D<1A9V1GD9S=? zxN|RTu2ooZ3|Tt7^A5L|(5}Kt%4$20C@3X_ee|^=@5?&&&;E~iTS2a<6U6iTk>z$c z?H%%x6f~HL1xpUt#1Y7)WK=0TbNxe7%qRXv-%^7?4YU!^__4LB{gMr)$XUt08fl9{ z4hCYvw{xm>&XNZD?c^p!{t#3+)IXl^p<=X(oQu^Fuq|~KC~dCnoMYut-96htsjLS) z;$zo+rW@Y@18P9R1(7Rt*A}O1g{#tt38ErHGdFXJXjuN&$@RzMybOM)!O(kZM|iws zL8gm|4!uck^%M;hSy!wXf>VA{?PY2tQSe_joVA%euKQ)PQ1;LHtX)m|jW`FAH4)rI zRXP6qH&EvxnC0Ag32XJfV6%Iv9Us4|gkt^Lb@;<;M+C;OVu#vJ073n0*3I{DZJ>fS z_glx1NQR6b8Tf9yLkQIJW05n+qfnzqYdJfOO04c{ab!IggTB_yWivWfBJ>~!Ufo4W z$#@C;>9`Cyvv_;lT=McKbPk$!x-gz(T2A(<OigWpB}cgu8XK8u8O4bf{AOun#+jIB z3kzL$IxXyy2bbZIk<6rfYD8WDmyQA-q0kb$LK=^qT(tGC-6$chWpl1E%8tf^QJQ%A zb428{k*IYBR{F$_mi;$xPA&~1VSbROS6azPW#?YX5oCQ^TP1z*_Y(C@a#%TC61heA z(!(%4V45C`;dT*b%vCthUiju@^E0585E?~wrSvZWEtk0H_Kj+@{I6c}<8-8qG~1R^ zYU=V$B&(yi*%`XKwVGb&KjyJBT0#w@=cry%Sco(kJs_{;$%&vGg1ma}Q*{liMdG}? z{A)(KXDbcNH;553qIR0O8|+7iw6Ut;2+s#4EA1nUkQKN4JfW%Yn>oF@x%BaMC+XkO zTUAG&S+A{mv%dPZ#|Fvj7U|AjqN8RjxOME5!WoCol@~UxS*-m7s;Z6RglPxUO_!Xv z<&m|5RUPN`^gA=d9fum+Ozonk;PEdf6gf{7!hWciIk`S_zjMEOcZfe(teX-%pEPe{ zTxy)W@PA+U{rz!Wlrc80tiQQknmc+q=cI+2FreROp5}@hH&P0QoA(3Pq5oG3YI@rF z?SuQC<i_g3gktnTwSs12bq$q!JLf_bw>II*wY(pA`^Y}>i?6pemb`9W#Qj_M^L@Ab zeJfGg{C8eSYh%Md>T=huYj1`9(KvjzzsY}3KEqp~8m6B#`6<UMJ*!6hSNuxHvv;tH z+H}}O76)pEb#s$B>C0(aN-5ds>)R+vS!&7=Fk@lEV-m}?FFUN9Gjg4aI$9E^kL;f% zXJ%$wa+Mzy%^g=LPHMbr2wE-YvTq3CHNS3&*lTW!GBR2|b_R`2+q4Le9thAXStJkU zWo4W+;R0tS`qX>G_h0rH$6nxFmu6ga|K0-$iJWTY9IU3}@*}NIEzha;`W($FJMJG$ zpzL7j&5GB}J;<`>u=dN3IWN?OM8AhH<SuTp6_=V{zV4m7>TSNZd)wkS;VGC=X;U{C zht~Zx)K1Y~YU-;s5tCF^9r+Q~_Q*IIbH-a2<4muqtSe}<Jz5nDiOo#d!{N8mV|b5V zKBJIXiAZRIV{(<ApV04fu;|S$eRv$7!RvTBx;&aw2G#4TJ?IKG#|xB47<YR1b=Zv$ za8f0|y{;rxGMf-y={H7p#Vq;iHCRep|J~gInja8SRf=-4NwMg=?RdEL_3dLlT624H zzMML)tOsCWVj7YOeX@ZD3cz)~e(iV;aJsjm{LcO%h^Z=(5M2=%=7b@lau$I~GRcNG zLYM@W$dKG%*BXfMOcPa1*HMd6xx5lu<ld&MRjcXjnB!jm#e2N-BXDiCuivP@@A{20 zp2AAtc>UOW_9%?rt{34bX!VtZi93Qc_}X!M56r9v?fDX#Eo00!-Zdno^97veuLFy3 z0CJ<eNi;8ZPh!FI)oKBW1LMiAML{Bbr62OnO>WOXLOW{#XE;R&?zh;7S$GbIL5qH< z<UxXYuP>tPS)S3F){c>emb$R?+AtxkIHd4KZQOZ0|Jcd!mQdmh<#Ddj7seb-kLfo5 zhGorF1*<}K!H1RGob!VA{xPwvpB#eMc-#i;RDPL1ADsX0cATRhnsz9dtmyK#d$?O4 zfZXxhoo!AJw-y(mzX-=_bG8R6k~Q?wD>Nl+t)|4MlQm}y^ti9h&P^SMI&8p|2zR$k z22UP6U@-K3*mTku=IdDF@|``QD6)F}rky}nSLW6xzo!calXET#DK`q*TR70QPd`vJ z*>Osi)tsOl4d8$(#;6k(KHWajtS-Nm+I+IWS1vy1z<N&lA^iV-4@`W*-W?T2n&$m_ z8@PK#`SCXZ!g1O-><g(O!WOLhGi0|EclxFuNmKQUYdCul(UK(u_a9j~IQicYG<(J% z;+L7zI^uuu|3`2y0F3CL_^&UBSG^W6DgKyG;Y-|E(2vMZhdH!I<Ln^bCawj0s+GLf zXoqG6Ck7Vo70fPsYc_|_qb9=zd)u1i5u7gj5H!sZx6L$FhvD`iU~Sr>{r8&WWrVKF zU68eX!Y{OQNT-wj@}XM2*9CimW*f;xduYoeO_}!0jO<N`t{Jw$#(|6Nw0V2^WM_JY zEqli8wo!dO=tX<{>GezK?Y0q&*cT6Nt9C25O(IwOOT~7=nvB}+d3)&^$N>{mo+)V9 z)h#jcc3OTl`^j1L>?ZbQ%gkLBkFt$4s)Ll=N-hhlD#i6o8?}F!|Lk7wo=CZsZl>g} z8h;xdl8K294bmj=5lhEXGvm8S4musw{^rw!`{>Kgijx?U27eHUD^vz1Vob)87HJX0 zOL#UhP>yJP9PCLu;5J|?LQfbo-XIW|2v#ux7HeJu)(XpjrNRW}=87r}1+pNMg}o`3 znuGp@=Zz|rDa!!c!iV?05C{Jj8xkHbP#&z$bO2^C!FZj+fp~rjqS%QGX1tvJEIB4m zrA!>%S0NA490uYX>GjkYIxZ>^6YorBLG@P_dW1Z3Mk<LP(#i~^Z7YZZ##lCS8I~n4 zbabDEGyzUmI&P&h!C+{?2lr=!iQE8&u1?eroGuw8Q_!gUc)1Hn^x*eLp8;>d1TkdI zvp`I;1TL47$gPTSoOhZ*csVgSV%B}p`MxyBsDvt<T~S@Af^-;NpF^0Ji*C1hO_I!( zaV!<17rS1C4In^6a4~YfQVdTvp@eQ&GW?xF!f*nN-1NbYn{hEwBtM1uP=<OEiw}Uw zC!(P+M*olzM#Sx;3c&|&PK?A@3Lis*rWI9&tW#wOF|Hco#wzd@-^57S4IzmX^MirU zrBMBb*YoCYkk67DsS*BuRuk?>=v{HtihQhHb{xw&CD$^nE+cVmamy^UAM!?b+0KLH zQc8pvc#}ACue{==eS{Du;e<-SB(p96DGVo-)M#jY8K<?-e7eNht$;hKtPVz3g=mt~ zM>fXv+ZC7vWG`Z-Gz0}2`6qgoFpNdI!XZ7+y-DBMQ_xDK+aV5FKSIGz$jpO-#5!q# zQW|v9bh~1dGtWQa-fYQnwy|jVQcOqAm;>pBYkvch9qngupZlo}Mj>P=GKe=UJ|6^v zB#SFl$R{4ajQh^Qpdb>+Hh-p0q7;RTkLi<uunTY|B~-upsewuDVJOk!<5vJVFlC@= zM4^+?CS3uwWv1%k`}!en<u%6IFuhq}UMiVoU^-b%F*_&rkZq*QGACO|p1k<$VEfi5 z6)ZEq@XWO^bBSr_*t(d@T$>Or0KAI{Nlb(jCO0l-@u#Pl>hB<7oC%h*fzJ{J5e+EX zrpmlJp{37~m!?=>JX;Zq1%X%DN*&@x9irMwf=dpl4Yj4&ulXk@Bn_Q+u)cs0Scfb= z%AtN+y<Z=q8lJ&*b3TW>vLSry+99u1Yua^A$vA;oDqSk&P~vq<c*;aT_3s)q@e#sR zw3y%bp;aZ1AUQvjtR-7r=lu)sk^#%Cyt#Tbe5h(cO<!YXDU<tj8|;ruNc<8GE>+`V zf0dLraV_0pQkX4Tki#&-1}Bk<vtk9vrR-@fd5kz`U1L3ijf#6n#J%}Ya%m37-{z}L zS)dtH;8+k{gE(ePVqMCGd%vGIOMX}nkjxlWD&=b<!NyB*m?Ck&Dw}Z(QKPB(vq>Pi z^Qq2jln8Zw)%?UQx;xN7_F-D+aCM`yLYw@p4j2a+s*h?e_*;?Zwz@sC=FnHTs#0BA zi4&+fmln?P17JA$Jfjoy!er3Q9yR)$h2HReO<EFgPLVIE%3XU?cB;`|Yih-svQ`v$ z`C`vi>=xPlx7rJGml|dv9pAFoWNchQjk}12GKn+;G|UDZ__`bMEx1E2@#{4Usv*3| zdy!n0^9Rp775ymLUJ_z)>t=T~G76d5BT<pMK7j>ZQ*4zDDNCm^Shxn2E-`%^Gn6SP zkk;|%^GvEZ7AzO%VT})`nw+&aDQRV?WhM%%dSoc;s(&3{7gUg3=9eiga5E#n0UwaP zS2iua4J2eNA%El_n$g|MCqjost=5WSl`ENbR%|a->V?|;D4fhN%*Q>GP~$D#qa&Qe zOsQYA?#-_2+>iHCw_P#}FH#S!Q0qP!qW>Mh4T1Q`2#ry&{*3|t;WfmDR*YPXMJkYi z4uZY102@w<d@zD}K&I%}FR}c!m=6GX15}AE21N{f7dR;|B)|?ut3dhg2ktLW0JRF= z03HzzrXnwvK_<bE95WiM3?2)kB@vhim=C`Mr9jd8-x_1OBaxQal2KZ-;ZVomaiz#b z@ZeEILkgl55R1><f!mW7!5oFZ7pw5^&{zQ&X^Gcifnglvff9`sFw$xRR%8S6V())t ztmHPlO2h#f<!)#sa3og9we+Ddm&tN-BE+J9O~IFJN2IwTL>HGfnIU|sASOsZKrGoY zbP^ESxRD%+Vk;Q)Tp=5yMTWhaDdqo+*7>S==)?j-82_T!HjF|~Ijlsu*08qo_&?{3 zG#@Vy-@i5KL!7DZM2Pg7|1)l;%KT`>d^rAW5K9(;ncOCh%8tTDiY>^?Iz}i(Ne4$# z0EAEU)N~M472hX_3M+8_sDYFNK-eI6p(eN#`ib$sW+{U^`r<b-4mfDk>7Zpk_prPO z6<bc5T5V>nYMyUKg(MPp(+s_Fs1t5%_H_!A&Jl^FwiezJ!BS;%O!MOr+Rj0I(#kYT znJ#dos<!YgPEg>q$)Xa{FKClg5~iV4(Gh6X6gIM4IG4q<Kr~ifAmL$h4&^Euyc!>_ z4da4dUR{FxFnsVISf`~x+CsHs5G5N#R5ta>WCTH~dKu+|4jY+LhQjb9C0nWzmePqi zn^>7bx@;*MZDD~FT%`i_!X&4P;IKH|ujnIqLTa&^gmT-XgzyZNDsa&O>6%4wI$dw* zL{iO3Oel#w{d~z2m&HeT+(He=J{JutRQQ533%Ld$B^300mANiqIO<s>Vy1R}aq1~- zEh30?6_N;@FngYMWS|bc5xQj$-6Bqmc@-?Fil9^hfyJFokgR~5LznXgIt5Ebi)P7N z0*i%-RLf=<U651@%?D&lf~yVTrVeg+hDc_R7YVBt^U&lgsLe2!<_xQ=Xhc{DsD_7? zMRua4<mSkS$I+pO?gAb0fmAcKWe-6l_#&(rF(-$`U|ohtfXPt0NVr`v$`J(UcnbL% zsNjhff<y*(Y0?$EgR1NxcWxXM(#ipec_;&(o&xByRof9@Ca`8E%!ec$kDMJtTOTr< z(x#wKj_H@PsVjxQX|C`M8CtDI^`nkYuhc3di%M1636I>69I`fQ1@n9bd#kCUrf2~V z;V`ZQR7Mm*q;`6tCU^*BjgMs)L97%hOc3NTk3<$9jCM`nI5=rZ_#k|EAt}W`s}F8= z!lXMM>OhJ(r!H?sDi{Fw1pvuC*&^3zh%#P^O;U@v2de<JFICIQ!A1h}6y6oWlki98 z!44;`)0h#zj+F)Mb7Cq<zDa>%3R2;SE|Lsp*uVF|1~UR6+$r43s4x#6Dx93QAxW|l z^xNI1R$mONBnUi89J1EQ99)=p7vkxg0;O(;Ysr~Fsu*J$S4&<78)gJU0kRXZ-Qfu* z34)A;ief}Er5XrN7jQ_4+6~}yiy*j6X7KLPN4ZZHXG7%`NAg4fWO8w4%V3`e*4U)7 zs^R49N{<CAj7%h3O>weS>QAfMvO}6MqZ%U@yG98+F~cLYz>s8?B^#?voPUc&Lts@B zV~<yX%q_4UFa!n;hfQy@D2l0Z$)q47N6z!|wRi{a418m2fd9tT5R;;44ia4q(fejM ztWdz-!rFj&L!+%!@k_KxO|&>dwTNqYz1$WY3jN&8CQ={q0P=!8p-J6`HC6ct-WXR{ zrZK2Z0zJ1<`IS7fga#kz4?;&d(&4c~cd+BzDtHL94kZ|-9l>8*1g63}iDbjtjE8mV z=Yb1bjFV&$6eKVq*lUaM3BouS5)zaYe*@vb0#+xCqcm*~)ulcvDwe`v7%COT_3+>l z(@Ql!BjcR#4?!9tIJjga8X*Kx=D4KECrIF$#A75cr7kVEU8<zWi`sS5CA(EiJ{=Yn z=1k@7teCV9DNG0}A#OS$x%6DB>Im!S4<s3f1CpbY_g2t>Z;VnR6qFK_&&Sc<ey~K! z04Ph~$)OT|Fbl&y_^nF>n7Am2$+3a6NW8xsa*&Zm?T(eB`Gwvl+KI7{s8Yztk)ccc zU}0j_qyaPg`4X{~B4gsqv4CF_tqkUF0P8_Ul9eMO62?JWNCJl*jS)d+Dw6(N4~Jes z$qYmF=b@JjJ3Q(UMx?K56AKw-8Z#NXnnWa=EX05idO|GrsB|P4wrCEC5N^tr7mE}u zP&8a7YHw_mO!FN;(hEC*otTh8g)TKlfx!ybm<YkLrUyoG@EnJ!QWFS7YxFfC$c{K1 zyDf$SX+RW^iGf<&KFq#>U~djW0?;OY{_v`hk`VK4f^}OLkymYUwhk~!3RJw2{7C^y zpizY&L79Qmq#z+PHs}c~f>2cCxPcW3`beP=?PW-W@MkDU{f3=Q=1MT#4)u?H2HVg4 z^Y(2*w4IFk+V1w>uYes1-d}?M7YiC)-|~$v*kgnUai4C7`#1YMaKH%cmHns%59{?D zqB2(O#d+YqW8FgWZCc=d`?|oKU}$b114qt#uY5s9hV8#myUoo({p?a6@$`^-u@c7Y z*I|#CGxnqFi$)lL$;Wv|fWrD2Zp#=b&$316I#6zUH7%qK6F3NYu#LC(#4_j()gc6y z4#^@EvV^~fmA%^r(Lo5#gkpR%=#?+kA+6}72dN(rh!4T?%~+t1lxd)1%pTHd9ju*x z-~@6s8E=nH(Mb^8fn?wknFW2o3oi!S)^=;7t;`b2YbM{(K1febNAEa2P^*s;qutzq z?gz6iLAzz4CaLDQ`Th#l(b3TgS4Zo1-cP|$dGHhn8gOH?piMA%Xmp0HMN>6SeXEcI zE)KY;Fr*R_v*^t=tq?8A`Y6L@GzBPQ+sIAbW^IO#CFg@t#bv!lC;BXfLdMyKR+dFt z^F}AVsmxsq+we_3b(DG{<chR8GE1~%@EAyAtH`0R(MDNQ51ye}k(e^e@QQWbT@R&Y zhh>K&|092PGs{sC_fft0cBZzr_MeybIJ?V?RX9CGT{_K9w(?oVg@UsU?F@D@i#za1 zEuO=dxy;`BcU~{+&QCfcIwON?#nR7;f-J40eWN>rc%BUw!CGFHNWK<f<l=d~>WaMt zIEXM)HU|jRb!`p9gf;O$v7_w7w}$-Y66n-3-Li{|H!2%uR-=Bce>199Z;Xt9s0~(> zm|9vtF+kX9Wt$J{x3I)$H0?dBHzCJ$qJVk1)rSz$Qz7$COB~5F(%Ep!LS^6Ugmf68 zVSXZj34_PwnQbMvXJF*xXT!b1!l7+zxwMOHzS&oSo~2VJdrP!SMvE`CM-Uv43P}i@ z6}NE<g_xTYBuUtz8rEh^W0kHK%zd{%v#sBD9pbJ_dXTpl?&?`%3}vufP8gYPJyL+4 zHSYKZjutS@d=Y%yG1V%wODqdh+|mJ+K#vkRp<trZ#R5#~U@~W4YxHQmWL~kD(8%;@ zjXGE0`zcC~O`oVxrCwdK)m8#S(CF@Lf49Q4n*9)buYleD`q#V@h?P)+P0uM|`YqpX zb24Z%^g=GoMO^%+STJ<3LxyZRL)EJug)7PBZci=(Jrk+w@FOL^%63~7Y$x>2U8Dj! zYH-PmgDPoHLtw%D{CpsbKM30aW-)wmyjV6isRG~1oONe*>1PMjD8pzj3yZ@P4fMKq zZ?1Coa=84vu3M*WGUu>MjuCQz>HV@%J)9+Cy*BY<ZtYMPCN*Kvw{|Y3C$A#>SHq7# z-QM7?d9Am!-YfNIe|~;eIv&I^ApQO9dXce2kg6WXPS!7;g0!<T#*bI1xgr+?w4L8A z&3f8Uee+xG-0=G){~Ic;gsR3Pe5&uKnP1o(zW1X`tk3zh!-7`M<%*3wbi6h3p4Xpj zjh#Wt<CUYC9{=^z=z3kno6MEh!=OarI<Gd`#9s5=g`n&k$kLIwo7FnRb;0F2P3-}R zXr1J6C4^j?W^=7k%GA4u(mSDJ<}@ZE&e!%d+-0xwfp5RHAnW_R4!u_s9~t!K+eS`o zPPgvI`U8j`?<2PPn4vK)iY-PukQySOPT>^JPRDH~Y@BVL*>}p&>wd+ql*ap9{OQ9R zc4`u3Jv<$9A=krdyMgn+&8Cqv(_1}vzdEm)&9)J%${9D0*d2)?e@ps#cj7Ym1NPN0 zTcR4|7NVKV7+xIoP^)B6un;>RJswFy#|supU~G-VRTdhG8P{w&A!Hs?sLV#?E5$xO zHDwzWr0_<a@>qh9(hfP5*TR`#uFJiVpnyYp4{g#ftc}Hfq-(l5z4)|zhTHA4>|rnw zmpyElyAoo>zkiZFSgU<M{sZIsGCi(;&4jr+`|<w8)@xZ(;|Ieh&@)ctAm5ctG;f}* z|Ll0~y8x({sm?_lS$S!v$nMX2hHE>S(Hx*%0smFa;y8s@ULxdKJ-JWwd2aX>OMO}3 z8e@N+&jHu->zaCdQ}MnP?h5nuejg`(f;X8QEB8_P)5E=@Xk<U+Z&Yn<e`ZEMgL)T2 zzTdT2J##pxs}fTyj@Q)`U4P#UHVn2h+yg$***ndz5B0_?U&d>9`}wBoUa=m}AISR_ zmGL>3z6jXzmZ_;*9rsQcW(QNpA-|WfmcPaSZTlU{W%w-dY?wHb#v^0auDH0?x0!4h zLnqhsK~&o4SEktvX>B+CJBi_aJZ`D%nJqVcGJ?XJs%rs`0HJ^Hr{p?A3gUr_H$|W^ zUG}o4?8k31V!^rh@%R2|Daz#b*80Y*#)5`{N5!!{#}>*9tpEmk`b_**_w_`RWQcAk z=Z)FPfX5NMdQ;!23i2!djPT;CtNgEb&Z+xbug&L6b<BA7?(1jw?yKX+6phLBt?t*5 z^CiA?C{pYpj)}9I@8?ilB~Ej7xQD)P<elMp=YLwJ-z+Ad79m#-BD>nE#ff6KzRSix z=KAhG>v+x`_GdrYeB2~m@%KM(Bp9}R|LT~`#Gkdh@MZh!KHixxHQTrF^wFERF5TBM zyKLlgh3$HV=D|Yck*P8M$PwOd<m-1cI#7L(pQp2X$mw^~>RkJj!`m~AA$-GSnL2e* zz;=zZ6Wx26Zkp{$Nk~+EN38xpqM-3&{w9ds-5qA94$E){mFmDZ;AU1c-MG@>T+XJr zxSYs-dJu<n?Q`t+XJ?Qa*}<s0b<~20Hu%?!HVHOkJQY+dy&}s*hyg<SY!6A&;T@m+ z&+**{)Jz_d4qG255f)||1`>t}1ZELDte-Qe_g<ufxJl5oEK-!cc_8Pemu$_#!pk-q zE#g^|>Azm^c5LF6oO~%zq8))e(5i?KIHT7rFIXaB&<Q3qP*I9NV|X|vdMa9#8)jUb zrrrF8`Q#@RC#S)?yb+Q{sm)BC=>gWMG{fV!Yej*R<c1cb&w6*}ozIqgx5wgid*FEz z@?<fi(lx)!^<?(nkUxmFSbwzaNu4@d3JT1nM>p;_ui1dUZ641P$MoDiUO$i+a)s9q zDrRyH5Cq63IO%nXUPyiBf6Wf6rA_0Y>SA0sHg207=g(sC*TZ>t6mAdVUTR?}Rz5y< zr0wxm!W{brSZ)z5uet1OJ61zrsD*25b}0#-(5_cC_xo6?OP4FTLREX2eV@KuFv>V) zKQ$=551Lr5HF&$c7D(W)IFIP8PER+VdsGwNXy2Pv60I&iy_M8U+Ac1i(<`je{QLRx zbM@SquyM5RZeh*?L9RYVn}S$x;Yf?}*5Up1nR9cpYpv&e$8@d-%eIP|z)z*e%3kgb zww;mn;GUWwz}r-HZl%99!_9Rgspg4NXU`THFzVT3eMv~~{r0F;=ParR45xnIIDTt5 zz2?QH3ulZU7fK1Jaryof(-;-G;doW!)q5EHmRaXm5}qPhQy;+E=JF9|A?)jK=WuqX z3K_={uOz(pu{&e+*5NS+`CUfqM^!lW(-s~td*PPDWF0GH9^rTnjZnYWPG5*xd_^&{ zmaE)3UA{e8>a!HA*6+OR?@r~9eV%*D+$Um;+~q{Jel~Bv7KbndiLm1aF#2rON~-yI zD-7lwAh&GfudJ>x>fqmdhf=P@<9{Q><s5aIrTIBH$HTnMLaR66{4z5X>KNb|)rXG? z#H4{hsUS0^cgVzyap{*nAirQqQL?wU^vro!HfsYoZYRMNC2nTfEgR2|;?$5J@~e3_ z`}yqvDwj#TgXdGN#wksEV|I^EnwNAt`@pC?*-{XxLOOa9NSf$nt^}CQpc5P3=5h<a zH2jT#g%ve|#O&R_u-9`|(mf43y8`@$^M@aWjhy~dJJ%W2WV)?q2HT(xqenqUN(NL0 z5Yj6oSSTY-Kq&%44Iy+ANCF7~WCR5Pg|ULt6cH3DigbhkQd9($BGQ5yA%i4@A~gxz zh*KQnJ@>40*FE=-Su0uZ_k4Tr=Xv+HcD}v;yzvwveJRO?-B8ed*62>v;heL)a`^*& zZ_}#@9M>W)dY9-KPhW^HqO!*BUz!bQKUAo(N1&<45}RhP7Paz_2MmP$CtVKTZq^(b zFSd;&BAR2!1~oU3z9TK?;|d`W(;}?4cgHbqw<Hr)GrDto)(L(gxTnzcQR@EOow)rP zO4Z-dvh&_tVDuy_X*#CcQSg>=HJcwfZj73aZSxu)&A463@7>>$i96tu;Lx?J@;H9t zOkj}Kyl{MFdh9bU*b|aV9yQLmE)acnCdtn)<uPwq#mR0PZsw*um>8e4ZzzSg7Rfa% z8%+@}UNdfWu5bHwu=}g{JoU7bTbm=@BNfhuabAyX%%)gqDz0r9T+!as9$oNt0ZO^< zerAX@S?|(*MZAvR%klyyv(S35XjH|KL$CBpfoTeQC*>bdCk9p18{1ZnIvjqh<#HQ$ z82Lg$M=9atPg!x1zpe<nZjhO3c!igf5r3*<d|M*u{ME=`{VczAyZ-~EJqvJ5avloq z)QHSnh~*JneR)L>;87P(JL&Z=28VOzGuAFNzC5oixxdFOG^xZ;xDeKaXuC0dAV<5S zY}!*fR?~4K&t*&3sM(TW+v;88<@{I+yE5$3#5wM4{e;Lixb;>E3Z*;z@ZR?BwO{*s zx>TY48%FA}NHaBuRSBM)^sXD>`mLj$l!BqhJd{CMWoFMyMYb2KG(WhlG_JtKa}{66 zV`_#6JiaiM{Vlf8u42krb!g_nP_QtsM4xHeA(1d0l6tF4UyUe43_N>77M}yo#?VzO z{bmPLt_oNYN3{2khG!Vu#kwGv-*O(79_Pl=bceALzUbtaHeVh^x+G)-6uZ31H@;-q zSXpp8Cw()2vB}@Maw+QCT1k}dRDXv;5as4u?IT`{U#cZ`MqSfMvnG^^%CHigyMuV~ zG_F;DxHo*~B@ETo+9+Pd#wO(zL_u#vQgf@eD&V%x#lV}4sVifvmCB}Ys)1Eg0zpKB zGARSoqH|L4Tq|30>nOugE$=QW;^|BBn>6DZR*T0ht(pPc#o?xiorX?~oz<o`4(4h* z9v)lVxj>*z_dPIZ9A=bAzA>LhpSw*v&1)F8G@1S7lsB~0X{x4%)IoSqHvd2|XD+oN z=vvC**M<4o87bVwK7OnoTJTlK&3v1osO;e9PK&Pn1R<2sw^RA&02k&6TF=U&Xj}Nf zBjeF;+H#9BDi(z*vkKpZAqwz~J+?>VL#dWOd#F+EXD;k2{mxj?A#0o2QSPIET;BxR z=CW$jd9m(|WYaU9(QlW|t+$Ubu3bseIB6P9zZPer)H!tKmMGEX_9iGUPi38*{+7$Z zzhKK|Uh3rES?wvY??N`V1=blFERuhjJ;U+GkOozg=UNdhAjXC97@#k|&v{Mj;_Z3+ zsu)5j&w-42J`LkU_K99^kNIk(0etOVpAJG#@kqG7?{Bfa$M>iB_rSMBICO;E`yu5N zyA7{z&_D1h*knvM{W@`~HpMspABi@`WEE<#TFk{eh|vcdhR%|sbbemkFn#YDXasW} zwmpJW(V+Fhy|B>PvD#}WfE7?De`N_D<20lfQe{?U$P6!;+U;3bZq2@SwK(Y#qfc9z zRa&6u_U!o}Zcsdb48fkho{D+>EbCa{Sfb8X9R;oH6rO(zb6t9-Dr9QjOdildQc_hA z!ws2xXFBFO?K$78_*CX*x$KmTmvk&V!*LVD6LPfrV%|MfRV6|C&zL~dlCqk6AS7Fu zu&{7ED7m}DB8li?-Nt$G@{SL_346QyM9YzS<9lWW^exo(DvH9>8eK_fsV7cM>bzXr zfwP70OI<J?vZ=1s6WTTZpc-7$TjJxHVx<*M3C<6w6lnCnEY+P{TUUaG_Z~_rM)q}& zC0t@J)j20F@|w-7lr*>7=BGJ_Ql6YSMbYznSYDKq_uEt@G$@=RFR`td%Xfrh?u<9R zek&%V$TdrPmqzQVro>{^E-hcN$1Tsd^7!Ypkg(TT;fUKJi~JL7Iv<A=uufa7bFEsp z73aAp@z~`+9^!m)WjSgwu_7hd=)BHwS~)%2J@<C-v!lHsRk4${E(R%g^}PKZpG4Lb zQGDZfT-jE=VGEn!B)R-Uit~h*TqU?1s!>BBY>1d|%a!YQ3ER2ytlW)Pt0InHI;d*P zVMLAtCGD&E4!3;kJmAjf)@ejVPcW}PS`XKvsY6bmL~7Bh4f7vKz7EIQ7q5`FxE1&C zex_xS*M+A)D(|$1UEq7WHrG0=lH6?BHD|kKH?+bsPxn_Zdg`v~GkntaT0m6a<Qj`z zict!<qqChcS3=)(GC=aXEleZyjXcB&>te?J-t65qHF0e7l->@da+-O1muIPi7qYB} z^ngEK%}c-?ay6tS`fZ6B;2NKrQ5t&AsA6%7u*x<1tkxpU$*D5~g1v{&tv`J#1<f+E zc6(?q>TyX85ROi~zQeIHYDQMK*7V+s<Fdz1W)V8({u7UM1gxRbw+G#4#fNYfjwXev zH`Me6i5e<f52ekR2Xkt|P92xjSLWH;r=o|_Siuif0q2-K_if~Ot<{K`#5Y?lGBGY; z|2Pund0);ZW_>qu;h741ydjVq#x4p8Oc)TTI#^)1Huq>%lK~O6kE0YLbof4^s{)Q% zH>JF0zHF*shh&9ZJyRomfSo74H`{0&jNFT((0a3Woo96&4#xx6wwz~bvQ-<gPOl*R z+?%h`ozo|-#q<UhyV{IRJEys~_(Y#**X(4PRi49N$IiZP<X+gkHVn8_oXMY)e7|wA zYtLa93qIkZ=X^Yglwce0<Ti03hQ0JWy5#1Ch}x&ZMPvIH)kU70qj=JHqP3CWr%=n% z`fSR{De>MyZt~LN!{a(E`N`gBG1G0NeaBUklF-f2W?#XmS4MqKybHgL(_6-WIFK4P z8_L+rQ!1YhkH~(gsl#h(vZZAAm+0KpP#Bzx&LcLO7v{GfGV=&pA|3Jxs~@Xh6lhPT zOx!iazUVtV6IQ+O+vNA5+GdI~Y8Ss#)3`ns?nM{_^wlTx%T^wk;ah8)DsLQdR5sbM z*r4m-uO4qdx&>vf*gBuH*0zKFO&%L<>0GR^Qw?*%KiM&~Lm#+1ZXsQz`!p;qXh--P zrJ`~`Nww}NN4R9-D%7~uSHjTtOc0F~h>R_LiW<^W%yuR*wBPzp-mH3{hQnXWBoai4 zV|;h6%Z3f7e4sbCG@r@LDO45>xJ~bNX_@N3l36RTk>s(cDp*th`|;+gclBY<wL0hB zElot5T4<T}1!cp!URvGXxKXZGHcc?bUTh(We#Qj`7r$!mX|LhUntOD4U|*QeO}{FO z>3*D>Qd%^a^hOLv`8M~dIIs<wRbzt1*yj}~eM<Y2($*MWMuGU#f^NfdRp45y&Y;pT zF@WWEN6bwZiei@Nq}_d;4y(=bQiM)7l9#5ZySo;PlrqAb9F?a0^%s8-+US#uQ5fi} z>C1?quPex63a218@RD+Rk$(e6+OR8aZ>y?YmrSl383EJow|gTg6&95?7-3GNCw7eG zuB4w(t04SQkX+JVce9i@*;B*c!#S%HxAn*iW_u0C^g_Q|w9Xcv=)JTB!{F~ZZ_^NG zla=>YUX0FilBn!c1|i$*0@9uU6RHCCF&*c=o7-b#(yyvigL*2g9Z0ZpvdPK4W1w`z z_Q`K&zHX97a)u5xWi9@cSd1erRFx7%bE_*vYFj2>_jfhVvh5rypYRlccjlc$Iy`fW zcp)g0ThzPq_&(n1)ZZZ1&)ixmw#WqU8+Y$ff*d1WRxcdI8w(o~MJL5YXT4sy6^c&g zenIfgn!O<c3i28lR`N}DN+-2C%Gc>6t)ILz{t$I*-nA*yYPL~nzT&CFptAu(;y+O} zdZw6Y=s4gw3>aj%y-qc?plPt##f2}D7>2+>kFsOFr|H<>z8PV)Wwf=yRz~Pdqqjby zXY)XiedpB{Y2Tdq&C4Zf=={i3OD;K0pJLccs_o(Mt#SqIg_y*uzP>B0JR5e)KzbfN ze!u{&6mcuCaEY6``D}$#M22FlMD6s8Uh*f8C4+)LI2X)1B!C3OljsC@0-XS~3UZ^r z1MKiW{c$`P6oiC-cpjL6Av1tL^d->&ZX{1{GFDw!#a0J+yJOXD;dl@}U?0iL`$ra) zWW_SKCbE2qXm@o(oB<QV^bhct(g2wLeq<VkiB%^^)sQgK^*b1-4p=s!`(o9hdSG27 z2&|5iH=w$EU@VPHes_{yVb#6p^Z*PH$Y3z^7*IV5)e{ItqtQSR1PFoXN-cD0A!Is% zsY|A5{1L&3L?cqY1L)oqGT_}c!Hp6`$EvFXevcdQL0mFTZ&{cgk>U@O-T;F2pul&5 zq-)GUD#bmBNTTBK-b5;eM)9E67XWN2RCfRb1V$SG|7K$V{D}KsRO3$kQ%pb*)o*!= z?nEHTkK|7x(`iyc;AKJXL<~{-Naz$P)w?)Wq`>zJKX06+bO%&Az?}p*Od^p19(uld z1U&%W%KW`3sm1%nvJddXNdKm2>7)B}3YmlesbbKwVyO{k-+Ll!3dQfg%i_mofBBJ& zq+c8a1Oe-Uz`9V7H5h^cLoslq4hW0^fj)43Z@KJ=r?`82g#0U>A6Wh`@_@(x^Gx{r z|B(zl9%Doy2EBW%`;BlxLEi2d6dVDAfK2x3qL3zgbzvamJ-R3~1g(pPA>ezBpm6j) z5M){G-+h0Nwx3L+6Uao;zZ2~P-%o5F@E`bmCizVAndCFcXOhn(pGp4nB=2AQ(so<g z0Q}jn<NoURrSk(;ogwY!KRs1IKA0+uylDY`gb-<mV(m@$BLV2tAQBGufid*s5yZ}t z<N>tuW|06;DA3jc00zJS5GMf8l0u;a-VH34!2M(o3IGCozcz9(FxdwIAz&!D$zBxF zcn=KpuC@8Fv%&q(7E*$LaxgLk{`Z5BiLPHnE-h_6ngx)PJE0wOFsE)47Y=GvUU7xI z=Q_nTj<oX_YelwQVU!ladCkzeE4ZUtGfJ*;T%F`sW~;3FSGvaWRFhwYug{*-s5`fN zSMtVl#}78wo_m4-?YO(?r&xoPR$tD4>$Cb;<+>}Jqc<x2TzyFE<mA41eP!zxpG-NE zO7d7Q4+218(%(Nn00bNkg#$eP!oWzt`#a=6F)$b{gF!%084QL5$zUkBEQUrQKE}Wx zFiZvmBW1Km(<~DY3`4_ZFgQ#`GZ-POSxSNW7?U>sGFl)Iw2UtV0hi%`pdm8xpb)f7 zJSZF?6Ay}p$i#zzQL-2m1(w0!vU!0a(J~kuB+CJZ%H#?Hf}=m?kX8rc<9$f6PuL;B zALjrjoz-M8s5A*OnAGwwj7}wZ`;n;2h5x?XVgKhf{=SL{RQmgZfkBZF<a+rXJB%$% z{wgBS|Bp7{K`JR2uq<i$KhTQq4_Hpw$D(1<S?+hy{{>J>2M7dg4$#|@0076X002-+ z0|XQR2mlBGQ&HPm0000000000000006#yUrRAqB?L349ubaO9rVQp}1WiD}VX?1uD z009I50000400000Ra6ZC2cP|2XgH^IXnCe|XjOZ8VAa=k<^{6|3$w{Q1I99#%@>FO zApt^cZ4B6Ho9Q%R#=Q41?&dU}ByFdgJ=1j3BolX<Zt+Z<)^%r+rgTf2q~m5%r*$fj zgcgMM1?@<BPYYlP1c>$LH|P7l`yMWTNaDTU@BHpP_nhzh&bjyZ%fI-^mz<kb;hgK6 z<6P93IdtgIoXoBxC)Q?)kDU0?Ov#b>&t`TWjekC~^Kjy8_F4Sz@Yla)b{<K#*pEaC zKPD^i^E!TH_~-jY`1u}w^y5db8A_bZ6dz6e1FZciKKp_hO8#P|_;BLiXLdf5_)uo& zPrUSS#zx{I{+rM+>_I<?=l(bQEB+n)w-0yU_1*ZDhT+p&Vfp7XI}V>H$*h0wx%t7u zfM!$tOkz)_<Z$BGG4g-JT~j_)jNi>>IPu5!UGlgME4eb<*R`u0-@e01dCua3Jtz4m znUbT)k7c$TI<_!e*_<hTHc<*IU!+I;4UF=(8B6>VZhP5g_CjH}xPAc!`(NRJZhyBB zcU9x^PiD%F9$OY>-kouu``qlz?&lJ#G3IhiJpog%mMy{^|BSyI<Wqa%CH!^ASK`;b zb-~|9lZ{#=`TI!nttaiz<WFM`hs_-){4xxwp1!g<#ZO=u@8a&rN2fR8kMCxRpN;=i zX6MeA=GwI_bdTK{KN>uFBykEq+KPP-o^=tA`5spEcd(+#OzGkH_RN-J$L8TlXELQ9 zd2t1<`)%Ab?xPwlp84sw3LJ)Flb@9-J$if#ZvRhs+~4AoF`r&8N15w>7i0Z*nH|p^ zTW<H<&6GUz{0@x#8=HJ|Zj)V>{Hx54XOEZJm(`iwA3pxrBMjIDesUjdebt5@|462+ z?AQXk;znl2(d0Hxwb0u_+8;l(2ugg|zN^S=KOElxgTMB)yn=O2%*_5bYdWRz+DG4F z%=@SvziTkwAJ2Eu?KPO+uh32YULodGX%-G0f7EWiWY2nj)rtZiU6^GCkMDCfB7|#c zHqI@?qcg=@6aa?~y_jcrrL|-hLBD}3rhU{m$No6}w2Q80c76DT0<6Gi@zto0YVrGu z9EVhLQ6FR1*5>#@eEc(u8IT9f<?$DlCPhb1<TDcQU>u1a9}Vuu(!P=T(2vEJy68$~ z`?Jrl!B?;2#|<Ab79;$48$tH0;+MhPslaBMBmeh%#{2DsJ65<GTt=?5k46|33>;^9 zU;OOxBDn4^_j^R%;Y5d=aO~Kzhg{UU4fFr~?f#rF22(h|2VS#l<Hwj5J{nyJhir7_ zGprZmBt&?J(uXOb0B;H~ggcvrF{MY6d)?&TMLwEXu9(NfTr`xORO0tw=9agVWdZ<# zR=en2Y^QHszQ$d_r$@GWbD3RsW|s?av{?WY5f|H-QZA~C;h}%w89?tdE!@OPE}aGE z<SMQf)^F#L6T69A-UcF+G3a#6r{o*H>uERk5WcVT(KH6|H<|K}{>&pTx&TC3goXZ} z1%zq&{Jx>?GshOYsESYU7nUD%X*gzo$Wz9Bm#tM|GuD$}4Al40m@=3s!PP!PKd%xl z4+|wngl`Jw8Igoh%JVL26Wjw;eRNqdzwJj~c-&d?VcZ_@miUqziXjdEz+1Z8!@nGJ zma2*m3kx3+oUf9m+<oR_f$!a*BpYPbFh4y<JDNk1Z<gSRzlje&4N!kU$WnSV{!B$F zqo@Mc{>OEJ`;H{u6qq86^L>PX_<PR4MdyWGX5~{MAg&4%m@#*WJRYkZ|5Z0YcQYWk z3d3_2;`eJJ77YJ@Yt3vw^x~3(NSmMI+;d!X&ELkaT4I|;+KRP4BIypTcDKcKAY(o( z(d_yasTSGwez2%G#Jhn-zUyNyWyve~YdL0|_BZis!0@duv*RQ2C)fLkpWMe%eQvdz zAuIU-1u9pp7pM_i@B8PH2+LQy)M}wgcJwLFVTR0RwA3)cLX?Rxx4E125<N4>Rd79A z%DIY$v1OzccUc%y@@(>uXc;)?uMrLmcL6eqlgkw{i5?Q3;f+1w|M)>p!*%D@p}}_- zi0^D^pIhy&5)t@SjpssM3-DY?72>04ajCnGnf^bshRARi1e*vhe}S-Q>zVjpBoQ}L z&R{9<liP!#3I@zhvvj(E$l|8U{NN+5i%Yo0cag_m-G<nC4j~BmWeR1Z-FVO4k5Rms zl`8r<-*L3(HO2qyx>k7PYvQIz88Ky#-bKVM^j9Pv=$gB$<(nuvJAb8{!cFa%nk|Xz zB-i+k;uWND0L6|Y@dHRW!f%G?HY7^Cy_I}xhHAGcIVL4`=%*jLj?w}koYA1AO-+7K z9!C?GJpdrlY0io<JIzA<S|JywJSYoQuAP`J1Z^uLvlt@OGXNLK$~#*vj073RO-y(~ z5eJ&~gO9nkl8wGiY615__1Ylf>paEO>yDWBC4Z-YW21Cvs0cZ0s%noQ5tu*EM`tC< z$j_HWARKFxYn$&|nNkE8m(@_vNqExH#4osMdG~sbLVJUn0EttTGL4w-bqZOm*izA9 zP@NwT#l~&3CAu!n!7vOW4Nk!B8cH1l3gAn~LOd7vamJ0ERZtv@wuT{SaJS$VWClWT zOK?wcNpOM=8r<F8VQ`lr4DL>FmjMPRxLc3_30(HQ_f+kD?|C@Y)$5_F`m65s)Lr$h z_0PKo$9ae=m_v-Tx|tL))X?Y={j<lHw4KVN+|1Ig*Vhi2cdZ^fpeQdDfF7&-qza+o zw!&OZaTwFTuJ93W7!j?gzl->`SwfT7x<`UAjKg&$#fnlhX_*gHC7~V_0#zQ=dmCcI zp-vCK1yY6pfX=&4SZ@xZF`=LQdDg(XFsbN)h5uRC_5eEYk^Z1pmALcpj-9EV(ft~g z58F|M8_Ls32_w(jQX3K_5=O36tmx<Z)YNfSwFeH_djCU)T-0-yctJ|W@RU{lu$(|2 z))jEYK+&d1yzwiz>LH@P`eA*if^`SY(m;;~IMJ|3x~wM%!b+daaE*DPb`OmZq=?KE zhZ6Co=RBv;#!Oys?O?UqhWd&5a`ZbQ+DEoX-4@M1M2(I&0xw^W0j4bD4ob*+X2uqk z9>cy@ZF@=&T88@}(UH76O$}N6sSIF0*XHk6lI%u%Gzk#ya?7^wYbceVjd5^!zb*T7 zBS@d4L(N7u$QEr?G&ML5aS&K&G)y**i*G>{Y<&sjM(^Vyk{d*aHIqjsxtJ=b#1B*n zCu3<b%vfPc3nh8zY|?!Fj_k$#0WK_CF#2<^1*DrD!34PY?(5uw{o=B%yYz|-8vPX$ zlQD6Gu^c*vt%{p2FTp>>_lQ&%u3(F+@phAccXsD!6_2ibu#{0lV?$#vOkw1Z<Y~=@ z8*S;0Q(wC$$i?rmh5+rFDZu7@$n(DH!~_P)p}5e(%XJxJ_0*Dbp3%>;ziBqPuJHc8 zo2R%o`f|w29Jh{_m86>1cNw?Jj2Y}}Tuq!1MUd3*ivMdGP^(iOWbHe~pPU)|`gKRI znOtKT*8biM=hgQjc8+iIHQqCAGe>W;?X{+d&LxYXb}8?*!)yMaX(&c}3yD<r7Up_y zhvnitf7Dbm+l-|}G&8U7H_%0#erEGtKMxL?=R;sfwj%ay$^i6A$US0lwP>M>es;s- zlYWu5u+f7W=8By+G-oGn{Dso0q0c1&SeleLbV6)~1r*u%wj$M_YZ_`3@)%Dj=ZobU z&7+5Xv@BuBIo@3x6W7H$ovk(}(fAxANlcC`z79o@*xGgRrH|r&9`1df_Y@h}1_i&{ zd(kpp%}lwqy_L%oB<JY&b%7$8nvu)=zRzZ%sT)_-vaQZ~gi9zB649s&TYlH@iQ&*> zCJl3AP@;deFo!6>HV|fdijbNqoqQ8ZRbqH~?LpZYbviZ=%Hr|LbA7KvZG!7uuEtD& z;==aLGo8oRGD^4&KS((1R|Yo~xsYmvu<vu$t4lBeUX*}NU~lXXL2<N}91k74@P)(I z+kb?Exk*<Glk4d6E#I>Dhb2Ar<EjlHIt~wu@kgV>pO>U$t`zLcHG@nzR!N@JNmpOv za5hLuzZ%<CP4$;4p33BJ-rq!nEx9Kg<)G+lVKhS!E~fx4fksBPQS=9;M5<#A<vf%_ zWp(|IP67+4&1}yb2vu$jjmG<!<b8WJD-&_ojCDgOd*sNBi88)E7_vv}YP7LPKkoh> z_k+z;v3k5afl%LGOPlZT6bI8Rb`CU*E$~c+%_DH%P5yyPQuLiU(Iq}DY7WeULeI>W zgG$|q;cBg^m7QI*!F`r_vb=Q!U@n)S)}a!LK6Yqg&+*Z8Z@KB5DR)4L!}!=ND~aJS zzaGy7AKw1Nn*kT#wItgSyL^5$Fq6I#VGq6GtisgNQ;BKCd8(8!ajq}~@?Dr|AuPus zrQozRzWCdAp@OITRNS_>qCd~QwBIz7%qZLRmNw<+U6&CL8C~ut26;_cEHO;m2GqGP z8aU3QKb0~R0j^mf*Evu<KhxonilT*FymP1zv0+yXP|y^gfPl`~ptjyGEDCzOXd`JN zSIhlVU+|&AwF$UM1FnFPy{(LizhO9{v^p2=tg=Dc54{kK9Q#GOaDhi<JKTfOHovg< z^W%9S%_sYBxEgDAPU1u@mTD<)+Fl-raOpe{#L_-uy9s5g3?RCMco|uhj{Dm<#U75| ze)=s!=r<w<k&E?NoWWZxLwQoH%a2beivD(~S)iN6g^2~51g6+`p_z=#Um($zFbrdq zLJROV&c-P5=Ep+JAjD<S;mwof8;1<U&FC|LNAg?_6|c-i*PN&?#G6*VnN_j_3#pbh zRp`!#WwHWgeREUZ?Tt1e%Jzvde8BTt<L~FM6is)CWRVaL)rH5A)3un_kW-%BtXXUQ z<xa7%tVlB@lCgp%?_HL+BVup>-qF2WYqglDX;hz>z34{Rd@F{l=p4px2-xV#*U(9D z=a6UKAi}8l5nH~`x!f9i<u{peMc^AT#o?wvreLhJ-sYTa^-F2apviL1%Ub0#=SobT zVrFesWCb2^dCYDPOj4~0UW}l3<KuRyVaK=SVR}cDo5^z^V)|RBDCeeO#F@?uy%={W z=f)WpyJ{|*3h}HObniADWjp(~sx-TtzK(c+8bjO+O;UcYpk#RPdEH@O!?qQGRFFjd zsh($uq{G20uIwrLTRYOOjOxLxa?5V|HoUBY1s3DhEBOY;6pl`u1yH(Miw|nL4X{Qp zU<<L_iL8L{yvo6XzR4zmu>iGZeJ)GHkseI!Baf>f+twyeVkIS1N4LJ~Vj?30!~8XT zM!O)Zt<JmwtCJ$_EjSieUufD)_*XNe{u<^G40@&*-4F7{GK@6#Xiaipp7L;Vjwv~F zZ^@xs7AX$}wzkhNmvwhx9R&q1c=>=ecXf7)lU~n?=cz(vS?q!jHEO&?N1Nq_<z}uo zC{8qcZaAE_wL6#JRxrJb>k3fWXn^m^_ANO=&~Y+Nf|o7`G&ryxGM$G_cKX4TkxWKG zp)AKj6eFVlhJC4{$jn>#w1P}|scK8;8d8~>_}Sv@l&XKeNg(9=aPH4?M=t`1r5C}G zUP?emd@#cLl%AM4GlB~Fa#HEn`PRb_EIvX?a{?e12Nb&{A*2v&_F7$R-I8Uxn2Ofr zltRF*CvUhknKnT3WJblXRA0>evq_6;!&o>7Odq{aHYQD_1lRj=g)?G@tbVJO`}uWJ zVW%7USVWrGFl(cb{+4fE`<&{>?m3++qc&y`!z)&?7A`OAj;mSLm|JKC$8AS}Cx&V$ z35qoXKiv@R>qa30bgPbti+}-5Elpo(_LW9($=2EZ73wUlj?6kgd%CS!@#W|nOkbXq z;t9)HLPV@&%$1TWDw7xKiZ?wT`$(Dt@sY`Ew{TNc*WVo4qik9DngXB*9yD~z?MNz> z*}6fO{?trCC}b>PVw^Hvnfk8vGtnTvdYR>U(R=kOi#HC^lCDwHFPaq7VbXo)g=}8z z+M`!)JZgkifQm;M2A>|Kx*21cU#Z@(c92)z!SD`wSa)!)ObA~+3#jWhVCSLHItv)< zHxYsH8F_Q55sI1VxBtT7;@)ch6673FiRbYBmMZT#q7>(nM!yi<Mrx`G)X1w;ntD#} zde-AoS&bf+Db0K#x~^+S@>BEYAB3ZrO>3!MEulPHuBPX>vgFsiP^W95Og0zWx##K? zHN9FKEf9NT*utT88C?c;i~lhi0RE*x+A6dV)*javdVWOI70X&xfio3DGC94<R2x&& zXF#_j{kvc6zNnZl0QF)BS+Mr-<$9Bb!b8&-bAF@3WnEkfWHGx~?)@HxlkhS)A%x@D zP_@BlX-xFsfu?kxZ-+Ny55k1=fV_ZgMQFoXDX6{8`@S|pD={}EMOWk91RKo>*d(*W zu%LX)cnn@355H)<ns2JS8Yi7Bf(_ae$w!w_Lugs=Vz22Y*mEwClv`q@^A`rWn4kJ? z$9aYI*j>6ii!VAjn0=YTIgKU4JnVwboy3r*CPEaQyoVLImhC~__=~S7BObE^F8v7K z5cqxL@}1AlITFT5es?=PCQ}1o^;RQ(aMQnjv0eq|Rov~0vraes8dFTMNm`WJMW-Ss zI>OtPY3oU`f#rzV)35_N)0$f|tou=LALIk$nm*al*oxqsLDAxkL03@bJlCJuaiftz zTYzJraNi3O3Xh@JiOIe#VozNEPTR8|14)+ATBb#0ehg&nrkX(PAoF*!hEnfe5nAVY zNvN~dj%=wyICBzd3mqM_NWWehYNEiHwp*b~k2iYck1TUlbNFeD20EXwm*hT$iW5;l z^GbvgMF9KxWCC>`$}|fDy=0hHr@lj(+OqANUFGFmU1QHmJA+@mQD2F%C(4OK_n$1| zU-(o1$wZLMQyU0)4U_CjIGcc&o~9Kfx3{u3e`L=h8;BYChM%Hu(Wro@7yqJr*XeR} zabBPMyUZ&Y?D+nTfPksd0w_(wLA`ZGKgPON^Q9_zTUW-bl*U9!wm%s<c+m5-y|#=L zP;&dI#1@!v&3YDG>|P*l{1X>-SgHFIsou2zKAvrI02}fVx?hCX+YqXs;nCTpGV&sY zC=z)-qtvuX6L#*S-Exg&$~z+e${9x<$BZ8WT=?ykSlr+UX7Y3PsiN`e<prC6+J|UJ zcPm_CyEz3xqHg=w_rRZg)l~G@`%GS$v(=+QYrdLBOwuPaP);T023X12GH*Aa=?`Z@ z)PH4Vy7xW*t(6hxY~H%i%Qqq!?h;NJQhFKX$!CNsmv6mB?)$uM04<+5|NO4U5}B0e znB^)-QGfMb0^83WNqGD)0$iz@Jq%hKkFQ0BmcY&{L&&LIB^Xx|kGHzfrU~ER0It*( zE<BkwXw_o|rdKHl8P%<ntolx%_jy_$f1;z6(-OOr4Qd%hRH(Zx8>%P5Fr(1;?Zrru zW^cZX>N^R_zB-dp2ol!;yutg(mHFlLonXJAH&#@bs3->M>E_DRfC8MVnZ-GJtx)W8 zi!CSPmaw2wN@Vof;M*f%(mo-burlU7r^4#ow(E<`KlSi?J)A+i`<~jVy;gdRSK6xc zL`hfV(irI#Upj@D^C$I>%0LmvUD)2;3EX*EH)@7ovEkp5B=S`I2{E^$4Sot$OVqnB zQg-{K9n%F`O&%VjHr@E@?U1;+S8leHp(<)32&w%3aB|FBX5o#m<Zi;h<T6xOdJ?e$ zvC*O%Y0-1KM%%&4`yp-%A<GY`(Sm#~2=5{v<sU^L!3XRuImgFH*Ap`f$ka_7CePa& zZxI%RsRi@5$KDXejlv~<=_dP`T(I>Yr|I#ys!*6_T>-yYk|0jm1iy_sVJlg;KBW@^ z#Cg@EZopb|FC{&8EDIdBEG5X`63lNHHN6^zr2xVZWmb$~SANZOJ_6)hYok9*HfTSM zSTKrTQfnac>S(3QpE$ax)BUnkxepe+j-~PKQ?Yb!sJ=>Ef&<w!C0E00bczPOd8%dI zvWqx)V(_ssjW|!ZV@;>QII=iijK<E+M*|oO?Mkd7dbHsY9JPmp`_IAC%hPHYW^zS! zfS=xd(Ei-z1*ye^TG}&I$CHcXvNN9(VFbj_#C-?2$6G2YT`#SV)thFxLVA;M4HjhK zYxK3kTT6W{2M$8eG_zS>nroX_@fID&d)P{RJZQ>jfpSwKY_3@vUH=2sZwoA5&jFZL zn?%x>$2&1Z646I;KeGdhQi_y&G}}~&!#l-N`q=m5p=l!F(%8#8@Sq?LlR2l1d(#W@ zSkpgY&DTCAbkabkxVY9^Owpw#^IE3j;t%P{q+W??$|3~kO;DdI<@Z+G-JnbtR*DxD zFp3`oLdh7P9*lo4rrKi)=x+;=Mh3L?Zn{=`^kThrEG_}1T~2!l@fV+<<fu;M9Q^4m z7`*(s-6K~42Uj$x*S@c&h25^GbeK2d!=RGaX7|SYbd1uX^&i9P6Fl$U)sHS~&N<gG zr*(GK((sBZXMJr>VzU&2S<6=pDXAB{zjqh-5bekr37-`Pi=Ii<kbY!zs2XJRI(N+p z_fq*ajPbN%<M&mkC{*gpNpiL*4Hx~*OJM`T;7M!&Ro4EmnzB4X!wM98gR6Om8Zzj_ zT0{+yp@U(nr&lxY%n5NCY}Gg~K;T$X7XnSPL@m&b#SudGCna!AquJqa6MWD9r?eO9 z5=Vut4MwSbEzDvkYGAOhig|5KvttxEh<~%|@ZLlLUn$4q&K17-&2;gmwmRVk$`aR# z{7t0lGVutwNE&VIL<C=~s%H){$R$N+l33+3dAfFVGbT-=yJJ12*EN21A!qTMJNEoe z-}Z=~#o(-eq$%k`k`J37XE07@tFS1SYGBN!|Msnsz&O`1b<~>^zB&_J9O432Jak$j zF;T=eTfCKInvA{DOBUq@Y-U8@hc^rnJvyga+38x@@WOYz?TGo=XQ9cXEuzZQQBf?8 zyKNN#G+$xJ;^XXg2Sx_U<x`uO#_zq$$;YXOP-^0AR&ei30zbV}LTw#uFTUrvYRYx& z00EpFx(Z)*QKqupr565KaL(|KTohW5IRt!g<&Sw_C%>`dte~1_Z|GUgdoSi{YEkk7 zoDqWTa1f+`&<c{X@DDFkf`}(Xee?`-QcUQ23Ri!M3@|p?2`usouS~K7xNV$<cIorU z+L{bari9Cd%L2{;1ycEOaJnah&ZA7A_NEOZE2H~m*qvRL>E@YzDf+NN)h`R`)K}r; zd%=N$7?{>Mls^tm8bxR{*?{o7!}SU@pH&yG;?RWJXh|0XaK$>#t(13WQ3$%&Rq2wK z6RTe~+foIgc6?T%-bzDtHPyzuEakl|ofpZ~=3f#Y-y-e2e8_7e3e$^aoG{mA(qGb_ zb=W-HoyZU2=2<w-JY^bL6$k2h#vbXhYA}Txw`J(@k+1b{q!&Q33A$l!mAyS@Z67t0 zUBBeV-$2A>Yb#Xh@*szo2O-cpo(KPh)dmMV)a(v9z>UY?ha}(e?dYTMlN)ao<nVrt z+}-BUH!Yj#P@HSW${(UQ#T%i-xKcwgEBSY^-^zuEqZrzX(I~{N{Kr{99O#?`@GfvX zWnhK_Pj0cJ!V<fvHr7u*I~d1;EnA1nP0w8e+te(^Mm<JhESZuhl(>cPbNl6eix~lb zA#QiTElz7}zX5>QFKut+>J;68C;V`}9EWV2)T~s0kWIu}UPVk${vCB~V@dSe?!>5u zq5ZdxRmJW^yvd=3N~KN-Zx0!$ta7sKhmqdSe1ZNzemOK6+JOMOU=+xAteEIjvYFB3 zhJJ~|ZFAH9aHeUmHcTU3%5TjrE~=^Tv+mL>SNT?MFvZ$2aXZ<kpHVNa5DLN*&up7; zd?+#J;$;J6IJELyNXNyt$ty&hvNQQQ*Bk*pWo1t%`}2Z^4r;9^QA?qWdrEd{I@izg zqGVhF#7tNprUTi~uG)p(XjGk^9{`~h!O$D`BXnc+kt97SHcFjHs6BC)zOGdK$KTX% zaKlZh7hlEdHiq1;iCIi*{$OgOnk7GZo|ftCUIA0JJIb21?BL0##p8E0<*HT&B`he; zv3CL8oVnlc!cSnX_H3~7o24(_c<(w77y@<bV#CHowq;WT&1j!&hIZ=aH)wU>nsQp9 zq}+D$CiwUE_!YHnXd;&9s4I0JvkF)LG?EoJC=9YRG!pp?Z8UIcn%cVCBm8P7{n~hU zK>K!y#l{Up=gyxHvAMI8-bM<MOp!yf4wevT_~<fXU<xyU_&l&&{X+PVzyJA<|5<pF z{i}0C;+H6kVi1h{1rEMchSvU7k^M@iNejpFq2}SMGm=!SosVKS>ij=7af!`po9DNt zYEdq?;9dw1r1xtdgzg1<`34Z|l084!yG`3$c*7(r&dTC!J*3T+8KeW3`in<3ie)^R zPE!p4YF_R7va!?lCA!|QYK_;CngJKpgZAey!5nlXxDheHS^4?+Ara9#wv&+0m}dqA zZ6G87m~1RN1Q&>o`6qUD$vrE)W>qVlmj$0<iQ%Nhb}jdh|J!oFJUf#}AM`^giEX*W z;Mec{JoJjC>_2##@tW;&*$7YiosUO4rsgNK_p4z-^CJuULM&;@Y8TJj-5NhU7HR5= zYk)6#uQG`}W%NNTrbn&59VY~pYHhsQwuL#^d%0WS<BEh^AN`upn2UiGUW{1nJc6TL z(O!wPaSZm4^HD!uPq)f<GC35=)WO8Mhk@R*$n&^FDD5fVe%x69Mr*zuHSx7e9A_DB zQD>qqAH{5==~x`!By8hHX~*`qNXmTm*1t*!@tlDQd@t}$B0{}QM-({WP1`7j>94i5 zG#12<>FEewydlEm%Kk9-sLwO*7|A=b2^jrxt3B0+XkiO`<T>m^x>RuAk*mUwn?>RF z7Ju`#iNy`0DrvFC0F-LamajE;N>jZ=&)1r?9O?-abJgeQSKcv>0M;M(mXpnWmcD4j zYZdU$PgQgWPr^$*bJw&PT`I)685(zm+cg(&_wfQnx?)<ikV$%%r;%x8&JGgCqd75U z*Sz@NFEdPG7T#V7Ej)m6+sQsx#zbT)n67Cx862RJELA<4JIUDl7npuaa&E5C(B|J~ zd^@R48+lW~2n!8qrC31+ZB$e-_zIn=uEOgjIK60RFEm#lr~YguR_&fvH$UgOB)mu| zwLdz&A)x*;)=_p5o2<Bg8qX!i$#O>^^C_&aXHMb=CeYbwWAxz9V0n=uif7C*rQ0x` zE0?@QetiI%=Vk7tIvxDnUXEj9v}I9dCL+XQ$TjLan3R!Enz>a}0bp`kP4GU=^ekbp zu4;XAJ%m`u%jIsmdb!6>)VPgOH%KJo_xSPXw$ELZgCpTIxWnDSV=V4i>q#pYi;#rx zS3Wjk=v`d@{ou{rBNg4`oxPrL;BlkV%QnSD*F}m>T>HV{_dj?KA37@?I7j`DtD%qv zEc>z4F#$tr42IyYSf0yurTxNmvK1DS33@C=A%!4T!$yynH8u+}BNd|U9`J+pZ%?>? zi5{$jsga>{2nd#9e~BK5FNlzc{#)<}bUFQp>Vb(s_TSh4Do^5n)xU`!|4;WoK|thv zRz3a&{Fgft{>x&)@cCBH=acAfz{UXie*(>|Y|OYgoLnvb9r-Vj<o}XU*i`~LUn3&4 z^`Rn={)3Ex_>V{ZUq{8_i@mAYe+vJ*3`6`6IFJ?b?|t}RxPz(re~SKl`~QiyZvS`a df9KXbH~W8Df`a<oMFf=Rqw}wqUVAPG{{=xkIXeIV literal 0 HcmV?d00001 diff --git a/src/modules/peek/Peek.UITests.Next/TestAssets/8.png b/src/modules/peek/Peek.UITests.Next/TestAssets/8.png new file mode 100644 index 0000000000000000000000000000000000000000..b6b87e89c4f227c66693e93f7c0f85faf21a4ea3 GIT binary patch literal 10166 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 literal 0 HcmV?d00001 diff --git a/src/modules/peek/Peek.UITests.Next/app.manifest b/src/modules/peek/Peek.UITests.Next/app.manifest new file mode 100644 index 0000000000..3631bbfad0 --- /dev/null +++ b/src/modules/peek/Peek.UITests.Next/app.manifest @@ -0,0 +1,16 @@ +<?xml version="1.0" encoding="utf-8"?> +<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1"> + <assemblyIdentity version="1.0.0.0" name="Peek.UITests.Next.app"/> + + <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1"> + <application> + <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" /> + </application> + </compatibility> + + <application xmlns="urn:schemas-microsoft-com:asm.v3"> + <windowsSettings> + <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2</dpiAwareness> + </windowsSettings> + </application> +</assembly> \ No newline at end of file diff --git a/src/modules/previewpane/PreviewPane.UITests/FileExplorerAddonsTests.cs b/src/modules/previewpane/PreviewPane.UITests/FileExplorerAddonsTests.cs new file mode 100644 index 0000000000..e5a024aaa7 --- /dev/null +++ b/src/modules/previewpane/PreviewPane.UITests/FileExplorerAddonsTests.cs @@ -0,0 +1,1193 @@ +// Copyright (c) Microsoft Corporation +// The Microsoft Corporation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Diagnostics; +using System.Drawing; +using System.Runtime.InteropServices; +using System.Text.Json.Nodes; +using Microsoft.PowerToys.UITest.Next; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Microsoft.Win32; + +namespace Microsoft.PowerToys.PreviewPane.UITests; + +[TestClass] +[DoNotParallelize] +public class FileExplorerAddonsTests : UITestBase +{ + private const string PreviewHandlerShellExtension = "{8895b1c6-b41f-4c1c-a562-0d564250836f}"; + private const string ThumbnailHandlerShellExtension = "{e357fccd-a995-4576-b01f-234630154e96}"; + private const string ThumbnailIsolationRegistryPath = @"Software\Classes\CLSID\{E357FCCD-A995-4576-B01F-234630154E96}"; + private const string DisableProcessIsolationValueName = "DisableProcessIsolation"; + private const string EmptyPreviewPaneText = "Select a file to preview."; + + private const string MarkdownPreviewHandler = "{60789D87-9C3C-44AF-B18C-3DE2C2820ED3}"; + private const string SvgPreviewHandler = "{FCDD4EED-41AA-492F-8A84-31A1546226E0}"; + private const string PdfPreviewHandler = "{A5A41CC7-02CB-41D4-8C9B-9087040D6098}"; + private const string GcodePreviewHandler = "{A0257634-8812-4CE8-AF11-FA69ACAEAFAE}"; + private const string MonacoPreviewHandler = "{D8034CFA-F34B-41FE-AD45-62FCBB52A6DA}"; + + private const string SvgThumbnailProvider = "{10144713-1526-46C9-88DA-1FB52807A9FF}"; + private const string PdfThumbnailProvider = "{D8BB9942-93BD-412D-87E4-33FAB214DC1A}"; + private const string GcodeThumbnailProvider = "{F2847CBE-CD03-4C83-A359-1A8052C1B9D5}"; + private const string StlThumbnailProvider = "{77257004-6F25-4521-B602-50ECC6EC62A6}"; + + private const int ExplorerTimeoutMS = 30_000; + private const int ExplorerOpenAttempts = 3; + private const int PreviewPaneDetectionTimeoutMS = 2_000; + private const int PreviewPaneOpenTimeoutMS = 10_000; + private const int PreviewTimeoutMS = 60_000; + private const int VisualStableTimeoutMS = 15_000; + private const int ExtraLargeIconSize = 256; + private const int LargeIconSize = 96; + private const int MediumIconSize = 48; + private const double PreviewRegionDifferenceThreshold = 0.75; + private static readonly TimeSpan FailureRecordingTail = TimeSpan.FromSeconds(2); + + private static readonly string[] FileExplorerModule = { "File Explorer" }; + private static readonly (string Extension, string Clsid)[] ThumbnailProviders = + { + (".svg", SvgThumbnailProvider), + (".pdf", PdfThumbnailProvider), + (".gcode", GcodeThumbnailProvider), + (".stl", StlThumbnailProvider), + }; + + private static readonly object ExplorerPreparationLock = new(); + private static readonly IDisposable FileExplorerSettings; + private static List<SandboxThumbnailRegistration>? sandboxThumbnailRegistrations; + private static bool explorerPrepared; + + private readonly List<string> temporaryFolders = new(); + private long explorerWindowHandle; + + public FileExplorerAddonsTests() + : base(PowerToysModule.PowerToysSettings, enableModules: FileExplorerModule) + { + } + + protected override bool ReuseScopeAcrossTests => true; + + static FileExplorerAddonsTests() + { + FileExplorerSettings = SettingsConfigHelper.PreserveModuleSettings("File Explorer"); + try + { + SettingsConfigHelper.UpdateModuleSettings( + "File Explorer", + """ + { + "name": "File Explorer", + "version": "1.0", + "properties": {} + } + """, + settings => + { + var properties = settings["properties"] as JsonObject ?? new JsonObject(); + foreach (var settingName in new[] + { + "md-previewer-toggle-setting", + "svg-previewer-toggle-setting", + "pdf-previewer-toggle-setting", + "gcode-previewer-toggle-setting", + "monaco-previewer-toggle-setting", + "svg-thumbnail-toggle-setting", + "pdf-thumbnail-toggle-setting", + "gcode-thumbnail-toggle-setting", + "stl-thumbnail-toggle-setting", + }) + { + properties[settingName] = new JsonObject { ["value"] = true }; + } + + settings["properties"] = properties; + }); + } + catch + { + FileExplorerSettings.Dispose(); + throw; + } + } + + [ClassInitialize] + public static void InitializeClass(TestContext testContext) + { + _ = testContext; + using var process = Process.GetCurrentProcess(); + process.ProcessorAffinity = new IntPtr(1); + Assert.AreEqual(new IntPtr(1), process.ProcessorAffinity, "PreviewPane.UITests must run on logical processor 0."); + } + + [ClassCleanup] + public static void CleanupClass() + { + try + { + if (sandboxThumbnailRegistrations is null) + { + return; + } + + for (var index = sandboxThumbnailRegistrations.Count - 1; index >= 0; index--) + { + sandboxThumbnailRegistrations[index].Dispose(); + } + + sandboxThumbnailRegistrations = null; + } + finally + { + FileExplorerSettings.Dispose(); + } + } + + [TestInitialize] + public void PrepareTest() + { + CloseExplorerFileWindows(); + } + + [TestCleanup] + public async Task CleanupTest() + { + await CaptureFailureArtifactsBeforeCleanupAsync(FailureRecordingTail); + + CloseExplorerFileWindows(); + explorerWindowHandle = 0; + + foreach (var folder in temporaryFolders) + { + DeleteDirectoryWithRetry(folder); + } + + temporaryFolders.Clear(); + } + + [TestMethod("FileExplorerAddons.Preview.Markdown")] + [TestCategory("File Explorer Add-ons")] + [TestCategory("Preview Pane")] + public void MarkdownPreviewShowsReadmeContent() + { + TestPreview( + ".md", + MarkdownPreviewHandler, + "README.md", + "markdown", + "MarkdownPreviewHandler", + "MDPrevHandler"); + } + + [TestMethod("FileExplorerAddons.Preview.SVG")] + [TestCategory("File Explorer Add-ons")] + [TestCategory("Preview Pane")] + public void SvgPreviewShowsImageContent() + { + TestPreview(".svg", SvgPreviewHandler, "sample.svg", "svg", "SvgPreviewHandler", "SvgPrevHandler"); + } + + [TestMethod("FileExplorerAddons.Preview.PDF")] + [TestCategory("File Explorer Add-ons")] + [TestCategory("Preview Pane")] + public void PdfPreviewShowsDocumentContent() + { + TestPreview(".pdf", PdfPreviewHandler, "sample.pdf", "pdf", "PdfPreviewHandler", "PdfPrevHandler"); + } + + [TestMethod("FileExplorerAddons.Preview.Gcode")] + [TestCategory("File Explorer Add-ons")] + [TestCategory("Preview Pane")] + public void GcodePreviewShowsToolpathContent() + { + TestPreview( + ".gcode", + GcodePreviewHandler, + "sample.gcode", + "gcode", + "GcodePreviewHandler", + "GcodePreviewHandler"); + } + + [TestMethod("FileExplorerAddons.Preview.SourceCode")] + [TestCategory("File Explorer Add-ons")] + [TestCategory("Preview Pane")] + public void MonacoPreviewShowsSyntaxHighlightedSource() + { + TestPreview( + ".cpp", + MonacoPreviewHandler, + "main.cpp", + "source-code", + "MonacoPreviewHandler", + "MonacoPrevHandler"); + } + + [TestMethod("FileExplorerAddons.Thumbnail.SVG")] + [TestCategory("File Explorer Add-ons")] + [TestCategory("Icon Preview")] + public void SvgThumbnailRendersAtMultipleIconSizes() + { + TestThumbnail( + ".svg", + SvgThumbnailProvider, + "sample.svg", + "PowerToys.SvgThumbnailProvider", + "svg"); + } + + [TestMethod("FileExplorerAddons.Thumbnail.PDF")] + [TestCategory("File Explorer Add-ons")] + [TestCategory("Icon Preview")] + public void PdfThumbnailRendersAtMultipleIconSizes() + { + TestThumbnail( + ".pdf", + PdfThumbnailProvider, + "sample.pdf", + "PowerToys.PdfThumbnailProvider", + "pdf"); + } + + [TestMethod("FileExplorerAddons.Thumbnail.Gcode")] + [TestCategory("File Explorer Add-ons")] + [TestCategory("Icon Preview")] + public void GcodeThumbnailRendersAtMultipleIconSizes() + { + TestThumbnail( + ".gcode", + GcodeThumbnailProvider, + "sample.gcode", + "PowerToys.GcodeThumbnailProvider", + "gcode"); + } + + [TestMethod("FileExplorerAddons.Thumbnail.STL")] + [TestCategory("File Explorer Add-ons")] + [TestCategory("Icon Preview")] + public void StlThumbnailRendersAtMultipleIconSizes() + { + TestThumbnail( + ".stl", + StlThumbnailProvider, + "sample.stl", + "PowerToys.StlThumbnailProvider", + "stl"); + } + + private void TestPreview( + string extension, + string expectedClsid, + string assetName, + string scenario, + string handlerName, + string handlerLogFolder) + { + AssertShellExtensionRegistration(extension, PreviewHandlerShellExtension, expectedClsid, "preview handler"); + PrepareExplorerForRegisteredHandlers(); + + var filePath = TestAssetPath(assetName); + var explorer = OpenExplorer(Path.GetDirectoryName(filePath)!); + EnsurePreviewPaneOpen(explorer); + var handlerLogDirectory = LocalLowHandlerLogDirectory(handlerLogFolder); + DeleteDirectoryWithRetry(handlerLogDirectory); + Assert.IsFalse( + Directory.Exists(handlerLogDirectory), + $"Could not clear the previous {handlerName} log before previewing {extension}."); + + var emptyPreviewPath = CaptureStableWindow(explorer, $"{scenario}-empty"); + SelectFile(explorer, filePath); + + var handlerLog = WaitForProviderLog( + handlerLogDirectory, + $"Starting {handlerName}.exe", + ExplorerTimeoutMS); + Assert.IsNotNull( + handlerLog, + $"Explorer rendered {extension}, but did not invoke the PowerToys {handlerName} shim."); + var handlerLogText = ReadAllTextWithRetry(handlerLog!); + Assert.IsFalse( + handlerLogText.Contains("Failed to start", StringComparison.OrdinalIgnoreCase), + $"The PowerToys {handlerName} shim reported a launch failure.{Environment.NewLine}{handlerLogText}"); + var persistedLogPath = ArtifactPath($"{scenario}-handler", ".log"); + File.WriteAllText(persistedLogPath, handlerLogText); + var renderedPreviewPath = WaitForVisibleChange(explorer, emptyPreviewPath, $"{scenario}-rendered"); + + TestContext.AddResultFile(emptyPreviewPath); + TestContext.AddResultFile(renderedPreviewPath); + TestContext.AddResultFile(persistedLogPath); + } + + private void TestThumbnail( + string extension, + string expectedClsid, + string assetName, + string providerProcessName, + string scenario) + { + AssertShellExtensionRegistration(extension, ThumbnailHandlerShellExtension, expectedClsid, "thumbnail provider"); + PrepareExplorerForRegisteredHandlers(); + + var sourcePath = TestAssetPath(assetName); + var testFolder = CreateTemporaryFolder(); + var destinationPath = Path.Combine(testFolder, assetName); + var explorer = OpenExplorer(testFolder); + var providerName = providerProcessName["PowerToys.".Length..]; + var providerLogDirectory = LocalLowHandlerLogDirectory(providerName); + DeleteDirectoryWithRetry(providerLogDirectory); + Assert.IsFalse( + Directory.Exists(providerLogDirectory), + $"Could not clear the previous {providerName} log before cold thumbnail generation."); + + File.Copy(sourcePath, destinationPath); + KeyboardHelper.SendKeys(Key.F5); + SelectFile(explorer, destinationPath); + SetExplorerViewAndWait( + explorer, + assetName, + ExtraLargeIconSize, + "extra-large icons", + minimumItemHeight: 180, + maximumItemHeight: int.MaxValue); + + var providerLog = WaitForProviderLog( + providerLogDirectory, + $"Start {providerName}.exe", + ExplorerTimeoutMS); + Assert.IsNotNull( + providerLog, + $"Windows Shell did not invoke the PowerToys {providerName} shim for the cold {extension} thumbnail."); + var providerLogText = ReadAllTextWithRetry(providerLog!); + Assert.IsFalse( + providerLogText.Contains("Bmp file not generated", StringComparison.OrdinalIgnoreCase) || + providerLogText.Contains("Failed to start", StringComparison.OrdinalIgnoreCase), + $"The PowerToys {providerName} shim reported a generation failure.{Environment.NewLine}{providerLogText}"); + var persistedLogPath = ArtifactPath($"{scenario}-provider", ".log"); + File.WriteAllText(persistedLogPath, providerLogText); + TestContext.AddResultFile(persistedLogPath); + + var extraLarge = CaptureStableFileItem(explorer, assetName, $"{scenario}-extra-large"); + + SetExplorerViewAndWait( + explorer, + assetName, + LargeIconSize, + "large icons", + minimumItemHeight: Math.Max(80, extraLarge.Height / 4), + maximumItemHeight: extraLarge.Height * 7 / 10); + var large = CaptureStableFileItem(explorer, assetName, $"{scenario}-large"); + SetExplorerViewAndWait( + explorer, + assetName, + MediumIconSize, + "medium icons", + minimumItemHeight: large.Height / 2, + maximumItemHeight: large.Height * 9 / 10); + var medium = CaptureStableFileItem(explorer, assetName, $"{scenario}-medium"); + + AssertThumbnailSizes(extraLarge, large, medium, extension); + + foreach (var capture in new[] { extraLarge, large, medium }) + { + AssertImageHasVisualDetail(capture.Path, extension); + TestContext.AddResultFile(capture.Path); + } + } + + private static void AssertShellExtensionRegistration( + string extension, + string shellExtension, + string expectedClsid, + string handlerDescription) + { + var registryPath = $@"{extension}\shellex\{shellExtension}"; + var deadline = DateTime.UtcNow + TimeSpan.FromSeconds(15); + string? actualClsid = null; + + while (DateTime.UtcNow < deadline) + { + using var key = Registry.ClassesRoot.OpenSubKey(registryPath); + actualClsid = key?.GetValue(null) as string; + if (string.Equals(actualClsid, expectedClsid, StringComparison.OrdinalIgnoreCase)) + { + return; + } + + Thread.Sleep(250); + } + + Assert.Fail( + $"PowerToys did not register the effective {extension} {handlerDescription}. " + + $"Expected '{expectedClsid}' at HKCR\\{registryPath}; actual '{actualClsid ?? "<missing>"}'."); + } + + private Session OpenExplorer(string folderPath) + { + for (var attempt = 1; attempt <= ExplorerOpenAttempts; attempt++) + { + CloseExplorerFileWindows(); + var existingHandles = WindowsFinder.ListByApp("explorer") + .Where(IsExplorerFileWindow) + .Select(window => window.Hwnd) + .ToHashSet(); + + using var launchProcess = Process.Start(new ProcessStartInfo + { + FileName = "explorer.exe", + Arguments = $"/n,\"{folderPath}\"", + UseShellExecute = true, + }); + + var explorer = WindowsFinder.WaitForWindowByApp( + "explorer", + window => IsExplorerFileWindow(window) && !existingHandles.Contains(window.Hwnd), + ExplorerTimeoutMS); + if (explorer is null) + { + TestContext.WriteLine( + $"Explorer attempt {attempt}/{ExplorerOpenAttempts} did not create a fresh HWND for '{folderPath}'."); + continue; + } + + explorerWindowHandle = explorer.WindowHandle; + if (WindowControl.WaitForForeground( + new IntPtr(explorerWindowHandle), + ExplorerTimeoutMS, + requiredConsecutiveMatches: 3)) + { + return explorer; + } + + TestContext.WriteLine( + $"Explorer attempt {attempt}/{ExplorerOpenAttempts} HWND {explorerWindowHandle} did not become foreground. " + + $"Current foreground: {WindowControl.GetForegroundWindowInfo()}."); + } + + Assert.Fail( + $"Explorer did not open a stable foreground window for '{folderPath}' after {ExplorerOpenAttempts} attempts. " + + $"Current foreground: {WindowControl.GetForegroundWindowInfo()}."); + return null!; + } + + private static bool IsExplorerFileWindow(WindowsFinder.WindowInfo window) + { + return window.ClassName.Equals("CabinetWClass", StringComparison.OrdinalIgnoreCase); + } + + private static bool CloseExplorerFileWindows() + { + return WindowControl.TryCloseByApp("explorer", IsExplorerFileWindow, timeoutMS: 10_000); + } + + private static void RestartExplorerShell() + { + var oldProcesses = Process.GetProcessesByName("explorer"); + foreach (var process in oldProcesses) + { + try + { + process.Kill(); + process.WaitForExit(10_000); + } + catch + { + } + finally + { + process.Dispose(); + } + } + + var shell = WindowsFinder.WaitForWindowByApp( + "explorer", + window => window.ClassName.Equals("Shell_TrayWnd", StringComparison.OrdinalIgnoreCase), + timeoutMS: 5_000); + if (shell is null) + { + using var launchProcess = Process.Start(new ProcessStartInfo + { + FileName = "explorer.exe", + UseShellExecute = true, + }); + shell = WindowsFinder.WaitForWindowByApp( + "explorer", + window => window.ClassName.Equals("Shell_TrayWnd", StringComparison.OrdinalIgnoreCase), + timeoutMS: ExplorerTimeoutMS); + } + + Assert.IsNotNull(shell, "Explorer shell did not restart after File Explorer Add-ons registration."); + } + + private static void PrepareExplorerForRegisteredHandlers() + { + lock (ExplorerPreparationLock) + { + if (explorerPrepared) + { + return; + } + + if (Environment.UserName.Equals("WDAGUtilityAccount", StringComparison.OrdinalIgnoreCase)) + { + sandboxThumbnailRegistrations = new List<SandboxThumbnailRegistration>(); + try + { + foreach (var (extension, clsid) in ThumbnailProviders) + { + AssertShellExtensionRegistration( + extension, + ThumbnailHandlerShellExtension, + clsid, + "thumbnail provider"); + sandboxThumbnailRegistrations.Add(SandboxThumbnailRegistration.Create(extension, clsid)); + } + } + catch + { + for (var index = sandboxThumbnailRegistrations.Count - 1; index >= 0; index--) + { + sandboxThumbnailRegistrations[index].Dispose(); + } + + sandboxThumbnailRegistrations = null; + throw; + } + } + + RestartExplorerShell(); + explorerPrepared = true; + } + } + + private void EnsurePreviewPaneOpen(Session explorer) + { + EnsureExplorerForeground(explorer); + if (WaitForPreviewPane(explorer, PreviewPaneDetectionTimeoutMS)) + { + TestContext.WriteLine("Explorer's Preview pane was already open."); + return; + } + + for (var attempt = 1; attempt <= 2; attempt++) + { + EnsureExplorerForeground(explorer); + KeyboardHelper.SendKeys(Key.Alt, Key.P); + if (WaitForPreviewPane(explorer, PreviewPaneOpenTimeoutMS)) + { + TestContext.WriteLine($"Opened Explorer's Preview pane with Alt+P on attempt {attempt}."); + return; + } + + TestContext.WriteLine($"Explorer's Preview pane was not visible after Alt+P attempt {attempt}."); + } + + Assert.Fail("Explorer's Preview pane did not open after two Alt+P attempts."); + } + + private static bool WaitForPreviewPane(Session explorer, int timeoutMS) + { + return explorer.WaitFor( + () => explorer.FindAll<Element>(By.Name(EmptyPreviewPaneText), timeoutMS: 250) + .Any(element => element.Width > 0 && element.Height > 0), + timeoutMS, + pollIntervalMS: 250); + } + + private static void EnsureExplorerForeground(Session explorer) + { + Assert.IsTrue( + WindowControl.WaitForForeground( + new IntPtr(explorer.WindowHandle), + ExplorerTimeoutMS, + requiredConsecutiveMatches: 3), + $"Explorer HWND {explorer.WindowHandle} was not the stable foreground window."); + } + + private static void SelectFile(Session explorer, string filePath) + { + var selection = ExplorerShell.SetSelectionAndWaitForStable( + new IntPtr(explorer.WindowHandle), + new[] { filePath }, + filePath, + ExplorerTimeoutMS, + requiredConsecutiveMatches: 4); + + Assert.IsTrue( + selection.Succeeded, + $"Explorer did not establish a stable selection for '{filePath}'. " + + $"Last focused path: '{selection.LastObservation?.FocusedPath ?? "<none>"}'."); + } + + private void SetExplorerViewAndWait( + Session explorer, + string fileName, + int iconSize, + string viewName, + int minimumItemHeight, + int maximumItemHeight) + { + Element? lastItem = null; + for (var attempt = 1; attempt <= 3; attempt++) + { + var view = ExplorerShell.SetViewModeAndIconSizeAndWait( + new IntPtr(explorer.WindowHandle), + ExplorerShell.ViewMode.Icons, + iconSize, + timeoutMS: 5_000); + if (!view.Succeeded) + { + TestContext.WriteLine( + $"Explorer did not report {viewName} on attempt {attempt}; " + + $"last Shell view: {view.LastObservation?.Mode}, icon size: {view.LastObservation?.IconSize}."); + continue; + } + + var applied = explorer.WaitFor( + () => + { + lastItem = FindVisibleFileItem(explorer, fileName, timeoutMS: 250); + return lastItem is not null && + lastItem.Height >= minimumItemHeight && + lastItem.Height <= maximumItemHeight; + }, + timeoutMS: 5_000, + pollIntervalMS: 250); + if (applied) + { + TestContext.WriteLine( + $"Explorer applied {viewName} ({iconSize}px) on attempt {attempt}; item bounds: " + + $"{lastItem!.Width}x{lastItem.Height}."); + return; + } + } + + Assert.Fail( + $"Explorer did not apply {viewName} after three shortcut attempts. " + + $"Expected item height {minimumItemHeight}..{maximumItemHeight}; " + + $"last bounds: {lastItem?.Width ?? 0}x{lastItem?.Height ?? 0}."); + } + + private string CaptureStableWindow(Session explorer, string name) + { + var previousPath = CaptureWindow(explorer, $"{name}-initial"); + var deadline = DateTime.UtcNow + TimeSpan.FromSeconds(10); + + while (DateTime.UtcNow < deadline) + { + Thread.Sleep(400); + var currentPath = CaptureWindow(explorer, name); + var difference = CalculateImageDifference(previousPath, currentPath, startXPercent: 0, startYPercent: 0); + if (difference < 0.25) + { + File.Delete(previousPath); + return currentPath; + } + + File.Delete(previousPath); + previousPath = currentPath; + } + + return previousPath; + } + + private string WaitForVisibleChange(Session explorer, string baselinePath, string name) + { + var deadline = DateTime.UtcNow + TimeSpan.FromMilliseconds(PreviewTimeoutMS); + var lastDifference = 0d; + string? lastPath = null; + + while (DateTime.UtcNow < deadline) + { + Thread.Sleep(500); + var currentPath = CaptureWindow(explorer, name); + lastDifference = CalculateImageDifference( + baselinePath, + currentPath, + startXPercent: 55, + startYPercent: 18); + TestContext.WriteLine($"Preview-region pixel change: {lastDifference:F2}%."); + + if (lastDifference >= PreviewRegionDifferenceThreshold) + { + if (lastPath is not null) + { + File.Delete(lastPath); + } + + return currentPath; + } + + if (lastPath is not null) + { + File.Delete(lastPath); + } + + lastPath = currentPath; + } + + TestContext.AddResultFile(baselinePath); + if (lastPath is not null) + { + TestContext.AddResultFile(lastPath); + } + + Assert.Fail( + $"The Explorer preview region did not visibly render within {PreviewTimeoutMS / 1_000}s. " + + $"Expected at least {PreviewRegionDifferenceThreshold:F2}%; last sampled change was {lastDifference:F2}%."); + return null!; + } + + private ThumbnailCapture CaptureStableFileItem(Session explorer, string fileName, string name) + { + var previous = CaptureFileItem(explorer, fileName, $"{name}-initial"); + var deadline = DateTime.UtcNow + TimeSpan.FromMilliseconds(VisualStableTimeoutMS); + + while (DateTime.UtcNow < deadline) + { + Thread.Sleep(400); + var current = CaptureFileItem(explorer, fileName, name); + var difference = CalculateImageDifference(previous.Path, current.Path, 0, 0, requireSameSize: false); + if (previous.Width == current.Width && + previous.Height == current.Height && + difference < 0.25) + { + File.Delete(previous.Path); + return current; + } + + File.Delete(previous.Path); + previous = current; + } + + return previous; + } + + private ThumbnailCapture CaptureFileItem(Session explorer, string fileName, string name) + { + var item = FindVisibleFileItem(explorer, fileName, timeoutMS: 5_000); + Assert.IsNotNull(item, $"Explorer did not expose a visible item for '{fileName}'."); + item!.ScrollIntoView(); + item = FindVisibleFileItem(explorer, fileName, timeoutMS: 5_000); + Assert.IsNotNull(item, $"Explorer did not expose '{fileName}' after scrolling it into view."); + + var path = ArtifactPath(name); + EnsureExplorerForeground(explorer); + using (var bitmap = new Bitmap(item!.Width, item.Height)) + { + using var graphics = Graphics.FromImage(bitmap); + graphics.CopyFromScreen(item.X, item.Y, 0, 0, bitmap.Size); + bitmap.Save(path, System.Drawing.Imaging.ImageFormat.Png); + } + + return new ThumbnailCapture(path, item.Width, item.Height); + } + + private static Element? FindVisibleFileItem(Session explorer, string fileName, int timeoutMS) + { + var displayName = Path.GetFileNameWithoutExtension(fileName); + return explorer.FindAll<Element>(By.Name(displayName), timeoutMS) + .Where(element => element.Width > 0 && element.Height > 0) + .Where(element => + element.Name.Equals(fileName, StringComparison.OrdinalIgnoreCase) || + element.Name.Equals(displayName, StringComparison.OrdinalIgnoreCase)) + .OrderByDescending(element => element.ControlType.Equals("ListItem", StringComparison.OrdinalIgnoreCase)) + .ThenByDescending(element => element.Width * element.Height) + .FirstOrDefault(); + } + + private string CaptureWindow(Session explorer, string name) + { + var path = ArtifactPath(name); + explorer.ScreenshotVisibleWindow(path); + return path; + } + + private string ArtifactPath(string name, string extension = ".png") + { + var currentTestName = TestContext.TestName ?? "unknown-test"; + var testName = string.Concat( + currentTestName.Select(character => Path.GetInvalidFileNameChars().Contains(character) ? '-' : character)); + var directory = Path.Combine( + FindStableResultsRoot(), + "FileExplorerAddons", + testName); + Directory.CreateDirectory(directory); + return Path.Combine(directory, $"{name}-{Guid.NewGuid():N}{extension}"); + } + + private string FindStableResultsRoot() + { + var candidate = TestContext.TestResultsDirectory ?? TestContext.TestRunResultsDirectory; + var directory = string.IsNullOrWhiteSpace(candidate) ? null : new DirectoryInfo(candidate); + while (directory is not null) + { + if (directory.Name.Equals("TestResults", StringComparison.OrdinalIgnoreCase)) + { + return directory.FullName; + } + + directory = directory.Parent; + } + + return Path.GetTempPath(); + } + + private static double CalculateImageDifference( + string baselinePath, + string currentPath, + int startXPercent, + int startYPercent, + bool requireSameSize = true) + { + using var baseline = new Bitmap(baselinePath); + using var current = new Bitmap(currentPath); + if (baseline.Size != current.Size) + { + if (requireSameSize) + { + Assert.Fail("Explorer changed size while waiting for visual content."); + } + + return 100; + } + + var changedSamples = 0; + var totalSamples = 0; + var startX = baseline.Width * startXPercent / 100; + var startY = baseline.Height * startYPercent / 100; + + for (var y = startY; y < baseline.Height; y += 3) + { + for (var x = startX; x < baseline.Width; x += 3) + { + var before = baseline.GetPixel(x, y); + var after = current.GetPixel(x, y); + var colorDelta = Math.Abs(before.R - after.R) + + Math.Abs(before.G - after.G) + + Math.Abs(before.B - after.B); + if (colorDelta >= 45) + { + changedSamples++; + } + + totalSamples++; + } + } + + return totalSamples == 0 ? 0 : changedSamples * 100d / totalSamples; + } + + private static void AssertThumbnailSizes( + ThumbnailCapture extraLarge, + ThumbnailCapture large, + ThumbnailCapture medium, + string extension) + { + Assert.IsTrue( + extraLarge.Height >= 180 && + extraLarge.Height > large.Height && + large.Height > medium.Height, + $"Explorer did not apply descending icon sizes for {extension}. " + + $"Extra large: {extraLarge.Width}x{extraLarge.Height}; " + + $"large: {large.Width}x{large.Height}; medium: {medium.Width}x{medium.Height}."); + } + + private static void AssertImageHasVisualDetail(string imagePath, string extension) + { + using var image = new Bitmap(imagePath); + var colorBuckets = new HashSet<int>(); + + for (var y = 0; y < image.Height; y += 3) + { + for (var x = 0; x < image.Width; x += 3) + { + var color = image.GetPixel(x, y); + colorBuckets.Add(((color.R >> 5) << 6) | ((color.G >> 5) << 3) | (color.B >> 5)); + } + } + + Assert.IsTrue( + colorBuckets.Count >= 6, + $"The captured {extension} Explorer item has only {colorBuckets.Count} sampled color buckets; " + + "the thumbnail appears blank or generic."); + } + + private static string? WaitForProviderLog(string logDirectory, string expectedText, int timeoutMS) + { + var deadline = DateTime.UtcNow + TimeSpan.FromMilliseconds(timeoutMS); + while (DateTime.UtcNow < deadline) + { + foreach (var path in Directory.Exists(logDirectory) + ? Directory.GetFiles(logDirectory, "*.log", SearchOption.TopDirectoryOnly) + : Array.Empty<string>()) + { + var contents = ReadAllTextWithRetry(path); + if (contents.Contains(expectedText, StringComparison.OrdinalIgnoreCase)) + { + return path; + } + } + + Thread.Sleep(100); + } + + return null; + } + + private static string LocalLowHandlerLogDirectory(string handlerFolder) + { + return Path.Combine( + Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), + "AppData", + "LocalLow", + "Microsoft", + "PowerToys", + "logs", + "FileExplorer_localLow", + handlerFolder); + } + + private static string ReadAllTextWithRetry(string path) + { + for (var attempt = 0; attempt < 20; attempt++) + { + try + { + using var stream = new FileStream( + path, + FileMode.Open, + FileAccess.Read, + FileShare.ReadWrite | FileShare.Delete); + using var reader = new StreamReader(stream); + return reader.ReadToEnd(); + } + catch (IOException) when (attempt < 19) + { + Thread.Sleep(50); + } + } + + return string.Empty; + } + + private string TestAssetPath(string assetName) + { + var path = Path.GetFullPath(Path.Combine("TestAssets", assetName)); + Assert.IsTrue(File.Exists(path), $"File Explorer Add-ons test asset does not exist: {path}"); + return path; + } + + private string CreateTemporaryFolder() + { + var folder = Path.Combine(Path.GetTempPath(), "PowerToys-FileExplorerAddons", Guid.NewGuid().ToString("N")); + Directory.CreateDirectory(folder); + temporaryFolders.Add(folder); + return folder; + } + + private static void DeleteDirectoryWithRetry(string folder) + { + for (var attempt = 0; attempt < 20 && Directory.Exists(folder); attempt++) + { + try + { + Directory.Delete(folder, recursive: true); + } + catch (IOException) + { + Thread.Sleep(100); + } + catch (UnauthorizedAccessException) + { + Thread.Sleep(100); + } + } + } + + private sealed class SandboxThumbnailRegistration : IDisposable + { + private readonly bool active; + private readonly string providerPath = string.Empty; + private readonly string associationPath = string.Empty; + private readonly RegistryTreeSnapshot? userProvider; + private readonly RegistryTreeSnapshot? userAssociation; + private readonly RegistryTreeSnapshot? machineProvider; + private readonly RegistryTreeSnapshot? machineAssociation; + private readonly RegistryTreeSnapshot? machineIsolation; + + private SandboxThumbnailRegistration() + { + } + + private SandboxThumbnailRegistration( + string providerPath, + string associationPath, + RegistryTreeSnapshot userProvider, + RegistryTreeSnapshot userAssociation, + RegistryTreeSnapshot machineProvider, + RegistryTreeSnapshot machineAssociation, + RegistryTreeSnapshot machineIsolation) + { + active = true; + this.providerPath = providerPath; + this.associationPath = associationPath; + this.userProvider = userProvider; + this.userAssociation = userAssociation; + this.machineProvider = machineProvider; + this.machineAssociation = machineAssociation; + this.machineIsolation = machineIsolation; + } + + public static SandboxThumbnailRegistration Create(string extension, string providerClsid) + { + if (!Environment.UserName.Equals("WDAGUtilityAccount", StringComparison.OrdinalIgnoreCase)) + { + return new SandboxThumbnailRegistration(); + } + + var providerPath = $@"Software\Classes\CLSID\{providerClsid}"; + var associationPath = $@"Software\Classes\{extension}\shellex\{ThumbnailHandlerShellExtension}"; + var userProvider = RegistryTreeSnapshot.Capture(Registry.CurrentUser, providerPath); + var userAssociation = RegistryTreeSnapshot.Capture(Registry.CurrentUser, associationPath); + var machineProvider = RegistryTreeSnapshot.Capture(Registry.LocalMachine, providerPath); + var machineAssociation = RegistryTreeSnapshot.Capture(Registry.LocalMachine, associationPath); + var machineIsolation = RegistryTreeSnapshot.Capture(Registry.LocalMachine, ThumbnailIsolationRegistryPath); + + Assert.IsTrue(userProvider.Exists, $"Sandbox bridge could not find HKCU\\{providerPath}."); + Assert.IsTrue(userAssociation.Exists, $"Sandbox bridge could not find HKCU\\{associationPath}."); + + try + { + userProvider.Restore(Registry.LocalMachine, providerPath); + userAssociation.Restore(Registry.LocalMachine, associationPath); + using (var isolationKey = Registry.LocalMachine.CreateSubKey(ThumbnailIsolationRegistryPath, writable: true)) + { + Assert.IsNotNull(isolationKey, "Could not create the machine Shell thumbnail isolation key in Sandbox."); + isolationKey!.SetValue(DisableProcessIsolationValueName, 1, RegistryValueKind.DWord); + } + + Registry.CurrentUser.DeleteSubKeyTree(providerPath, throwOnMissingSubKey: false); + Registry.CurrentUser.DeleteSubKeyTree(associationPath, throwOnMissingSubKey: false); + NotifyShellAssociationsChanged(); + + return new SandboxThumbnailRegistration( + providerPath, + associationPath, + userProvider, + userAssociation, + machineProvider, + machineAssociation, + machineIsolation); + } + catch + { + machineIsolation.Restore(Registry.LocalMachine, ThumbnailIsolationRegistryPath); + machineAssociation.Restore(Registry.LocalMachine, associationPath); + machineProvider.Restore(Registry.LocalMachine, providerPath); + userAssociation.Restore(Registry.CurrentUser, associationPath); + userProvider.Restore(Registry.CurrentUser, providerPath); + NotifyShellAssociationsChanged(); + throw; + } + } + + public void Dispose() + { + if (!active) + { + return; + } + + machineIsolation!.Restore(Registry.LocalMachine, ThumbnailIsolationRegistryPath); + machineAssociation!.Restore(Registry.LocalMachine, associationPath); + machineProvider!.Restore(Registry.LocalMachine, providerPath); + userAssociation!.Restore(Registry.CurrentUser, associationPath); + userProvider!.Restore(Registry.CurrentUser, providerPath); + NotifyShellAssociationsChanged(); + } + } + + private sealed class RegistryTreeSnapshot + { + private readonly List<RegistryValueSnapshot> values = new(); + private readonly Dictionary<string, RegistryTreeSnapshot> subKeys = new(StringComparer.OrdinalIgnoreCase); + + private RegistryTreeSnapshot(bool exists) + { + Exists = exists; + } + + public bool Exists { get; } + + public static RegistryTreeSnapshot Capture(RegistryKey root, string path) + { + using var key = root.OpenSubKey(path, writable: false); + return key is null ? new RegistryTreeSnapshot(false) : CaptureKey(key); + } + + public void Restore(RegistryKey root, string path) + { + root.DeleteSubKeyTree(path, throwOnMissingSubKey: false); + if (!Exists) + { + return; + } + + using var key = root.CreateSubKey(path, writable: true) ?? + throw new InvalidOperationException($"Could not restore registry key '{path}'."); + RestoreKey(key); + } + + private static RegistryTreeSnapshot CaptureKey(RegistryKey key) + { + var snapshot = new RegistryTreeSnapshot(true); + foreach (var valueName in key.GetValueNames()) + { + var value = key.GetValue(valueName, null, RegistryValueOptions.DoNotExpandEnvironmentNames); + if (value is not null) + { + snapshot.values.Add(new RegistryValueSnapshot(valueName, value, key.GetValueKind(valueName))); + } + } + + foreach (var subKeyName in key.GetSubKeyNames()) + { + using var subKey = key.OpenSubKey(subKeyName, writable: false); + if (subKey is not null) + { + snapshot.subKeys[subKeyName] = CaptureKey(subKey); + } + } + + return snapshot; + } + + private void RestoreKey(RegistryKey key) + { + foreach (var value in values) + { + key.SetValue(value.Name, value.Value, value.Kind); + } + + foreach (var (subKeyName, snapshot) in subKeys) + { + using var subKey = key.CreateSubKey(subKeyName, writable: true) ?? + throw new InvalidOperationException($"Could not restore registry subkey '{subKeyName}'."); + snapshot.RestoreKey(subKey); + } + } + } + + private sealed record RegistryValueSnapshot(string Name, object Value, RegistryValueKind Kind); + + private static void NotifyShellAssociationsChanged() + { + SHChangeNotify(0x08000000, 0, IntPtr.Zero, IntPtr.Zero); + } + + [DllImport("shell32.dll")] + private static extern void SHChangeNotify(long eventId, uint flags, IntPtr item1, IntPtr item2); + + private sealed record ThumbnailCapture(string Path, int Width, int Height); +} diff --git a/src/modules/previewpane/PreviewPane.UITests/PreviewPane.UITests.csproj b/src/modules/previewpane/PreviewPane.UITests/PreviewPane.UITests.csproj new file mode 100644 index 0000000000..bbc53b3736 --- /dev/null +++ b/src/modules/previewpane/PreviewPane.UITests/PreviewPane.UITests.csproj @@ -0,0 +1,52 @@ +<Project Sdk="Microsoft.NET.Sdk"> + <Import Project="$(RepoRoot)src\Common.Dotnet.CsWinRT.props" /> + + <PropertyGroup> + <OutputType>Exe</OutputType> + <TargetFramework>net10.0-windows10.0.26100.0</TargetFramework> + <ImplicitUsings>enable</ImplicitUsings> + <Nullable>enable</Nullable> + <IsPackable>false</IsPackable> + <TreatWarningsAsErrors>false</TreatWarningsAsErrors> + <RootNamespace>Microsoft.PowerToys.PreviewPane.UITests</RootNamespace> + <AssemblyName>PreviewPane.UITests</AssemblyName> + <ApplicationManifest>app.manifest</ApplicationManifest> + <IsTestingPlatformApplication>true</IsTestingPlatformApplication> + <EnableMSTestRunner>true</EnableMSTestRunner> + <GenerateDocumentationFile>false</GenerateDocumentationFile> + <RunVSTest>false</RunVSTest> + </PropertyGroup> + + <PropertyGroup> + <OutputPath>$(RepoRoot)$(Platform)\$(Configuration)\tests\PreviewPane.UITests\</OutputPath> + </PropertyGroup> + + <ItemGroup> + <PackageReference Include="MSTest" /> + </ItemGroup> + + <ItemGroup> + <ProjectReference Include="..\..\..\common\UITestAutomation.Next\UITestAutomation.Next.csproj" /> + </ItemGroup> + + <ItemGroup> + <Content Include="$(RepoRoot)README.md" Link="TestAssets\README.md"> + <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory> + </Content> + <Content Include="$(RepoRoot)src\modules\previewpane\UnitTests-SvgPreviewHandler\HelperFiles\file1.svg" Link="TestAssets\sample.svg"> + <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory> + </Content> + <Content Include="$(RepoRoot)src\modules\previewpane\UnitTests-PdfPreviewHandler\HelperFiles\sample.pdf" Link="TestAssets\sample.pdf"> + <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory> + </Content> + <Content Include="$(RepoRoot)src\modules\previewpane\UnitTests-GcodePreviewHandler\HelperFiles\sample_JPG.gcode" Link="TestAssets\sample.gcode"> + <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory> + </Content> + <Content Include="$(RepoRoot)src\modules\previewpane\UnitTests-StlThumbnailProvider\HelperFiles\sample.stl" Link="TestAssets\sample.stl"> + <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory> + </Content> + <Content Include="$(RepoRoot)src\runner\main.cpp" Link="TestAssets\main.cpp"> + <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory> + </Content> + </ItemGroup> +</Project> \ No newline at end of file diff --git a/src/modules/previewpane/PreviewPane.UITests/app.manifest b/src/modules/previewpane/PreviewPane.UITests/app.manifest new file mode 100644 index 0000000000..4107ae5a54 --- /dev/null +++ b/src/modules/previewpane/PreviewPane.UITests/app.manifest @@ -0,0 +1,10 @@ +<?xml version="1.0" encoding="utf-8"?> +<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1"> + <assemblyIdentity version="1.0.0.0" name="PreviewPane.UITests.app" /> + <application xmlns="urn:schemas-microsoft-com:asm.v3"> + <windowsSettings> + <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2</dpiAwareness> + <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true/pm</dpiAware> + </windowsSettings> + </application> +</assembly> \ No newline at end of file