CI / Build and test (push) Successful in 8m14s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 7s
Release / Build, test and publish (push) Successful in 13m19s
CI / PostgreSQL 16 integration (push) Successful in 4m49s
CI / PostgreSQL 17 integration (push) Successful in 5m28s
CI / Docker image (push) Successful in 53s
Release / Server image (push) Failing after 10s
The owner renamed the product and moved the repository to the self-hosted Gitea (https://gitea.encke-hake.ts.net/BalboSoft/Chronos) for more control, and asked for Actions and a first automatic release with the server package and the Windows exe (docs/requests/2026-10-23-chronos-gitea.md). - Chronos everywhere: a byte-exact rename of contents and paths, then a per-language review of the forms the old name's ending had dictated. - Gitea instead of GitHub: the update check, licence, issue and support links read ChronosReleasesUrl; the update check takes the highest stable version, offers a pre-release build its final release and reports a repository it cannot see as a failed check. EULA, security policy and Gitea issue forms live at the repository root. - Gitea Actions for the Linux act_runner (.gitea/workflows): CI, release, nightly image and performance gates in the .NET SDK container with git checkout and the system SQLite. The release cross-compiles the Windows programs, checks their icon, version and DPI manifest, packs installers and zips, publishes the Gitea release and pushes the server image (REGISTRY_TOKEN). Windows-only tests run in an opt-in job on a Windows runner (WINDOWS_RUNNER). - New Chronos.Tools commands: zip, gitea-release, postgres-ci (replaces the docker-exec script, which Gitea's service containers do not allow; the throw-away server runs without durability) and pe-check. - Timed tests take their budget from TestTiming (CHRONOS_TEST_TIME_FACTOR, 3 on the shared runner; the weekly performance gates keep theirs). BREAKING CHANGE: programs, settings, data folders, file types, environment variables and the Docker image use the new name; nothing is migrated from Titano, which never had a release. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
440 lines
22 KiB
C#
440 lines
22 KiB
C#
using System.Windows;
|
||
using System.Windows.Automation;
|
||
using System.Windows.Controls;
|
||
using System.Windows.Controls.Primitives;
|
||
using System.Windows.Input;
|
||
using System.Windows.Media;
|
||
using Chronos.App.Import;
|
||
using Chronos.App.Infrastructure;
|
||
using Chronos.App.Sections;
|
||
using Chronos.App.Shell;
|
||
using Chronos.App.Tests.Windows;
|
||
using Chronos.Core.Localization;
|
||
using Chronos.Testing;
|
||
using Chronos.Ui.Controls;
|
||
|
||
namespace Chronos.App.Tests.Import;
|
||
|
||
/// <summary>
|
||
/// Every Import state of <c>--capture</c> (<see cref="ImportScenes"/>) on the simulated cards, rendered in both themes
|
||
/// in the real main window at the 1200 × 788 capture size, with the figures and gates each state must show — and the
|
||
/// buttons really enabled, named for screen readers, nothing that matters cut off, and paths, numbers and times
|
||
/// readable in a right-to-left language.
|
||
/// </summary>
|
||
[WindowsOnly]
|
||
[Serial]
|
||
[Timeout(300_000)]
|
||
public sealed class ImportScreenSmokeTests
|
||
{
|
||
[Test]
|
||
public Task EveryImportStateRendersInBothThemes() => ScreenHost.RunAsync(async () =>
|
||
{
|
||
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
|
||
await app.Sample.FillAsync();
|
||
var import = app.Shell.Import;
|
||
|
||
await ShowAsync(app, "inserted");
|
||
await UseCaptureSizeAsync(app);
|
||
Assert.NotEmpty(app.FindAll<ToastHost>().SelectMany(host => host.Toasts), "the insertion toast");
|
||
Assert.False(import.FolderPath.HasErrors, "the folder path is not checked while Archive is the destination");
|
||
await app.ExpectAsync<ImportView>("import-inserted");
|
||
|
||
await ShowAsync(app, "plan");
|
||
Assert.Equal(ImportPhase.Ready, import.Phase);
|
||
Assert.Equal("EOS R5 · card A", import.SourceTitle);
|
||
Assert.Equal(3, import.Sessions.Count, "night, dawn and sunset");
|
||
Assert.Equal(50, import.Plan!.CopyCount);
|
||
Assert.Equal("Harbour sunset", import.Plan.Sessions[^1].Title);
|
||
Assert.Null(import.StartBlocker);
|
||
Assert.Empty(app.FindAll<ToastHost>().SelectMany(host => host.Toasts));
|
||
await app.ExpectAsync<ImportView>("import-plan");
|
||
Assert.True(ButtonFor(app, import.StartCommand).IsEnabled, "the Import button is enabled once the plan is ready");
|
||
Assert.True(ButtonFor(app, import.Sessions[1].MergeCommand).IsEnabled, "a session can merge into the one before");
|
||
Assert.False(Validation.GetHasError(Named<TextBox>(app, "FolderPathBox")), "the folder path is not checked while Archive is the destination");
|
||
foreach (var session in import.Sessions)
|
||
Assert.True(Fits(TextFor(app, session.Row.TimeText)), $"the session time '{session.Row.TimeText}' is cut at 1200 px");
|
||
foreach (var item in DeviceItems(app))
|
||
{
|
||
Assert.NotNull(item.FocusVisualStyle, "a device shows keyboard focus");
|
||
Assert.Equal(((ImportSource)item.DataContext).ToolTip, item.ToolTip as string);
|
||
}
|
||
AssertEveryButtonIsNamed(app);
|
||
await AssertFourDigitsFitAsync(app, import);
|
||
await AssertFolderPathIsCheckedOnlyForFolderAsync(app, import);
|
||
|
||
await ShowAsync(app, "showplan");
|
||
Assert.True(import.IsDetailsOpen);
|
||
Assert.Equal(50 + 3, import.Details!.Rows.Count);
|
||
await app.ExpectAsync<ImportView>("import-showplan");
|
||
var file = import.Details.Rows[2];
|
||
Assert.True(Fits(TextFor(app, file.SourceText)), "a file's name on the card is shown whole");
|
||
Assert.True(Fits(TextFor(app, file.DestinationText)), "a file's new name is shown whole");
|
||
Assert.True(Fits(TextFor(app, import.Details.Rows[0].SourceText)), "a session heading is shown whole");
|
||
Assert.Within(Left(app, TextFor(app, Loc.L("Import.Details.Column.Action"))), 0, Left(app, TextFor(app, file.ActionText)), 0, 2,
|
||
"the Action header lines up with its cells");
|
||
AssertEveryButtonIsNamed(app);
|
||
|
||
await ShowAsync(app, "running");
|
||
Assert.True(import.IsRunning);
|
||
Assert.False(import.IsFormEnabled);
|
||
Assert.False(import.Sessions[0].IsEditable, "titles lock while copying");
|
||
await app.ExpectAsync<ImportView>("import-running");
|
||
Assert.True(ButtonFor(app, import.CancelCommand).IsEnabled, "Cancel is enabled while copying");
|
||
foreach (var item in DeviceItems(app))
|
||
{
|
||
Assert.False(item.IsEnabled, "the source of a running import stays selected");
|
||
Assert.Equal(Loc.L("Import.Blocked.Copying"), item.ToolTip as string);
|
||
}
|
||
Assert.Equal(0.4, TextFor(app, Loc.L("Import.Scan.Frames")).Opacity, "unit words dim with their field");
|
||
var progress = Named<TextBlock>(app, "ProgressLine");
|
||
Assert.Equal(AutomationLiveSetting.Polite, AutomationProperties.GetLiveSetting(progress));
|
||
Assert.Same(progress, AutomationProperties.GetLabeledBy(app.FindAll<ProgressBar>().First(p => p.IsVisible && IsInImport(p))));
|
||
|
||
await ShowAsync(app, "failed");
|
||
Assert.True(import.IsFailed);
|
||
Assert.Equal("EOS R5 · card A is no longer available.", import.ErrorText);
|
||
Assert.Contains(SampleCards.Card(app.Services.Environment.DataDirectory).Root, import.FailureToolTip);
|
||
await app.ExpectAsync<ImportView>("import-failed");
|
||
Assert.True(ButtonFor(app, import.RetryCommand).IsEnabled, "Retry is enabled after a failure");
|
||
var failure = Named<TextBlock>(app, "FailureLine");
|
||
Assert.Equal(AutomationLiveSetting.Assertive, AutomationProperties.GetLiveSetting(failure));
|
||
Assert.True(Fits(failure), "the failure sentence is shown whole");
|
||
Assert.Null(app.FindAll<Button>().FirstOrDefault(b => b.IsVisible && ReferenceEquals(b.Command, app.Shell.NavigateCommand) && IsInImport(b)),
|
||
"an error offers one action");
|
||
|
||
await ShowAsync(app, "done");
|
||
Assert.True(import.IsDone);
|
||
var result = import.Result!;
|
||
Assert.True(result.IsComplete);
|
||
Assert.True(result.OffersDelete);
|
||
Assert.True(result.Actions.CanDelete, "a verified import and its dry run allow deleting");
|
||
Assert.Equal(49, result.Actions.DeleteCount);
|
||
Assert.False(result.Actions.CanFormat, "a photo touched since the import keeps the card from being formatted");
|
||
Assert.Empty(app.FindAll<ToastHost>().SelectMany(host => host.Toasts));
|
||
Assert.False(import.IsFormEnabled, "a finished import keeps its form until New import");
|
||
Assert.False(import.TotalsText.Contains(Loc.L("Import.Plan.About", string.Empty).Trim(), StringComparison.Ordinal), "no estimate after the import");
|
||
Assert.Equal(string.Empty, import.SpaceText);
|
||
await app.ExpectAsync<ImportView>("import-done");
|
||
Assert.True(ButtonFor(app, result.DeleteCommand).IsEnabled, "the Delete button follows the dry run");
|
||
AssertEveryButtonIsNamed(app);
|
||
|
||
await ShowAsync(app, "newcard");
|
||
Assert.True(import.IsNicknameOpen, "a new card asks for its nickname");
|
||
Assert.Equal("SONY", import.SourceTitle);
|
||
Assert.False(import.SelectedSource!.IsKnown, "a card without a nickname is still new, though its plan remembered it");
|
||
Assert.NotEmpty(app.FindAll<ToastHost>().SelectMany(host => host.Toasts));
|
||
await app.ExpectAsync<ImportView>("import-newcard");
|
||
AssertEveryButtonIsNamed(app);
|
||
});
|
||
|
||
[Test]
|
||
public Task PathsNumbersAndTimesStayReadableRightToLeft() => ScreenHost.RunAsync(async () =>
|
||
{
|
||
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
|
||
await app.Sample.FillAsync();
|
||
UiLanguage.Apply("ar");
|
||
try
|
||
{
|
||
var import = app.Shell.Import;
|
||
await ShowAsync(app, "plan");
|
||
Assert.Equal(ImportPhase.Ready, import.Phase);
|
||
Assert.Equal(FlowDirection.RightToLeft, WindowOf(app).FlowDirection);
|
||
Assert.Equal(FlowDirection.LeftToRight, Named<TextBox>(app, "FolderPathBox").FlowDirection);
|
||
Assert.Equal(FlowDirection.LeftToRight, Named<TextBox>(app, "GapBox").FlowDirection);
|
||
foreach (var template in app.FindAll<TextBox>().Where(t => EditBehavior.GetField(t) is { } f && (f == import.FolderTemplate || f == import.FileTemplate)))
|
||
Assert.Equal(FlowDirection.LeftToRight, template.FlowDirection, "name templates read left to right");
|
||
Assert.Equal(FlowDirection.LeftToRight, TextFor(app, import.NamePreview).FlowDirection, "the name preview reads left to right");
|
||
// A size carries the language's unit, so it reads in the language's direction, whole, at the end of its cell.
|
||
var size = TextFor(app, import.Sessions[0].Row.SizeText);
|
||
Assert.Equal(FlowDirection.RightToLeft, size.FlowDirection);
|
||
Assert.Equal(TextAlignment.Right, size.TextAlignment);
|
||
var shown = size.ActualWidth + size.Margin.Left + size.Margin.Right;
|
||
size.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
|
||
Assert.True(shown >= size.DesiredSize.Width - 0.5, $"the size column fits the whole size ({shown:0.#} < {size.DesiredSize.Width:0.#})");
|
||
Assert.Contains("←", import.Sessions[0].Row.TimeText);
|
||
await app.ExpectAsync<ImportView>("import-plan-ar");
|
||
|
||
await ShowAsync(app, "showplan");
|
||
var file = import.Details!.Rows[2];
|
||
Assert.Equal(FlowDirection.LeftToRight, TextFor(app, file.SourceText).FlowDirection);
|
||
Assert.Equal(FlowDirection.LeftToRight, TextFor(app, file.DestinationText).FlowDirection);
|
||
await app.ExpectAsync<ImportView>("import-showplan-ar");
|
||
}
|
||
finally
|
||
{
|
||
UiLanguage.Apply("en");
|
||
}
|
||
});
|
||
|
||
/// <summary>
|
||
/// An archive import whose job ends before the screen records its id (here cancelled inside the engine's own "queued"
|
||
/// event, so the screen sees none of its events) still ends the screen's run instead of leaving it copying forever.
|
||
/// </summary>
|
||
[Test]
|
||
public Task AnImportJobThatEndsBeforeItIsRecordedStillEndsTheRun() => ScreenHost.RunAsync(async () =>
|
||
{
|
||
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
|
||
await app.Sample.FillAsync();
|
||
var import = app.Shell.Import;
|
||
await ShowAsync(app, "plan");
|
||
var engine = Assert.NotNull(app.Services.Engine);
|
||
void CancelAtOnce(Core.Model.Job job)
|
||
{
|
||
if (job is { Kind: Core.Model.JobKind.Import, State: Core.Model.JobState.Queued }) engine.CancelAsync(job.Id).GetAwaiter().GetResult();
|
||
}
|
||
engine.JobChanged += CancelAtOnce;
|
||
try
|
||
{
|
||
Assert.True(import.StartCommand.CanExecute(null), "the plan can be imported");
|
||
import.StartCommand.Execute(null);
|
||
for (var i = 0; i < 300 && !import.IsFailed; i++) await Task.Delay(50);
|
||
}
|
||
finally
|
||
{
|
||
engine.JobChanged -= CancelAtOnce;
|
||
}
|
||
Assert.True(import.IsFailed, "the screen left Running though no event of the job reached it");
|
||
Assert.Equal(Loc.L("Import.Status.Cancelled"), import.ErrorText);
|
||
});
|
||
|
||
/// <summary>A result replaced by New import stops following the language: nothing keeps it, or its plan, alive.</summary>
|
||
[Test]
|
||
public Task AReplacedResultStopsFollowingTheLanguage() => ScreenHost.RunAsync(async () =>
|
||
{
|
||
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
|
||
await app.Sample.FillAsync();
|
||
var import = app.Shell.Import;
|
||
await ShowAsync(app, "done");
|
||
var replaced = Assert.NotNull(import.Result);
|
||
var refreshed = 0;
|
||
replaced.PropertyChanged += (_, _) => refreshed++;
|
||
import.NewImportCommand.Execute(null);
|
||
Assert.Null(import.Result);
|
||
try
|
||
{
|
||
UiLanguage.Apply("it");
|
||
}
|
||
finally
|
||
{
|
||
UiLanguage.Apply("en");
|
||
}
|
||
Assert.Equal(0, refreshed, "the replaced result was disposed");
|
||
await import.WaitForPlanAsync();
|
||
});
|
||
|
||
/// <summary>As <c>--capture</c> does: toasts of the previous state go, those of an insertion state stay.</summary>
|
||
private static async Task ShowAsync(ScreenSmokeTests.SampleApp app, string state)
|
||
{
|
||
DismissToasts(app);
|
||
await ImportScenes.ShowAsync(app.Shell, state);
|
||
if (!ImportScenes.ShowsToast(state)) DismissToasts(app);
|
||
await SettleAsync(app);
|
||
}
|
||
|
||
private static void DismissToasts(ScreenSmokeTests.SampleApp app)
|
||
{
|
||
foreach (var host in app.FindAll<ToastHost>())
|
||
{
|
||
foreach (var toast in host.Toasts.ToList()) host.Dismiss(toast);
|
||
}
|
||
}
|
||
|
||
/// <summary>The size CI captures at (and the window's minimum width): nothing may be cut there.</summary>
|
||
private static async Task UseCaptureSizeAsync(ScreenSmokeTests.SampleApp app)
|
||
{
|
||
var window = WindowOf(app);
|
||
window.Width = 1200;
|
||
window.Height = 788;
|
||
await SettleAsync(app);
|
||
}
|
||
|
||
private static async Task SettleAsync(ScreenSmokeTests.SampleApp app)
|
||
{
|
||
var window = WindowOf(app);
|
||
window.UpdateLayout();
|
||
await window.Dispatcher.InvokeAsync(() => { }, System.Windows.Threading.DispatcherPriority.ApplicationIdle);
|
||
window.UpdateLayout();
|
||
}
|
||
|
||
private static async Task WaitUntilAsync(ScreenSmokeTests.SampleApp app, Func<bool> condition, string what)
|
||
{
|
||
for (var i = 0; i < 200 && !condition(); i++) await Task.Delay(25);
|
||
Assert.True(condition(), what);
|
||
await SettleAsync(app);
|
||
}
|
||
|
||
/// <summary>The empty folder path is fine for the archive; choosing Folder makes it invalid and offers "Choose folder".</summary>
|
||
private static async Task AssertFolderPathIsCheckedOnlyForFolderAsync(ScreenSmokeTests.SampleApp app, ImportViewModel import)
|
||
{
|
||
var box = Named<TextBox>(app, "FolderPathBox");
|
||
import.IsFolderDestination = true;
|
||
await WaitUntilAsync(app, () => import.Phase == ImportPhase.NoSource, "the plan stops without a folder");
|
||
Assert.True(Validation.GetHasError(box), "an empty path is an error once Folder is chosen");
|
||
Assert.True(import.HasStatusAction);
|
||
Assert.Equal(Loc.L("Import.Destination.Choose"), import.StatusActionText);
|
||
Assert.True(Named<Button>(app, "StatusActionButton").IsVisible, "the status sentence comes with its action");
|
||
import.IsArchiveDestination = true;
|
||
await WaitUntilAsync(app, () => import.Phase == ImportPhase.Ready, "the archive plan is back");
|
||
Assert.False(Validation.GetHasError(box));
|
||
Assert.Equal("Harbour sunset", import.Plan!.Sessions[^1].Title, "typed titles survive the round trip");
|
||
}
|
||
|
||
/// <summary>The 56 px gap box shows its largest value, 1440, whole.</summary>
|
||
private static async Task AssertFourDigitsFitAsync(ScreenSmokeTests.SampleApp app, ImportViewModel import)
|
||
{
|
||
import.GapMinutes.Text = "1440";
|
||
await SettleAsync(app);
|
||
var host = Descendants(Named<TextBox>(app, "GapBox")).OfType<ScrollViewer>().First();
|
||
Assert.LessOrEqual(host.ExtentWidth, host.ViewportWidth + 1, "1440 fits the gap box");
|
||
import.GapMinutes.Revert();
|
||
}
|
||
|
||
/// <summary>Every button, check box and radio button of the screen has a name screen readers can announce.</summary>
|
||
private static void AssertEveryButtonIsNamed(ScreenSmokeTests.SampleApp app)
|
||
{
|
||
foreach (var button in app.FindAll<ButtonBase>().Where(b => b.IsVisible && b.Focusable && IsInImport(b)))
|
||
{
|
||
var name = AutomationProperties.GetName(button);
|
||
if (string.IsNullOrEmpty(name)) name = button.Content as string;
|
||
Assert.False(string.IsNullOrWhiteSpace(name), $"{button.GetType().Name} '{button.Name}' bound to {button.Command} has no accessible name");
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Beside the 200 px rail at the 1200 px minimum (owner review 1, R1), in every shipped language: the session rows' Merge and the
|
||
/// plan rows' Split stay inside their rows (shown or not yet revealed), and the result line inside its card.
|
||
/// </summary>
|
||
[Test]
|
||
public Task RowButtonsAndTheResultFitAtTheMinimumWidthInEveryLanguage() => ScreenHost.RunAsync(async () =>
|
||
{
|
||
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
|
||
await app.Sample.FillAsync();
|
||
foreach (var (state, list) in new[] { ("plan", "SessionRows"), ("showplan", "PlanRows") })
|
||
{
|
||
await ShowAsync(app, state);
|
||
await UseCaptureSizeAsync(app);
|
||
await InEveryLanguageAsync(app, language =>
|
||
{
|
||
var rows = Named<ListBox>(app, list);
|
||
var viewport = Descendants(rows).OfType<ScrollContentPresenter>().First();
|
||
var (left, right) = Span(viewport, WindowOf(app));
|
||
foreach (var button in Descendants(rows).OfType<Button>().Where(b => b.Visibility != Visibility.Collapsed && b.ActualWidth > 0))
|
||
{
|
||
var (start, end) = Span(button, WindowOf(app));
|
||
Assert.True(start >= left - 0.5 && end <= right + 0.5, $"{language} {state}: '{button.Content}' spans {start:0}–{end:0} px, its rows {left:0}–{right:0} px");
|
||
}
|
||
});
|
||
}
|
||
await ShowAsync(app, "done");
|
||
await UseCaptureSizeAsync(app);
|
||
await InEveryLanguageAsync(app, language =>
|
||
{
|
||
var result = app.FindAll<StatusGlyph>().First(g => g.IsVisible && g.DataContext is ImportResultViewModel && IsInImport(g));
|
||
var line = (FrameworkElement)VisualTreeHelper.GetParent(result);
|
||
var card = (FrameworkElement)VisualTreeHelper.GetParent(line);
|
||
var (left, right) = Span(card, WindowOf(app));
|
||
foreach (var text in Descendants(line).OfType<TextBlock>().Where(t => t.IsVisible))
|
||
{
|
||
var (start, end) = Span(text, WindowOf(app));
|
||
Assert.True(start >= left - 0.5 && end <= right + 0.5, $"{language}: '{text.Text}' spans {start:0}–{end:0} px, its card {left:0}–{right:0} px");
|
||
}
|
||
});
|
||
});
|
||
|
||
private static async Task InEveryLanguageAsync(ScreenSmokeTests.SampleApp app, Action<string> check)
|
||
{
|
||
try
|
||
{
|
||
foreach (var language in Languages.Shipped)
|
||
{
|
||
UiLanguage.Apply(language);
|
||
await SettleAsync(app);
|
||
check(language);
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
UiLanguage.Apply("en");
|
||
}
|
||
}
|
||
|
||
/// <summary>The left and right edges of an element in window coordinates, whichever way the window reads.</summary>
|
||
private static (double Left, double Right) Span(FrameworkElement element, Window window)
|
||
{
|
||
var a = element.TranslatePoint(new Point(0, 0), window).X;
|
||
var b = element.TranslatePoint(new Point(element.ActualWidth, 0), window).X;
|
||
return (Math.Min(a, b), Math.Max(a, b));
|
||
}
|
||
|
||
private static Window WindowOf(ScreenSmokeTests.SampleApp app) => Window.GetWindow(app.FindAll<FrameworkElement>().First())!;
|
||
|
||
private static ImportView View(ScreenSmokeTests.SampleApp app) => app.FindAll<ImportView>().First(v => v.IsVisible);
|
||
|
||
private static bool IsInImport(DependencyObject element) => FindAncestor<ImportView>(element) is not null;
|
||
|
||
private static T? FindAncestor<T>(DependencyObject element)
|
||
where T : DependencyObject
|
||
{
|
||
for (var node = VisualTreeHelper.GetParent(element); node is not null; node = VisualTreeHelper.GetParent(node))
|
||
{
|
||
if (node is T match) return match;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
private static IEnumerable<DependencyObject> Descendants(DependencyObject root)
|
||
{
|
||
for (var i = 0; i < VisualTreeHelper.GetChildrenCount(root); i++)
|
||
{
|
||
var child = VisualTreeHelper.GetChild(root, i);
|
||
yield return child;
|
||
foreach (var below in Descendants(child)) yield return below;
|
||
}
|
||
}
|
||
|
||
private static T Named<T>(ScreenSmokeTests.SampleApp app, string name)
|
||
where T : FrameworkElement =>
|
||
Assert.NotNull(app.FindAll<T>().FirstOrDefault(e => e.Name == name), $"{typeof(T).Name} {name}");
|
||
|
||
private static TextBlock TextFor(ScreenSmokeTests.SampleApp app, string text) =>
|
||
Assert.NotNull(app.FindAll<TextBlock>().FirstOrDefault(t => t.IsVisible && t.Text == text && IsInImport(t)), $"a visible text '{text}'");
|
||
|
||
private static IEnumerable<ListBoxItem> DeviceItems(ScreenSmokeTests.SampleApp app) =>
|
||
app.FindAll<ListBoxItem>().Where(i => i.IsVisible && i.DataContext is ImportSource);
|
||
|
||
/// <summary>
|
||
/// The text is shown whole: a copy with the same font, numerals and padding, measured by the same layout engine,
|
||
/// needs no more room than the layout gave the shown one (a formatted-text estimate differs by a few pixels).
|
||
/// </summary>
|
||
private static bool Fits(TextBlock text)
|
||
{
|
||
var probe = new TextBlock
|
||
{
|
||
Text = text.Text,
|
||
FontFamily = text.FontFamily,
|
||
FontSize = text.FontSize,
|
||
FontStyle = text.FontStyle,
|
||
FontWeight = text.FontWeight,
|
||
FontStretch = text.FontStretch,
|
||
FlowDirection = text.FlowDirection,
|
||
Language = text.Language,
|
||
Padding = text.Padding,
|
||
TextWrapping = text.TextWrapping,
|
||
};
|
||
System.Windows.Documents.Typography.SetNumeralAlignment(probe, System.Windows.Documents.Typography.GetNumeralAlignment(text));
|
||
TextOptions.SetTextFormattingMode(probe, TextOptions.GetTextFormattingMode(text));
|
||
if (text.TextWrapping != TextWrapping.NoWrap)
|
||
{
|
||
probe.Measure(new Size(text.ActualWidth, double.PositiveInfinity));
|
||
return probe.DesiredSize.Height <= text.ActualHeight + 0.5;
|
||
}
|
||
probe.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
|
||
return probe.DesiredSize.Width <= text.ActualWidth + 1;
|
||
}
|
||
|
||
private static double Left(ScreenSmokeTests.SampleApp app, FrameworkElement element) => element.TranslatePoint(new Point(0, 0), View(app)).X;
|
||
|
||
private static Button ButtonFor(ScreenSmokeTests.SampleApp app, ICommand command) =>
|
||
Assert.NotNull(app.FindAll<Button>().FirstOrDefault(b => ReferenceEquals(b.Command, command) && b.IsVisible), "a visible button bound to the command");
|
||
}
|