diff --git a/.gitignore b/.gitignore
index f4eb769..078e9c9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -50,6 +50,10 @@ HumanUI/HumanUI/bin/
HUI_Install/bin/
HUI_Install/obj/
HumanUIBaseApp/HumanUIBaseApp/bin/*
+HumanUI.Tests/bin/
+HumanUI.Tests/obj/
+HumanUI.Tests/diag*.log
+HumanUI.Tests/diag.host*
# NuGet Dependencies
packages/
diff --git a/HumanUI.Tests/ComponentSmokeTests.cs b/HumanUI.Tests/ComponentSmokeTests.cs
new file mode 100644
index 0000000..b745f14
--- /dev/null
+++ b/HumanUI.Tests/ComponentSmokeTests.cs
@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using Grasshopper.Kernel;
+using Xunit;
+
+namespace HumanUI.Tests
+{
+ ///
+ /// Smoke tests over every GH_Component subclass in the HumanUI assembly. These sit above
+ /// the UI toolkit, so they survive a WPF -> Eto migration: they exercise the Grasshopper
+ /// metadata layer (Name, Nickname, Category, ComponentGuid uniqueness) and instantiability.
+ ///
+ public class ComponentSmokeTests
+ {
+ private static readonly Type[] ComponentTypes = LoadComponentTypes();
+
+ private static Type[] LoadComponentTypes()
+ {
+ Assembly asm = typeof(HumanUIInfo).Assembly;
+ return asm.GetTypes()
+ .Where(t => !t.IsAbstract
+ && typeof(GH_Component).IsAssignableFrom(t)
+ && t.GetConstructor(Type.EmptyTypes) != null)
+ .ToArray();
+ }
+
+ public static IEnumerable AllComponentTypes()
+ => ComponentTypes.Select(t => new object[] { t });
+
+ [Fact]
+ public void Assembly_ExposesAtLeastOneComponent()
+ {
+ Assert.NotEmpty(ComponentTypes);
+ }
+
+ [Fact]
+ public void AssemblyInfo_IsWellFormed()
+ {
+ var info = new HumanUIInfo();
+ Assert.Equal("Human UI", info.Name);
+ Assert.False(string.IsNullOrWhiteSpace(info.Version), "Version must be set");
+ Assert.NotEqual(Guid.Empty, info.Id);
+ Assert.False(string.IsNullOrWhiteSpace(info.AuthorName));
+ }
+
+ [Theory]
+ [MemberData(nameof(AllComponentTypes))]
+ public void Component_InstantiatesViaParameterlessCtor(Type componentType)
+ {
+ object instance = Activator.CreateInstance(componentType);
+ Assert.NotNull(instance);
+ Assert.IsAssignableFrom(instance);
+ }
+
+ [Theory]
+ [MemberData(nameof(AllComponentTypes))]
+ public void Component_HasNonEmptyName(Type componentType)
+ {
+ var component = (GH_Component)Activator.CreateInstance(componentType);
+ Assert.False(string.IsNullOrWhiteSpace(component.Name),
+ $"{componentType.FullName} has an empty Name");
+ Assert.False(string.IsNullOrWhiteSpace(component.NickName),
+ $"{componentType.FullName} has an empty NickName");
+ }
+
+ [Theory]
+ [MemberData(nameof(AllComponentTypes))]
+ public void Component_LivesInHumanUiCategory(Type componentType)
+ {
+ var component = (GH_Component)Activator.CreateInstance(componentType);
+ Assert.Equal("Human UI", component.Category);
+ }
+
+ [Theory]
+ [MemberData(nameof(AllComponentTypes))]
+ public void Component_HasNonEmptyComponentGuid(Type componentType)
+ {
+ var component = (GH_Component)Activator.CreateInstance(componentType);
+ Assert.NotEqual(Guid.Empty, component.ComponentGuid);
+ }
+
+ [Fact]
+ public void ComponentGuids_AreUniqueAcrossAssembly()
+ {
+ var guidsByType = ComponentTypes
+ .Select(t => new { Type = t, Component = (GH_Component)Activator.CreateInstance(t) })
+ .Select(x => new { x.Type, x.Component.ComponentGuid })
+ .ToList();
+
+ var duplicates = guidsByType
+ .GroupBy(x => x.ComponentGuid)
+ .Where(g => g.Count() > 1)
+ .Select(g => $"{g.Key}: {string.Join(", ", g.Select(x => x.Type.FullName))}")
+ .ToList();
+
+ Assert.True(duplicates.Count == 0,
+ "Duplicate ComponentGuids:\n" + string.Join("\n", duplicates));
+ }
+ }
+}
diff --git a/HumanUI.Tests/ContractSnapshotTests.cs b/HumanUI.Tests/ContractSnapshotTests.cs
new file mode 100644
index 0000000..ddd7e0c
--- /dev/null
+++ b/HumanUI.Tests/ContractSnapshotTests.cs
@@ -0,0 +1,115 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Grasshopper.Kernel;
+using Xunit;
+
+namespace HumanUI.Tests
+{
+ ///
+ /// Snapshot-style regression test over the GH-facing public contract of every component
+ /// in the HumanUI assembly. The shape of inputs/outputs and the component GUID are what
+ /// user .gh files encode against -- any change here can silently break saved files. This
+ /// captures the contract into a checked-in JSON baseline and fails on any drift.
+ ///
+ /// To intentionally update the baseline (e.g. after adding a component), set the env var
+ /// HUMANUI_REGENERATE_SNAPSHOT=1 and run the test. It will overwrite the baseline and
+ /// report the path; review the diff in source control before committing.
+ ///
+ public class ContractSnapshotTests
+ {
+ private static readonly JsonSerializerOptions JsonOptions = new()
+ {
+ WriteIndented = true,
+ DefaultIgnoreCondition = JsonIgnoreCondition.Never,
+ };
+
+ [Fact]
+ public void Snapshot_MatchesBaseline()
+ {
+ ComponentSnapshot[] current = BuildSnapshot();
+ string actual = JsonSerializer.Serialize(current, JsonOptions);
+
+ string baselinePath = ResolveBaselinePath();
+
+ bool regenerate = Environment.GetEnvironmentVariable("HUMANUI_REGENERATE_SNAPSHOT") == "1";
+ if (regenerate || !File.Exists(baselinePath))
+ {
+ File.WriteAllText(baselinePath, actual);
+ Assert.Fail(File.Exists(baselinePath) && !regenerate
+ ? $"Baseline did not exist; wrote a fresh one at {baselinePath}. Review and commit it, then re-run."
+ : $"Baseline rewritten at {baselinePath} because HUMANUI_REGENERATE_SNAPSHOT=1. Review the diff and commit.");
+ }
+
+ string expected = File.ReadAllText(baselinePath);
+ Assert.Equal(NormalizeNewlines(expected), NormalizeNewlines(actual));
+ }
+
+ private static ComponentSnapshot[] BuildSnapshot()
+ {
+ Assembly asm = typeof(HumanUIInfo).Assembly;
+ return asm.GetTypes()
+ .Where(t => !t.IsAbstract
+ && typeof(GH_Component).IsAssignableFrom(t)
+ && t.GetConstructor(Type.EmptyTypes) != null)
+ .Select(t => (GH_Component)Activator.CreateInstance(t))
+ .Select(c => new ComponentSnapshot
+ {
+ Type = c.GetType().FullName,
+ Guid = c.ComponentGuid.ToString("D"),
+ Name = c.Name,
+ NickName = c.NickName,
+ Category = c.Category,
+ SubCategory = c.SubCategory,
+ Exposure = c.Exposure.ToString(),
+ Inputs = c.Params.Input.Select(ToParamSnapshot).ToArray(),
+ Outputs = c.Params.Output.Select(ToParamSnapshot).ToArray(),
+ })
+ .OrderBy(s => s.Guid, StringComparer.Ordinal)
+ .ToArray();
+ }
+
+ private static ParamSnapshot ToParamSnapshot(IGH_Param param) => new()
+ {
+ Type = param.GetType().FullName,
+ Name = param.Name,
+ NickName = param.NickName,
+ Description = param.Description,
+ Access = param.Access.ToString(),
+ Optional = param.Optional,
+ };
+
+ private static string ResolveBaselinePath([CallerFilePath] string thisFile = null)
+ => Path.Combine(Path.GetDirectoryName(thisFile)!, "contract-baseline.json");
+
+ private static string NormalizeNewlines(string s) => s.Replace("\r\n", "\n");
+
+ private sealed class ComponentSnapshot
+ {
+ public string Type { get; set; }
+ public string Guid { get; set; }
+ public string Name { get; set; }
+ public string NickName { get; set; }
+ public string Category { get; set; }
+ public string SubCategory { get; set; }
+ public string Exposure { get; set; }
+ public ParamSnapshot[] Inputs { get; set; }
+ public ParamSnapshot[] Outputs { get; set; }
+ }
+
+ private sealed class ParamSnapshot
+ {
+ public string Type { get; set; }
+ public string Name { get; set; }
+ public string NickName { get; set; }
+ public string Description { get; set; }
+ public string Access { get; set; }
+ public bool Optional { get; set; }
+ }
+ }
+}
diff --git a/HumanUI.Tests/HUI_UtilTests.cs b/HumanUI.Tests/HUI_UtilTests.cs
new file mode 100644
index 0000000..83972f4
--- /dev/null
+++ b/HumanUI.Tests/HUI_UtilTests.cs
@@ -0,0 +1,73 @@
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace HumanUI.Tests
+{
+ public class HUI_UtilTests
+ {
+ [Fact]
+ public void BoolsFromString_RoundTripsThroughStringFromBools()
+ {
+ // stringFromBools emits a trailing comma; after a split the final empty token
+ // gets parsed back as a (default) False. The historical format always carries
+ // that extra False, so test that the original list is a prefix of the round trip.
+ var input = new List { true, false, true, true, false };
+ string serialized = HUI_Util.stringFromBools(input);
+ List roundTripped = HUI_Util.boolsFromString(serialized);
+ Assert.Equal(input, roundTripped.Take(input.Count));
+ Assert.Equal(input.Count + 1, roundTripped.Count);
+ Assert.False(roundTripped[^1]);
+ }
+
+ [Fact]
+ public void StringFromBools_EmitsCommaSeparatedTrailingComma()
+ {
+ var input = new List { true, false, true };
+ Assert.Equal("True,False,True,", HUI_Util.stringFromBools(input));
+ }
+
+ [Fact]
+ public void StringFromBools_EmptyListReturnsEmptyString()
+ {
+ Assert.Equal(string.Empty, HUI_Util.stringFromBools(new List()));
+ }
+
+ [Fact]
+ public void BoolsFromString_UnparseableTokensBecomeFalse()
+ {
+ // Boolean.TryParse on "garbage" leaves bl=false, which is the historical behavior we want to preserve.
+ List result = HUI_Util.boolsFromString("True,garbage,False");
+ Assert.Equal(new List { true, false, false }, result);
+ }
+
+ [Fact]
+ public void StringFromStrings_JoinsWithPipe()
+ {
+ var input = new List { "alpha", "beta", "gamma" };
+ Assert.Equal("alpha|beta|gamma", HUI_Util.stringFromStrings(input));
+ }
+
+ [Fact]
+ public void StringsFromString_SplitsOnPipe()
+ {
+ List result = HUI_Util.stringsFromString("alpha|beta|gamma");
+ Assert.Equal(new List { "alpha", "beta", "gamma" }, result);
+ }
+
+ [Fact]
+ public void StringFromStrings_RoundTripsThroughStringsFromString()
+ {
+ var input = new List { "one", "two with spaces", "three" };
+ string serialized = HUI_Util.stringFromStrings(input);
+ List roundTripped = HUI_Util.stringsFromString(serialized);
+ Assert.Equal(input, roundTripped);
+ }
+
+ [Fact]
+ public void StringFromStrings_EmptyListReturnsEmptyString()
+ {
+ Assert.Equal(string.Empty, HUI_Util.stringFromStrings(new List()));
+ }
+ }
+}
diff --git a/HumanUI.Tests/HumanUI.Tests.csproj b/HumanUI.Tests/HumanUI.Tests.csproj
new file mode 100644
index 0000000..8e10938
--- /dev/null
+++ b/HumanUI.Tests/HumanUI.Tests.csproj
@@ -0,0 +1,30 @@
+
+
+
+ net7.0-windows
+ HumanUI.Tests
+ HumanUI.Tests
+ false
+ disable
+ latest
+ $(NoWarn);NU1701
+
+ False
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/HumanUI.Tests/SnapshotComparison.cs b/HumanUI.Tests/SnapshotComparison.cs
new file mode 100644
index 0000000..709c30d
--- /dev/null
+++ b/HumanUI.Tests/SnapshotComparison.cs
@@ -0,0 +1,194 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace HumanUI.Tests
+{
+ ///
+ /// Semantic diff between the branch's contract baseline and an external snapshot file
+ /// (typically produced by SnapshotTool against a master build). Compares JSON
+ /// structurally so serializer formatting differences are ignored.
+ ///
+ /// Skipped unless the HUMANUI_MASTER_SNAPSHOT env var points at a snapshot JSON file.
+ ///
+ public class SnapshotComparison
+ {
+ private readonly ITestOutputHelper _output;
+ public SnapshotComparison(ITestOutputHelper output) => _output = output;
+
+ // Components removed during the net7/MahApps 2 modernization. Each one used MahApps 1.x
+ // APIs (ThemeManager.ChangeAppTheme / ControlsHelper.SetHeaderFontSize) that no longer
+ // exist; all three are GH_Exposure.hidden so removing them is invisible in the toolbar.
+ // See commit 49dfc4e for the rationale.
+ private static readonly HashSet AcceptedRemovals = new()
+ {
+ "669ed7cd-5b59-4484-b179-4e8934ab39b3", // TabContainer_Component_ALSO_DEPRECATED
+ "aa3816cc-918e-4383-9125-8f00922f154a", // SetWindowProperties_Component_DEPRECATED
+ "b2ca4d57-1f81-4ce5-aed6-2a39fb285814", // SetWindowProperties_Component_ALSO_DEPRECATED
+ };
+
+ // Intentional contract corrections relative to master. Keyed by ComponentGuid; value is
+ // the set of property names allowed to differ.
+ private static readonly Dictionary> AcceptedFieldChanges = new()
+ {
+ // CreateGrid_Component_DEPRECATED -- category typo fix, "Human" -> "Human UI" (commit 7561ff0)
+ ["1e68a9a8-c28d-4799-854c-337dc4018917"] = new() { "Category" },
+ // CreateSlider_Component_ALSO_DEPRECATED -- same typo fix
+ ["e4f276af-46fb-478e-b10a-b95e7b04dff0"] = new() { "Category" },
+ };
+
+ [Fact]
+ public void Branch_ContractMatchesMasterSnapshot_ExceptForKnownIntentionalDiffs()
+ {
+ string testsDir = Path.GetFullPath(Path.Combine(
+ Path.GetDirectoryName(typeof(SnapshotComparison).Assembly.Location)!,
+ "..", "..", ".."));
+
+ string masterPath = Environment.GetEnvironmentVariable("HUMANUI_MASTER_SNAPSHOT");
+ if (string.IsNullOrWhiteSpace(masterPath))
+ masterPath = Path.Combine(testsDir, "master-snapshot.json");
+ Assert.True(File.Exists(masterPath), $"Master snapshot not found at {masterPath}");
+
+ string branchPath = Path.Combine(testsDir, "contract-baseline.json");
+ Assert.True(File.Exists(branchPath), $"Branch baseline not found at {branchPath}");
+
+ Dictionary master = LoadByGuid(masterPath);
+ Dictionary branch = LoadByGuid(branchPath);
+
+ var onlyInMaster = master.Keys.Except(branch.Keys).OrderBy(x => x).ToList();
+ var onlyInBranch = branch.Keys.Except(master.Keys).OrderBy(x => x).ToList();
+ var inBoth = master.Keys.Intersect(branch.Keys).OrderBy(x => x).ToList();
+
+ var unexpectedRemovals = onlyInMaster.Where(g => !AcceptedRemovals.Contains(g)).ToList();
+ var unexpectedAdditions = onlyInBranch.ToList();
+
+ _output.WriteLine($"master snapshot: {master.Count} components ({masterPath})");
+ _output.WriteLine($"branch baseline: {branch.Count} components ({branchPath})");
+ _output.WriteLine($"shared: {inBoth.Count}");
+ _output.WriteLine($"only in master: {onlyInMaster.Count}");
+ _output.WriteLine($"only in branch: {onlyInBranch.Count}");
+
+ if (onlyInMaster.Count > 0)
+ {
+ _output.WriteLine("\n=== Components in MASTER but missing from BRANCH ===");
+ foreach (string g in onlyInMaster)
+ _output.WriteLine($" {g} {master[g].GetProperty("Type").GetString()}");
+ }
+ if (onlyInBranch.Count > 0)
+ {
+ _output.WriteLine("\n=== Components in BRANCH but missing from MASTER ===");
+ foreach (string g in onlyInBranch)
+ _output.WriteLine($" {g} {branch[g].GetProperty("Type").GetString()}");
+ }
+
+ var unexpectedDiffs = new List();
+ var acceptedDiffs = new List();
+ foreach (string guid in inBoth)
+ {
+ var diffs = DiffComponent(master[guid], branch[guid]);
+ if (diffs.Count == 0) continue;
+
+ AcceptedFieldChanges.TryGetValue(guid, out var allowed);
+ allowed ??= new HashSet();
+ var unexpected = diffs.Where(d => !allowed.Contains(FieldOf(d))).ToList();
+ string typeName = branch[guid].GetProperty("Type").GetString();
+
+ if (unexpected.Count > 0)
+ {
+ unexpectedDiffs.Add($" {guid} {typeName}");
+ foreach (string d in unexpected) unexpectedDiffs.Add($" {d}");
+ }
+ else
+ {
+ acceptedDiffs.Add($" {guid} {typeName}");
+ foreach (string d in diffs) acceptedDiffs.Add($" {d} (allowlisted)");
+ }
+ }
+
+ if (acceptedDiffs.Count > 0)
+ {
+ _output.WriteLine("\n=== Allowlisted intentional contract changes ===");
+ foreach (string line in acceptedDiffs) _output.WriteLine(line);
+ }
+ if (unexpectedDiffs.Count > 0)
+ {
+ _output.WriteLine("\n=== Unexpected contract differences (regressions) ===");
+ foreach (string line in unexpectedDiffs) _output.WriteLine(line);
+ }
+
+ Assert.True(unexpectedRemovals.Count == 0,
+ $"{unexpectedRemovals.Count} component(s) present in master are missing from the branch " +
+ "and not on the AcceptedRemovals allowlist. See test output above.");
+ Assert.True(unexpectedAdditions.Count == 0,
+ $"{unexpectedAdditions.Count} component(s) added to the branch are not in master. " +
+ "Confirm the new GUID is intentional, then add it to AcceptedAdditions or extend this assertion.");
+ int unexpectedComponents = unexpectedDiffs.Count(l => !l.StartsWith(" "));
+ Assert.True(unexpectedDiffs.Count == 0,
+ $"{unexpectedComponents} component(s) drifted from master in unexpected ways. " +
+ "Either fix the drift or add the field(s) to AcceptedFieldChanges with a justification.");
+ }
+
+ private static string FieldOf(string diffLine)
+ {
+ // Lines look like "Category: master='Human' -> branch='Human UI'" or
+ // "Inputs[0].Name: master='X' -> branch='Y'" -- the field is everything before the first colon,
+ // and for params we accept on the dotted field too.
+ int colon = diffLine.IndexOf(':');
+ string head = colon > 0 ? diffLine.Substring(0, colon) : diffLine;
+ int dot = head.LastIndexOf('.');
+ return dot > 0 ? head.Substring(dot + 1) : head;
+ }
+
+ private static Dictionary LoadByGuid(string path)
+ {
+ using var doc = JsonDocument.Parse(File.ReadAllText(path));
+ var map = new Dictionary();
+ foreach (var element in doc.RootElement.EnumerateArray())
+ map[element.GetProperty("Guid").GetString()] = element.Clone();
+ return map;
+ }
+
+ private static List DiffComponent(JsonElement master, JsonElement branch)
+ {
+ var diffs = new List();
+ foreach (string prop in new[] { "Type", "Name", "NickName", "Category", "SubCategory", "Exposure" })
+ {
+ string m = master.GetProperty(prop).GetString();
+ string b = branch.GetProperty(prop).GetString();
+ if (m != b) diffs.Add($"{prop}: master='{m}' -> branch='{b}'");
+ }
+ DiffParams(master.GetProperty("Inputs"), branch.GetProperty("Inputs"), "Inputs", diffs);
+ DiffParams(master.GetProperty("Outputs"), branch.GetProperty("Outputs"), "Outputs", diffs);
+ return diffs;
+ }
+
+ private static void DiffParams(JsonElement master, JsonElement branch, string label, List diffs)
+ {
+ int mCount = master.GetArrayLength();
+ int bCount = branch.GetArrayLength();
+ if (mCount != bCount)
+ {
+ diffs.Add($"{label} count: master={mCount} -> branch={bCount}");
+ return;
+ }
+ for (int i = 0; i < mCount; i++)
+ {
+ JsonElement mp = master[i];
+ JsonElement bp = branch[i];
+ foreach (string prop in new[] { "Type", "Name", "NickName", "Description", "Access" })
+ {
+ string m = mp.GetProperty(prop).GetString();
+ string b = bp.GetProperty(prop).GetString();
+ if (m != b) diffs.Add($"{label}[{i}].{prop}: master='{m}' -> branch='{b}'");
+ }
+ bool mo = mp.GetProperty("Optional").GetBoolean();
+ bool bo = bp.GetProperty("Optional").GetBoolean();
+ if (mo != bo) diffs.Add($"{label}[{i}].Optional: master={mo} -> branch={bo}");
+ }
+ }
+ }
+}
diff --git a/HumanUI.Tests/UiIntegrationTests.cs b/HumanUI.Tests/UiIntegrationTests.cs
new file mode 100644
index 0000000..e236b00
--- /dev/null
+++ b/HumanUI.Tests/UiIntegrationTests.cs
@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows;
+using System.Windows.Media;
+using Xunit;
+
+namespace HumanUI.Tests
+{
+ ///
+ /// Live WPF tests that catch what static analysis and constructor-only smoke tests miss:
+ /// XAML pack-URI resource resolution and string-keyed Style/Brush lookups, both of which
+ /// fail at runtime when MahApps.Metro (or any other styled library) renames its resource
+ /// dictionaries between major versions.
+ ///
+ /// All tests need an STA thread plus a live WPF Application -- [StaFact]/[StaTheory] from
+ /// the Xunit.StaFact package gives us the apartment state, and EnsureApplication() spins
+ /// up the singleton on first use.
+ ///
+ public class UiIntegrationTests
+ {
+ private static Application EnsureApplication()
+ => Application.Current ?? new Application();
+
+ [StaFact]
+ public void MainWindow_ConstructsWithoutException()
+ {
+ EnsureApplication();
+ var win = new HumanUIBaseApp.MainWindow();
+ Assert.NotNull(win);
+ Assert.Equal(3, win.Resources.MergedDictionaries.Count);
+ }
+
+ [StaFact]
+ public void MainWindow_DefaultsToCenterScreen()
+ {
+ // Guards against a regression of the "appears off-screen on multi-monitor"
+ // failure mode: when WindowStartupLocation defaults to Manual the window
+ // opens at (0, 0) on the primary monitor regardless of where Rhino lives.
+ EnsureApplication();
+ var win = new HumanUIBaseApp.MainWindow();
+ Assert.Equal(WindowStartupLocation.CenterScreen, win.WindowStartupLocation);
+ }
+
+ [Fact]
+ public void ValueListener_EventedElementsIsInstanceLevel()
+ {
+ // The original code made this static, so two ValueListener components on
+ // the same canvas trampled each other's wired-element bookkeeping. Pin the
+ // instance-level layout to prevent regression.
+ var field = typeof(ValueListener_Component).GetField(
+ "eventedElements",
+ System.Reflection.BindingFlags.Instance |
+ System.Reflection.BindingFlags.NonPublic);
+ Assert.NotNull(field);
+ Assert.False(field.IsStatic, "eventedElements must not be static");
+ }
+
+ // Every MahApps pack-URI the codebase loads at runtime. If a future MahApps upgrade or
+ // an Eto migration moves any of these, the test fails with the specific URI that broke.
+ public static IEnumerable MahAppsResourceUris()
+ {
+ yield return new object[] { "pack://application:,,,/MahApps.Metro;component/Styles/Controls.xaml" };
+ yield return new object[] { "pack://application:,,,/MahApps.Metro;component/Styles/Fonts.xaml" };
+ yield return new object[] { "pack://application:,,,/MahApps.Metro;component/Styles/Themes/Light.Blue.xaml" };
+ }
+
+ [StaTheory]
+ [MemberData(nameof(MahAppsResourceUris))]
+ public void MahAppsResourceUri_LoadsAsResourceDictionary(string uri)
+ {
+ EnsureApplication();
+ var rd = new ResourceDictionary { Source = new Uri(uri, UriKind.RelativeOrAbsolute) };
+ Assert.NotEmpty(rd.Keys.Cast