Enable xunit testing in VS with the dispatcher #10023

JeremyKuhne · 2024-10-31T00:22:00Z

Enable xunit testing in VS with the dispatcher
This change enables writing and debugging unit tests in the Test Explorer in Visual Studio. I added a new test project for WindowsBase that has a unit test that launches the SplashScreen as an example.

In order to make this happen I had to reference the xunit.stafact package which introduced a number of challenges to overcome. The package has a reference to the desktop sdk and needs to be used in a project that targets net10.0-windows, not net10.0. To make everything work seamlessly I had to:

Strip the platform reference
Apply actual versions from the sdk
Get rid of AnyCPU and explictly use x86 (everything has a native dependency)
Enable transitive copying of references for the unit test projects
Target the 10.0 SDK (would get version confusion otherwise)
Add an override setting for WinForms which still targets the 9.0 SDK
Remove other targets that were trying to fixup WindowsBase references from the .NET SDK

This builds on #9914, which is included.

Microsoft Reviewers: Open in CodeFlow

eng/Versions.props

src/Microsoft.DotNet.Wpf/tests/UnitTests/WindowsBase.Tests/Resources/Needle.png

src/Microsoft.DotNet.Wpf/tests/UnitTests/WindowsBase.Tests/System/Windows/SplashScreenTests.cs

JeremyKuhne · 2024-10-31T00:39:03Z

Clearly there are some CI issues, but this does work locally. 🤷🏼 I'll be digging through that tomorrow. :)

src/Microsoft.DotNet.Wpf/src/WindowsBase/LibraryAssemblyInfo.cs

JeremyKuhne · 2024-11-01T00:19:13Z

The build machine is failing to load System.Text.Json when restoring. I can't reproduce this locally unfortunately.

Some general notes about why I updated to build against the .NET 10 SDK:

Despite installing and running the 9.0 SDK in the .dotnet folder, projects actually reference 10.0 via:

wpf/eng/Versions.props

Line 29 in 5c87aff

    
           <MicrosoftNETCoreAppRefVersion>10.0.0-alpha.1.24528.7</MicrosoftNETCoreAppRefVersion>

and

wpf/eng/WpfArcadeSdk/tools/RuntimeFrameworkReference.targets

Lines 15 to 22 in 5c87aff

    
               <FrameworkReference Update="Microsoft.NETCore.App" 
        
                                 Condition="'$(MicrosoftNETCoreAppRefVersion)'!='' 
        
                                        And '$(NoTargets)'!='true' 
        
                                        And '$(TargetFrameworkIdentifier)' == '.NETCoreApp' 
        
                                        And $([MSBuild]::VersionGreaterThanOrEquals('$(TargetFrameworkVersion)', '3.0')) 
        
                                        And '$(MSBuildProjectExtension)'!='.vcxproj'"> 
        
                 <TargetingPackVersion>$(MicrosoftNETCoreAppRefVersion)</TargetingPackVersion> 
        
               </FrameworkReference>

That means the output assemblies have a target framework of [assembly: TargetFramework(".NETCoreApp,Version=v9.0", FrameworkDisplayName = ".NET 9.0")] but all of the assembly references to the platform are 10.0.

Anything that brings in a reference with be keyed off of net9.0, but we have all 10.0 assemblies and assembly references. We can fix these up via a bit of whack-a-mole, but I'm not even sure what the runtime implications are. I'm experimenting a bit more to see if I can get all of the references implicitly pulled into the tests to be 10.0.

JeremyKuhne · 2024-11-03T00:31:18Z

@lonitra could not repro the CI failure locally either.

JeremyKuhne · 2024-11-04T23:12:59Z

The VS version on the CI machines needs to be updated to unblock this as the SDK we're trying to use has a newer version of MSBuild with an updated System.Text.Json dependency. Following up internally.

eng/WpfArcadeSdk/tools/ApiCompat.targets

eng/WpfArcadeSdk/tools/RuntimeFrameworkReference.targets

JeremyKuhne · 2024-11-10T06:40:30Z

Finally figured out how to get everything happy here. @ViktorHofer's fixes did enable me to backpedal on changing to 10.0. I struggled a bit with ARM until I figured out there was a race condition created by having the platform with multiple casings (ARM64 and arm64). 👀

eng/WpfArcadeSdk/tools/RuntimeFrameworkReference.targets

This updates SplashScreen to use direct interop built on CsWin32. It also uses the shared `System.Private.Windows.Core` library built in Windows Forms. This makes SplashScreen trim-friendly and improves the performance as it will no longer need to generate the rather extensive interop it used to at startup. This also introduces a bottom level assembly for WPF: `System.Windows.Primitives` where there are no other dependencies other than the WinForms/WPF base assembly: `System.Private.Windows.Core`. `PInvokeCore` is the static class that comes from `System.Private.Windows.Core`. `PInvoke` is the static class from `System.Windows.Primitives`. When C# adds something akin to extension types (currently in the design phase) we'll be able to unify to a single `PInvoke`. Generated types (such as `HWND`) are in the namespaces as specified by the Windows metdata and don't have the same problem with conflicts as CsWin32 won't generate types that already exist. CsWin32 uses `System.Drawing` types where they match Win32 types. `Point` is an example of this. These interchange `System.Drawing` types are in-box with .NET. `System.Private.Windows.Core` provides a lot of useful support functionality, particularly when it comes to interop. The various scope types in this PR are an example. OLE code will come from this assembly after the new APIs are merged in WinForms. I've also deleted a large swath of unused interop. It leverages dotnet#10023, which leverages dotnet#9914 (the first commit), and will be updated when those are merged. This is an update of dotnet#7929.

JeremyKuhne · 2024-11-10T19:53:24Z

The key changes in this PR:

Makes the ref projects only reference the ref projects and makes them AnyCPU
Makes all implementation projects explicitly x86, x64, and arm64 (outside of PresentationBuildTasks, which remains AnyCPU)
Strips out references to the desktop platform in the unit tests to ensure we test what we build and avoid version conflicts
Establishes the pattern for using StaFact, which enables tests that require the dispatcher (UI)

(This took a while to finalize due to other infra issues.)

This removes the `NetCoreReference` infrastructure and replaces it with `DefaultReferenceExclusion` to remove the one problematic implicit reference to WindowsBase. Manually picking references was blocking using System.Private.Windows.Core from the WinForms repo. Not having this also greatly simplifies the projects. This also tweaks the solution to add folders docs and eng items. Fixes dotnet#9168

This change enables writing and debugging unit tests in the Test Explorer in Visual Studio. I added a new test project for WindowsBase that has a unit test that launches the SplashScreen as an example. In order to make this happen I had to reference the xunit.stafact package which introduced a number of challenges to overcome. The package has a reference to the desktop sdk and needs to be used in a project that targets `net10.0-windows`, not `net10.0`. To make everything work seamlessly I had to: - Strip the platform reference - Apply actual versions from the sdk - Get rid of AnyCPU and explictly use x86 (everything has a native dependency) - Enable transitive copying of references for the unit test projects - Target the 10.0 SDK (would get version confusion otherwise) - Add an override setting for WinForms which still targets the 9.0 SDK - Remove other targets that were trying to fixup WindowsBase references from the .NET SDK -

…breaker projects to AnyCPU.

…s to be built multiple times to the same folder.

This updates SplashScreen to use direct interop built on CsWin32. It also uses the shared `System.Private.Windows.Core` library built in Windows Forms. This makes SplashScreen trim-friendly and improves the performance as it will no longer need to generate the rather extensive interop it used to at startup. This also introduces a bottom level assembly for WPF: `System.Windows.Primitives` where there are no other dependencies other than the WinForms/WPF base assembly: `System.Private.Windows.Core`. `PInvokeCore` is the static class that comes from `System.Private.Windows.Core`. `PInvoke` is the static class from `System.Windows.Primitives`. When C# adds something akin to extension types (currently in the design phase) we'll be able to unify to a single `PInvoke`. Generated types (such as `HWND`) are in the namespaces as specified by the Windows metdata and don't have the same problem with conflicts as CsWin32 won't generate types that already exist. CsWin32 uses `System.Drawing` types where they match Win32 types. `Point` is an example of this. These interchange `System.Drawing` types are in-box with .NET. `System.Private.Windows.Core` provides a lot of useful support functionality, particularly when it comes to interop. The various scope types in this PR are an example. OLE code will come from this assembly after the new APIs are merged in WinForms. I've also deleted a large swath of unused interop. It leverages dotnet#10023, which leverages dotnet#9914 (the first commit), and will be updated when those are merged. This is an update of dotnet#7929.

eng/pipeline-pr.yml

src/Microsoft.DotNet.Wpf/cycle-breakers/PresentationFramework/PresentationFramework.cs

src/Microsoft.DotNet.Wpf/src/DirectWriteForwarder/DirectWriteForwarder.vcxproj

src/Microsoft.DotNet.Wpf/tests/UnitTests/Directory.Build.targets

src/Microsoft.DotNet.Wpf/tests/UnitTests/WindowsBase.Tests/WindowsBase.Tests.csproj

eng/WpfArcadeSdk/tools/SdkReferences.targets

src/Microsoft.DotNet.Wpf/tests/Directory.Build.props

This updates SplashScreen to use direct interop built on CsWin32. It also uses the shared `System.Private.Windows.Core` library built in Windows Forms. This makes SplashScreen trim-friendly and improves the performance as it will no longer need to generate the rather extensive interop it used to at startup. This also introduces a bottom level assembly for WPF: `System.Windows.Primitives` where there are no other dependencies other than the WinForms/WPF base assembly: `System.Private.Windows.Core`. `PInvokeCore` is the static class that comes from `System.Private.Windows.Core`. `PInvoke` is the static class from `System.Windows.Primitives`. When C# adds something akin to extension types (currently in the design phase) we'll be able to unify to a single `PInvoke`. Generated types (such as `HWND`) are in the namespaces as specified by the Windows metdata and don't have the same problem with conflicts as CsWin32 won't generate types that already exist. CsWin32 uses `System.Drawing` types where they match Win32 types. `Point` is an example of this. These interchange `System.Drawing` types are in-box with .NET. `System.Private.Windows.Core` provides a lot of useful support functionality, particularly when it comes to interop. The various scope types in this PR are an example. OLE code will come from this assembly after the new APIs are merged in WinForms. I've also deleted a large swath of unused interop. It leverages dotnet#10023, which leverages dotnet#9914 (the first commit), and will be updated when those are merged. This is an update of dotnet#7929.

…t also uses the shared `System.Private.Windows.Core` library built in Windows Forms. This makes `SplashScreen` trim-friendly and improves the performance as it will no longer need to generate the rather extensive interop it used to at startup. This also introduces a bottom level assembly for WPF: `System.Windows.Primitives` where there are no other dependencies other than the WinForms/WPF base assembly: `System.Private.Windows.Core`. `PInvokeCore` is the static class that comes from `System.Private.Windows.Core`. `PInvoke` is the static class from `System.Windows.Primitives`. When C# adds something akin to extension types (currently in the design phase) we'll be able to unify to a single `PInvoke`. Generated types (such as `HWND`) are in the namespaces as specified by the Windows metdata and don't have the same problem with conflicts as CsWin32 won't generate types that already exist. CsWin32 uses `System.Drawing` types where they match Win32 types. `Point` is an example of this. These interchange `System.Drawing` types are in-box with .NET. `System.Private.Windows.Core` provides a lot of useful support functionality, particularly when it comes to interop. The various scope types in this PR are an example. OLE code will come from this assembly after the new APIs are merged in WinForms. I've also deleted a large swath of unused interop. It builds on dotnet#10023, which leverages dotnet#9914. This is an update of dotnet#7929.

* This updates `SplashScreen` to use direct interop built on CsWin32. It also uses the shared `System.Private.Windows.Core` library built in Windows Forms. This makes `SplashScreen` trim-friendly and improves the performance as it will no longer need to generate the rather extensive interop it used to at startup. This also introduces a bottom level assembly for WPF: `System.Windows.Primitives` where there are no other dependencies other than the WinForms/WPF base assembly: `System.Private.Windows.Core`. `PInvokeCore` is the static class that comes from `System.Private.Windows.Core`. `PInvoke` is the static class from `System.Windows.Primitives`. When C# adds something akin to extension types (currently in the design phase) we'll be able to unify to a single `PInvoke`. Generated types (such as `HWND`) are in the namespaces as specified by the Windows metdata and don't have the same problem with conflicts as CsWin32 won't generate types that already exist. CsWin32 uses `System.Drawing` types where they match Win32 types. `Point` is an example of this. These interchange `System.Drawing` types are in-box with .NET. `System.Private.Windows.Core` provides a lot of useful support functionality, particularly when it comes to interop. The various scope types in this PR are an example. OLE code will come from this assembly after the new APIs are merged in WinForms. I've also deleted a large swath of unused interop. It builds on #10023, which leverages #9914. This is an update of #7929. * Make anonymous method static and remove orphaned file.

JeremyKuhne requested review from a team as code owners October 31, 2024 00:22

dotnet-policy-service bot requested review from dipeshmsft and singhashish-wpf October 31, 2024 00:22

dotnet-policy-service bot assigned JeremyKuhne Oct 31, 2024

dotnet-policy-service bot added the PR metadata: Label to tag PRs, to facilitate with triage label Oct 31, 2024

JeremyKuhne commented Oct 31, 2024

View reviewed changes

eng/Versions.props Outdated Show resolved Hide resolved

JeremyKuhne commented Oct 31, 2024

View reviewed changes

eng/Versions.props Show resolved Hide resolved

JeremyKuhne commented Oct 31, 2024

View reviewed changes

src/Microsoft.DotNet.Wpf/tests/UnitTests/WindowsBase.Tests/Resources/Needle.png Outdated Show resolved Hide resolved

JeremyKuhne commented Oct 31, 2024

View reviewed changes

src/Microsoft.DotNet.Wpf/tests/UnitTests/WindowsBase.Tests/System/Windows/SplashScreenTests.cs Show resolved Hide resolved

h3xds1nz reviewed Oct 31, 2024

View reviewed changes

src/Microsoft.DotNet.Wpf/src/WindowsBase/LibraryAssemblyInfo.cs Show resolved Hide resolved

JeremyKuhne force-pushed the enabletests branch from 0d38625 to b3c090f Compare November 1, 2024 17:09

JeremyKuhne force-pushed the enabletests branch from b3c090f to 2a0fc96 Compare November 4, 2024 21:02

ViktorHofer reviewed Nov 6, 2024

View reviewed changes

eng/WpfArcadeSdk/tools/ApiCompat.targets Outdated Show resolved Hide resolved

ViktorHofer reviewed Nov 6, 2024

View reviewed changes

eng/WpfArcadeSdk/tools/RuntimeFrameworkReference.targets Outdated Show resolved Hide resolved

JeremyKuhne force-pushed the enabletests branch 2 times, most recently from 3d10c7d to 441ce34 Compare November 10, 2024 01:32

ViktorHofer reviewed Nov 10, 2024

View reviewed changes

eng/WpfArcadeSdk/tools/RuntimeFrameworkReference.targets Outdated Show resolved Hide resolved

JeremyKuhne mentioned this pull request Nov 10, 2024

Update SplashScreen to use CsWin32 and shared library #10047

Merged

JeremyKuhne added 4 commits November 10, 2024 21:37

Put back test projects in solution

ebcc5d5

Make PresentationBuildTasks always AnyCPU

9f0027d

JeremyKuhne added 11 commits November 10, 2024 21:38

Attempt to turn on the binlog for the CI

931174e

Update binlog names for both build and test run

6d15f2a

Try 17.12 preview

fedce1b

Move back off of scout image

5946b9a

Update versions

04c5a6e

Push back to 9.0

802ac96

Uncheck D3DCompiler in ConfigurationManager

693d30d

Have ref projects only reference ref projects and move ref and cycle …

20bf9ba

…breaker projects to AnyCPU.

Normalize ARM64 to arm64. Having multiple casings was causing project…

4e9f048

…s to be built multiple times to the same folder.

Revert RuntimeFrameworkReference.targets changes

486e354

Final cleanup pass

17a9cf5

JeremyKuhne force-pushed the enabletests branch from 4cf5088 to 17a9cf5 Compare November 11, 2024 05:42

Tweak SdkReferences.targets

953cc6e