From 6a2c6a4735bcec975ff94ea016ea44f7d592b918 Mon Sep 17 00:00:00 2001 From: Jeremy Koritzinsky Date: Thu, 16 May 2019 17:40:23 -0700 Subject: [PATCH] Add Managed->Native tests for our WinRT primitives (#23529) * First pass generating the contracts for the WinRT tests. Managed ones are manually written, Native are generated via C++/WinRT. * Don't overwrite the public implementation files when we run cppwinrt * Don't output a MIDL-processed header. * Add default constructor for BindingViewModel. * Partial implementation of most of the native winrt component. * Finish implementation of native winrt component. * Get native component building correctly (cppwinrt doesn't include wrappers for the "Windows::UI::Xaml::Interop::IBindable*" collection types. * Add WinRT primitive marshalling tests. * Add testing for projected types used for binding. * Add license headers to native files. * Disable WinRT tests on non-WinRT platforms (detection copied from CoreFX). * Use WINDOWS_SDK_VERSION variable in all locations. * Use Windows SDK version determined by CMake in WinRT build. * Resolve WinMDs via globs so the build can roll between different Windows SDK versions that have required APIs seamlessly. * Add logging of cppwinrt version. * Try to construct path to cppwinrt when finding it * Just directly construct the cppwinrt path. * Remove -prefix flag from cppwinrt invocation * PR feedback. * Fix syntax in BindableVectorWrapper. * Disable winrt binding test on Nano Server. * Add enum testing. Clean up WinRT tests to hopefully build on CI (or at least fail at a later point). * Add some more logging to try to determine why an older SDK version is being picked. * Try to define CMAKE_SYSTEM_VERSION and see if that selects the correct SDK version (it seems to work on the build.cmd script) * Clean up WinRT CMake now that it builds on AzDO CI. * Disable WinRT binding test on pre-Win10V1809 systems. --- build-test.cmd | 3 +- tests/src/Common/CoreCLRTestLibrary/Assertion.cs | 10 ++ tests/src/Common/CoreCLRTestLibrary/Utilities.cs | 75 ++++++++++ tests/src/Interop/CMakeLists.txt | 1 + .../Interop/WinRT/Contracts/Component.Contracts.cs | 118 +++++++++++++++ .../WinRT/Contracts/Component.Contracts.idl | 104 +++++++++++++ .../src/Interop/WinRT/Contracts/NativeComponent.cs | 16 ++ .../Contracts/WindowsRuntimeImportAttribute.cs | 13 ++ .../WinRT/NETClients/Bindings/BindingTests.cs | 58 ++++++++ .../NETClients/Bindings/NETClientBindings.csproj | 33 +++++ .../Interop/WinRT/NETClients/Bindings/Program.cs | 31 ++++ .../WinRT/NETClients/Primitives/ArrayTests.cs | 34 +++++ .../WinRT/NETClients/Primitives/BooleanTests.cs | 17 +++ .../WinRT/NETClients/Primitives/EnumTests.cs | 17 +++ .../WinRT/NETClients/Primitives/ExceptionTests.cs | 22 +++ .../NETClients/Primitives/KeyValuePairTests.cs | 34 +++++ .../Primitives/NETClientPrimitives.csproj | 41 ++++++ .../WinRT/NETClients/Primitives/NullableTests.cs | 18 +++ .../Interop/WinRT/NETClients/Primitives/Program.cs | 38 +++++ .../WinRT/NETClients/Primitives/StringTests.cs | 18 +++ .../WinRT/NETClients/Primitives/TypeTests.cs | 25 ++++ .../WinRT/NETClients/Primitives/UriTests.cs | 19 +++ .../Interop/WinRT/NativeComponent/CMakeLists.txt | 116 +++++++++++++++ .../Component.Contracts.ArrayTesting.cpp | 19 +++ .../Component.Contracts.ArrayTesting.h | 24 +++ ...mponent.Contracts.BindingProjectionsTesting.cpp | 20 +++ ...Component.Contracts.BindingProjectionsTesting.h | 25 ++++ .../Component.Contracts.BindingViewModel.cpp | 40 +++++ .../Component.Contracts.BindingViewModel.h | 161 +++++++++++++++++++++ .../Component.Contracts.BooleanTesting.cpp | 13 ++ .../Component.Contracts.BooleanTesting.h | 23 +++ .../Component.Contracts.EnumTesting.cpp | 15 ++ .../Component.Contracts.EnumTesting.h | 21 +++ .../Component.Contracts.ExceptionTesting.cpp | 18 +++ .../Component.Contracts.ExceptionTesting.h | 24 +++ .../Component.Contracts.KeyValuePairTesting.cpp | 48 ++++++ .../Component.Contracts.KeyValuePairTesting.h | 25 ++++ .../Component.Contracts.NullableTesting.cpp | 18 +++ .../Component.Contracts.NullableTesting.h | 24 +++ .../Component.Contracts.StringTesting.cpp | 13 ++ .../Component.Contracts.StringTesting.h | 23 +++ .../Component.Contracts.TypeTesting.cpp | 13 ++ .../Component.Contracts.TypeTesting.h | 23 +++ .../Component.Contracts.UriTesting.cpp | 18 +++ .../Component.Contracts.UriTesting.h | 24 +++ .../src/Interop/WinRT/NativeComponent/Exports.def | 3 + tests/src/Interop/WinRT/NativeComponent/pch.h | 10 ++ 47 files changed, 1505 insertions(+), 1 deletion(-) create mode 100644 tests/src/Interop/WinRT/Contracts/Component.Contracts.cs create mode 100644 tests/src/Interop/WinRT/Contracts/Component.Contracts.idl create mode 100644 tests/src/Interop/WinRT/Contracts/NativeComponent.cs create mode 100644 tests/src/Interop/WinRT/Contracts/WindowsRuntimeImportAttribute.cs create mode 100644 tests/src/Interop/WinRT/NETClients/Bindings/BindingTests.cs create mode 100644 tests/src/Interop/WinRT/NETClients/Bindings/NETClientBindings.csproj create mode 100644 tests/src/Interop/WinRT/NETClients/Bindings/Program.cs create mode 100644 tests/src/Interop/WinRT/NETClients/Primitives/ArrayTests.cs create mode 100644 tests/src/Interop/WinRT/NETClients/Primitives/BooleanTests.cs create mode 100644 tests/src/Interop/WinRT/NETClients/Primitives/EnumTests.cs create mode 100644 tests/src/Interop/WinRT/NETClients/Primitives/ExceptionTests.cs create mode 100644 tests/src/Interop/WinRT/NETClients/Primitives/KeyValuePairTests.cs create mode 100644 tests/src/Interop/WinRT/NETClients/Primitives/NETClientPrimitives.csproj create mode 100644 tests/src/Interop/WinRT/NETClients/Primitives/NullableTests.cs create mode 100644 tests/src/Interop/WinRT/NETClients/Primitives/Program.cs create mode 100644 tests/src/Interop/WinRT/NETClients/Primitives/StringTests.cs create mode 100644 tests/src/Interop/WinRT/NETClients/Primitives/TypeTests.cs create mode 100644 tests/src/Interop/WinRT/NETClients/Primitives/UriTests.cs create mode 100644 tests/src/Interop/WinRT/NativeComponent/CMakeLists.txt create mode 100644 tests/src/Interop/WinRT/NativeComponent/Component.Contracts.ArrayTesting.cpp create mode 100644 tests/src/Interop/WinRT/NativeComponent/Component.Contracts.ArrayTesting.h create mode 100644 tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BindingProjectionsTesting.cpp create mode 100644 tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BindingProjectionsTesting.h create mode 100644 tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BindingViewModel.cpp create mode 100644 tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BindingViewModel.h create mode 100644 tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BooleanTesting.cpp create mode 100644 tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BooleanTesting.h create mode 100644 tests/src/Interop/WinRT/NativeComponent/Component.Contracts.EnumTesting.cpp create mode 100644 tests/src/Interop/WinRT/NativeComponent/Component.Contracts.EnumTesting.h create mode 100644 tests/src/Interop/WinRT/NativeComponent/Component.Contracts.ExceptionTesting.cpp create mode 100644 tests/src/Interop/WinRT/NativeComponent/Component.Contracts.ExceptionTesting.h create mode 100644 tests/src/Interop/WinRT/NativeComponent/Component.Contracts.KeyValuePairTesting.cpp create mode 100644 tests/src/Interop/WinRT/NativeComponent/Component.Contracts.KeyValuePairTesting.h create mode 100644 tests/src/Interop/WinRT/NativeComponent/Component.Contracts.NullableTesting.cpp create mode 100644 tests/src/Interop/WinRT/NativeComponent/Component.Contracts.NullableTesting.h create mode 100644 tests/src/Interop/WinRT/NativeComponent/Component.Contracts.StringTesting.cpp create mode 100644 tests/src/Interop/WinRT/NativeComponent/Component.Contracts.StringTesting.h create mode 100644 tests/src/Interop/WinRT/NativeComponent/Component.Contracts.TypeTesting.cpp create mode 100644 tests/src/Interop/WinRT/NativeComponent/Component.Contracts.TypeTesting.h create mode 100644 tests/src/Interop/WinRT/NativeComponent/Component.Contracts.UriTesting.cpp create mode 100644 tests/src/Interop/WinRT/NativeComponent/Component.Contracts.UriTesting.h create mode 100644 tests/src/Interop/WinRT/NativeComponent/Exports.def create mode 100644 tests/src/Interop/WinRT/NativeComponent/pch.h diff --git a/build-test.cmd b/build-test.cmd index 85af0d2..e1400c4 100644 --- a/build-test.cmd +++ b/build-test.cmd @@ -206,7 +206,8 @@ if not defined VSINSTALLDIR ( if not exist "%VSINSTALLDIR%DIA SDK" goto NoDIA pushd "%__NativeTestIntermediatesDir%" -call "%__SourceDir%\pal\tools\gen-buildsys-win.bat" ""%__ProjectFilesDir%"" %__VSVersion% %__BuildArch% +set __ExtraCmakeArgs="-DCMAKE_SYSTEM_VERSION=10.0" +call "%__SourceDir%\pal\tools\gen-buildsys-win.bat" ""%__ProjectFilesDir%"" %__VSVersion% %__BuildArch% !__ExtraCmakeArgs! @if defined _echo @echo on popd diff --git a/tests/src/Common/CoreCLRTestLibrary/Assertion.cs b/tests/src/Common/CoreCLRTestLibrary/Assertion.cs index e4f785a..275b308 100644 --- a/tests/src/Common/CoreCLRTestLibrary/Assertion.cs +++ b/tests/src/Common/CoreCLRTestLibrary/Assertion.cs @@ -685,6 +685,16 @@ namespace TestLibrary } } + static public void OfType(object obj) + { + if (!(obj is T)) + { + Assert.HandleFail( + "Assert.IsOfType", + $"Expected an object of type [{typeof(T).AssemblyQualifiedName}], got type of type [{obj.GetType().AssemblyQualifiedName}]."); + } + } + /// /// Throws an AssertFailedException. /// diff --git a/tests/src/Common/CoreCLRTestLibrary/Utilities.cs b/tests/src/Common/CoreCLRTestLibrary/Utilities.cs index 41e0e29..470ff87 100644 --- a/tests/src/Common/CoreCLRTestLibrary/Utilities.cs +++ b/tests/src/Common/CoreCLRTestLibrary/Utilities.cs @@ -67,7 +67,12 @@ namespace TestLibrary public static bool IsLinux => RuntimeInformation.IsOSPlatform(OSPlatform.Linux); public static bool IsMacOSX => RuntimeInformation.IsOSPlatform(OSPlatform.OSX); public static bool IsWindows7 => IsWindows && Environment.OSVersion.Version.Major == 6 && Environment.OSVersion.Version.Minor == 1; + public static bool IsWinRTSupported => IsWindows && !IsWindows7; public static bool IsWindowsNanoServer => (!IsWindowsIoTCore && GetInstallationType().Equals("Nano Server", StringComparison.OrdinalIgnoreCase)); + + // Windows 10 October 2018 Update + public static bool IsWindows10Version1809OrGreater => + IsWindows && GetWindowsVersion() == 10 && GetWindowsMinorVersion() == 0 && GetWindowsBuildNumber() >= 17763; public static bool IsWindowsIoTCore { get @@ -193,6 +198,37 @@ namespace TestLibrary } } + internal static uint GetWindowsVersion() + { + if (!IsWindows) + { + return 0; + } + + Assert.AreEqual(0, Ntdll.RtlGetVersionEx(out Ntdll.RTL_OSVERSIONINFOEX osvi)); + return osvi.dwMajorVersion; + } + internal static uint GetWindowsMinorVersion() + { + if (!IsWindows) + { + return 0; + } + + Assert.AreEqual(0, Ntdll.RtlGetVersionEx(out Ntdll.RTL_OSVERSIONINFOEX osvi)); + return osvi.dwMinorVersion; + } + internal static uint GetWindowsBuildNumber() + { + if (!IsWindows) + { + return 0; + } + + Assert.AreEqual(0, Ntdll.RtlGetVersionEx(out Ntdll.RTL_OSVERSIONINFOEX osvi)); + return osvi.dwBuildNumber; + } + [MethodImpl(MethodImplOptions.NoInlining)] private static string GetRegistryValueString(string key, string value) { @@ -231,6 +267,45 @@ namespace TestLibrary return stringValue; } + private static class Ntdll + { + [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)] + internal unsafe struct RTL_OSVERSIONINFOEX + { + internal uint dwOSVersionInfoSize; + internal uint dwMajorVersion; + internal uint dwMinorVersion; + internal uint dwBuildNumber; + internal uint dwPlatformId; + internal fixed char szCSDVersion[128]; + } + + [DllImport(nameof(Ntdll), ExactSpelling=true)] + private static extern int RtlGetVersion(ref RTL_OSVERSIONINFOEX lpVersionInformation); + + internal static unsafe int RtlGetVersionEx(out RTL_OSVERSIONINFOEX osvi) + { + osvi = new RTL_OSVERSIONINFOEX(); + osvi.dwOSVersionInfoSize = (uint)sizeof(RTL_OSVERSIONINFOEX); + return RtlGetVersion(ref osvi); + } + + internal static unsafe string RtlGetVersion() + { + const string Version = "Microsoft Windows"; + if (RtlGetVersionEx(out RTL_OSVERSIONINFOEX osvi) == 0) + { + return osvi.szCSDVersion[0] != '\0' ? + string.Format("{0} {1}.{2}.{3} {4}", Version, osvi.dwMajorVersion, osvi.dwMinorVersion, osvi.dwBuildNumber, new string(&(osvi.szCSDVersion[0]))) : + string.Format("{0} {1}.{2}.{3}", Version, osvi.dwMajorVersion, osvi.dwMinorVersion, osvi.dwBuildNumber); + } + else + { + return Version; + } + } + } + private sealed class Kernel32 { public const int PRODUCT_UNDEFINED = 0; diff --git a/tests/src/Interop/CMakeLists.txt b/tests/src/Interop/CMakeLists.txt index 26a09be..aa19c68 100644 --- a/tests/src/Interop/CMakeLists.txt +++ b/tests/src/Interop/CMakeLists.txt @@ -83,6 +83,7 @@ if(WIN32) add_subdirectory(COM/NativeClients/Primitives) add_subdirectory(COM/NativeClients/Licensing) add_subdirectory(COM/NativeClients/DefaultInterfaces) + add_subdirectory(WinRT/NativeComponent) # IJW isn't supported on ARM64 if(NOT CLR_CMAKE_PLATFORM_ARCH_ARM64) diff --git a/tests/src/Interop/WinRT/Contracts/Component.Contracts.cs b/tests/src/Interop/WinRT/Contracts/Component.Contracts.cs new file mode 100644 index 0000000..068bbd7 --- /dev/null +++ b/tests/src/Interop/WinRT/Contracts/Component.Contracts.cs @@ -0,0 +1,118 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Collections.Generic; +using System.Collections.Specialized; +using System.ComponentModel; +using System.Runtime.InteropServices; +using System.Runtime.InteropServices.WindowsRuntime; + +namespace Component.Contracts +{ + [ComImport] + [Guid("971AF13A-9793-4AF7-B2F2-72D829195592")] + [WindowsRuntimeImport] + public interface IBooleanTesting + { + bool And(bool left, bool right); + } + + [ComImport] + [Guid("C6F1F632-47B6-4A52-86D2-A89807ED2677")] + [WindowsRuntimeImport] + public interface IStringTesting + { + string ConcatStrings(string left, string right); + } + + [ComImport] + [Guid("939D4EE5-8D41-4C4B-8948-86017CEB9244")] + [WindowsRuntimeImport] + public interface INullableTesting + { + bool IsNull(int? value); + int GetIntValue(int? value); + } + + [ComImport] + [Guid("BB545A14-9AE7-491A-874D-1C03D239FB70")] + [WindowsRuntimeImport] + public interface ITypeTesting + { + string GetTypeName(Type type); + } + + [ComImport] + [Guid("9162201d-b591-4f30-8f41-f0f79f6ecea3")] + [WindowsRuntimeImport] + public interface IExceptionTesting + { + void ThrowException(Exception ex); + Exception GetException(int hResultToReturn); + } + + [ComImport] + [Guid("ccd10099-3a45-4382-970d-b76f52780bcd")] + [WindowsRuntimeImport] + public interface IKeyValuePairTesting + { + KeyValuePair MakeSimplePair(int key, int value); + KeyValuePair MakeMarshaledPair(string key, string value); + KeyValuePair> MakeProjectedPair(int key, int[] values); + } + + [ComImport] + [Guid("e0af24b3-e6c6-4e89-b8d1-a332979ef398")] + [WindowsRuntimeImport] + public interface IUriTesting + { + string GetFromUri(Uri uri); + Uri CreateUriFromString(string uri); + } + + [ComImport] + [Guid("821B532D-CC5E-4218-90AB-A8361AC92794")] + [WindowsRuntimeImport] + public interface IArrayTesting + { + int Sum(int[] array); + bool Xor(bool[] array); + } + + [ComImport] + [Guid("4bb923ae-986a-4aad-9bfb-13e0b5ecffa4")] + [WindowsRuntimeImport] + public interface IBindingViewModel + { + INotifyCollectionChanged Collection { get; } + void AddElement(int i); + string Name { get; set; } + } + + [ComImport] + [Guid("857e28e1-3e7f-4f6f-8554-efc73feba286")] + [WindowsRuntimeImport] + public interface IBindingProjectionsTesting + { + IBindingViewModel CreateViewModel(); + IDisposable InitializeXamlFrameworkForCurrentThread(); + } + + public enum TestEnum + { + A = 1, + B = 2, + C = 3 + } + + [ComImport] + [Guid("d89d71b2-2671-444d-8576-536d206dea49")] + [WindowsRuntimeImport] + public interface IEnumTesting + { + TestEnum GetA(); + Boolean IsB(TestEnum val); + } +} diff --git a/tests/src/Interop/WinRT/Contracts/Component.Contracts.idl b/tests/src/Interop/WinRT/Contracts/Component.Contracts.idl new file mode 100644 index 0000000..9126829 --- /dev/null +++ b/tests/src/Interop/WinRT/Contracts/Component.Contracts.idl @@ -0,0 +1,104 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +namespace Component.Contracts +{ + [interface_name("Component.Contracts.IBooleanTesting", 971AF13A-9793-4AF7-B2F2-72D829195592)] + runtimeclass BooleanTesting + { + BooleanTesting(); + Boolean And(Boolean left, Boolean right); + } + + [interface_name("Component.Contracts.IStringTesting", C6F1F632-47B6-4A52-86D2-A89807ED2677)] + runtimeclass StringTesting + { + StringTesting(); + String ConcatStrings(String left, String right); + } + + [interface_name("Component.Contracts.INullableTesting", 939D4EE5-8D41-4C4B-8948-86017CEB9244)] + runtimeclass NullableTesting + { + NullableTesting(); + Boolean IsNull(Windows.Foundation.IReference value); + Int32 GetIntValue(Windows.Foundation.IReference value); + } + + [interface_name("Component.Contracts.ITypeTesting", BB545A14-9AE7-491A-874D-1C03D239FB70)] + runtimeclass TypeTesting + { + TypeTesting(); + String GetTypeName(Windows.UI.Xaml.Interop.TypeName typeName); + } + + [interface_name("Component.Contracts.IExceptionTesting", 9162201d-b591-4f30-8f41-f0f79f6ecea3)] + runtimeclass ExceptionTesting + { + ExceptionTesting(); + void ThrowException(Windows.Foundation.HResult hr); + Windows.Foundation.HResult GetException(Int32 hr); + } + + [interface_name("Component.Contracts.IKeyValuePairTesting", ccd10099-3a45-4382-970d-b76f52780bcd)] + runtimeclass KeyValuePairTesting + { + KeyValuePairTesting(); + Windows.Foundation.Collections.IKeyValuePair MakeSimplePair(Int32 key, Int32 value); + Windows.Foundation.Collections.IKeyValuePair MakeMarshaledPair(String key, String value); + Windows.Foundation.Collections.IKeyValuePair > MakeProjectedPair(Int32 key, Int32[] values); + } + + [interface_name("Component.Contracts.IUriTesting", e0af24b3-e6c6-4e89-b8d1-a332979ef398)] + runtimeclass UriTesting + { + UriTesting(); + String GetFromUri(Windows.Foundation.Uri uri); + Windows.Foundation.Uri CreateUriFromString(String uri); + } + + [interface_name("Component.Contracts.IArrayTesting", 821B532D-CC5E-4218-90AB-A8361AC92794)] + runtimeclass ArrayTesting + { + ArrayTesting(); + Int32 Sum(Int32[] array); + Boolean Xor(Boolean[] array); + } + + [uuid(4bb923ae-986a-4aad-9bfb-13e0b5ecffa4)] + interface IBindingViewModel + { + Windows.UI.Xaml.Interop.INotifyCollectionChanged Collection { get; }; + void AddElement(Int32 i); + String Name { get; set; }; + } + + runtimeclass BindingViewModel : [default] IBindingViewModel, Windows.UI.Xaml.Data.INotifyPropertyChanged + { + BindingViewModel(); + } + + [interface_name("Component.Contracts.IBindingProjectionsTesting", 857e28e1-3e7f-4f6f-8554-efc73feba286)] + runtimeclass BindingProjectionsTesting + { + BindingProjectionsTesting(); + IBindingViewModel CreateViewModel(); + Windows.Foundation.IClosable InitializeXamlFrameworkForCurrentThread(); + } + + enum TestEnum + { + A = 1, + B = 2, + C = 3 + }; + + [interface_name("Component.Contracts.IEnumTesting", d89d71b2-2671-444d-8576-536d206dea49)] + runtimeclass EnumTesting + { + EnumTesting(); + TestEnum GetA(); + Boolean IsB(TestEnum val); + } +} diff --git a/tests/src/Interop/WinRT/Contracts/NativeComponent.cs b/tests/src/Interop/WinRT/Contracts/NativeComponent.cs new file mode 100644 index 0000000..0b4903e --- /dev/null +++ b/tests/src/Interop/WinRT/Contracts/NativeComponent.cs @@ -0,0 +1,16 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation 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 System.Runtime.InteropServices.WindowsRuntime; + +public static class WinRTNativeComponent +{ + [DllImport(nameof(WinRTNativeComponent), PreserveSig = false)] + private static extern IActivationFactory DllGetActivationFactory([MarshalAs(UnmanagedType.HString)] string typeName); + + public static object GetObjectFromNativeComponent(string typeName) + { + return DllGetActivationFactory(typeName).ActivateInstance(); + } +} diff --git a/tests/src/Interop/WinRT/Contracts/WindowsRuntimeImportAttribute.cs b/tests/src/Interop/WinRT/Contracts/WindowsRuntimeImportAttribute.cs new file mode 100644 index 0000000..4118488 --- /dev/null +++ b/tests/src/Interop/WinRT/Contracts/WindowsRuntimeImportAttribute.cs @@ -0,0 +1,13 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +namespace System.Runtime.InteropServices.WindowsRuntime +{ + // Types decorated with this attribute are treated specially by the compiler. A "windowsruntime" bit is set in their metadata. + [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Enum | AttributeTargets.Struct | AttributeTargets.Delegate, Inherited = false)] + internal sealed class WindowsRuntimeImportAttribute : Attribute + { + public WindowsRuntimeImportAttribute() { } + } +} diff --git a/tests/src/Interop/WinRT/NETClients/Bindings/BindingTests.cs b/tests/src/Interop/WinRT/NETClients/Bindings/BindingTests.cs new file mode 100644 index 0000000..da88636 --- /dev/null +++ b/tests/src/Interop/WinRT/NETClients/Bindings/BindingTests.cs @@ -0,0 +1,58 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +using System; +using System.Collections.Specialized; +using System.ComponentModel; +using System.Linq; +using TestLibrary; +using Component.Contracts; + +namespace NetClient +{ + public class BindingTests + { + public static void RunTest() + { + IBindingProjectionsTesting target = (IBindingProjectionsTesting)WinRTNativeComponent.GetObjectFromNativeComponent("Component.Contracts.BindingProjectionsTesting"); + using (target.InitializeXamlFrameworkForCurrentThread()) + { + IBindingViewModel vm = target.CreateViewModel(); + RunINotifyPropertyChangedTest(vm); + RunINotifyCollectionChangedTest(vm); + } + } + + private static void RunINotifyPropertyChangedTest(IBindingViewModel viewModel) + { + bool propertyChangedEventFired = false; + INotifyPropertyChanged notifyPropertyChanged = (INotifyPropertyChanged)viewModel; + PropertyChangedEventHandler handler = (o, e) => propertyChangedEventFired = (e.PropertyName == nameof(viewModel.Name)); + notifyPropertyChanged.PropertyChanged += handler; + viewModel.Name = "New Name"; + Assert.IsTrue(propertyChangedEventFired); + notifyPropertyChanged.PropertyChanged -= handler; + propertyChangedEventFired = false; + viewModel.Name = "Old Name"; + Assert.IsFalse(propertyChangedEventFired); + } + + private static void RunINotifyCollectionChangedTest(IBindingViewModel viewModel) + { + bool notifyCollectionChangedEventFired = false; + int addedElement = 42; + viewModel.Collection.CollectionChanged += (o, e) => + { + notifyCollectionChangedEventFired = + e.Action == NotifyCollectionChangedAction.Add + && e.NewItems.Count == 1 + && e.NewItems[0] is int i + && i == addedElement; + }; + + viewModel.AddElement(addedElement); + + Assert.IsTrue(notifyCollectionChangedEventFired); + } + } +} diff --git a/tests/src/Interop/WinRT/NETClients/Bindings/NETClientBindings.csproj b/tests/src/Interop/WinRT/NETClients/Bindings/NETClientBindings.csproj new file mode 100644 index 0000000..7bc62dc --- /dev/null +++ b/tests/src/Interop/WinRT/NETClients/Bindings/NETClientBindings.csproj @@ -0,0 +1,33 @@ + + + + + Debug + AnyCPU + NETClientBindings + 2.0 + {85C57688-DA98-4DE3-AC9B-526E4747434C} + Exe + {209912F9-0DA1-4184-9CC1-8D583BAF4A28};{87799F5D-CEBD-499D-BDBA-B2C6105CD766} + + true + true + + + + + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/WinRT/NETClients/Bindings/Program.cs b/tests/src/Interop/WinRT/NETClients/Bindings/Program.cs new file mode 100644 index 0000000..75bb46a --- /dev/null +++ b/tests/src/Interop/WinRT/NETClients/Bindings/Program.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +namespace NetClient +{ + using System; + + class Program + { + static int Main(string[] args) + { + if (!TestLibrary.Utilities.IsWinRTSupported || TestLibrary.Utilities.IsWindowsNanoServer || !TestLibrary.Utilities.IsWindows10Version1809OrGreater) + { + Console.WriteLine("XAML Islands are unsupported on this platform."); + return 100; + } + + try + { + BindingTests.RunTest(); + } + catch (System.Exception ex) + { + Console.WriteLine(ex); + return 101; + } + return 100; + } + } +} diff --git a/tests/src/Interop/WinRT/NETClients/Primitives/ArrayTests.cs b/tests/src/Interop/WinRT/NETClients/Primitives/ArrayTests.cs new file mode 100644 index 0000000..a4f24c2 --- /dev/null +++ b/tests/src/Interop/WinRT/NETClients/Primitives/ArrayTests.cs @@ -0,0 +1,34 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +using System; +using System.Linq; +using TestLibrary; + +namespace NetClient +{ + public class ArrayTests + { + public static void RunTest() + { + Component.Contracts.IArrayTesting target = (Component.Contracts.IArrayTesting)WinRTNativeComponent.GetObjectFromNativeComponent("Component.Contracts.ArrayTesting"); + TestIntArray(target); + TestBoolArray(target); + } + + private static void TestIntArray(Component.Contracts.IArrayTesting target) + { + int[] array = Enumerable.Range(1, 30).ToArray(); + Assert.AreEqual(array.Sum(), target.Sum(array)); + + } + + private static void TestBoolArray(Component.Contracts.IArrayTesting target) + { + bool[] array = new []{ true, false, true, true, true, false, false}; + bool expected = array.Aggregate(false, (left, right) => left ^ right); + + Assert.AreEqual(expected, target.Xor(array)); + } + } +} diff --git a/tests/src/Interop/WinRT/NETClients/Primitives/BooleanTests.cs b/tests/src/Interop/WinRT/NETClients/Primitives/BooleanTests.cs new file mode 100644 index 0000000..479161e --- /dev/null +++ b/tests/src/Interop/WinRT/NETClients/Primitives/BooleanTests.cs @@ -0,0 +1,17 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +using TestLibrary; + +namespace NetClient +{ + public class BooleanTests + { + public static void RunTest() + { + Component.Contracts.IBooleanTesting target = (Component.Contracts.IBooleanTesting)WinRTNativeComponent.GetObjectFromNativeComponent("Component.Contracts.BooleanTesting"); + Assert.IsTrue(target.And(true, true)); + Assert.IsFalse(target.And(false, true)); + } + } +} diff --git a/tests/src/Interop/WinRT/NETClients/Primitives/EnumTests.cs b/tests/src/Interop/WinRT/NETClients/Primitives/EnumTests.cs new file mode 100644 index 0000000..3830405 --- /dev/null +++ b/tests/src/Interop/WinRT/NETClients/Primitives/EnumTests.cs @@ -0,0 +1,17 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +using TestLibrary; + +namespace NetClient +{ + public class EnumTests + { + public static void RunTest() + { + Component.Contracts.IEnumTesting target = (Component.Contracts.IEnumTesting)WinRTNativeComponent.GetObjectFromNativeComponent("Component.Contracts.EnumTesting"); + Assert.AreEqual(Component.Contracts.TestEnum.A, target.GetA()); + Assert.IsTrue(target.IsB(Component.Contracts.TestEnum.B)); + } + } +} diff --git a/tests/src/Interop/WinRT/NETClients/Primitives/ExceptionTests.cs b/tests/src/Interop/WinRT/NETClients/Primitives/ExceptionTests.cs new file mode 100644 index 0000000..a26b81f --- /dev/null +++ b/tests/src/Interop/WinRT/NETClients/Primitives/ExceptionTests.cs @@ -0,0 +1,22 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +using System; +using TestLibrary; + +namespace NetClient +{ + public class ExceptionTests + { + public static void RunTest() + { + Component.Contracts.IExceptionTesting target = (Component.Contracts.IExceptionTesting)WinRTNativeComponent.GetObjectFromNativeComponent("Component.Contracts.ExceptionTesting"); + + Assert.Throws(() => target.ThrowException(new InvalidOperationException())); + + Assert.OfType(target.GetException(new ArgumentOutOfRangeException().HResult)); + Assert.OfType(target.GetException(new ArgumentNullException().HResult)); + Assert.OfType(target.GetException(new NullReferenceException().HResult)); + } + } +} diff --git a/tests/src/Interop/WinRT/NETClients/Primitives/KeyValuePairTests.cs b/tests/src/Interop/WinRT/NETClients/Primitives/KeyValuePairTests.cs new file mode 100644 index 0000000..622771b --- /dev/null +++ b/tests/src/Interop/WinRT/NETClients/Primitives/KeyValuePairTests.cs @@ -0,0 +1,34 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +using System.Collections.Generic; +using TestLibrary; + +namespace NetClient +{ + public class KeyValuePairTests + { + public static void RunTest() + { + Component.Contracts.IKeyValuePairTesting target = (Component.Contracts.IKeyValuePairTesting)WinRTNativeComponent.GetObjectFromNativeComponent("Component.Contracts.KeyValuePairTesting"); + TestSimplePair(target); + TestMarshaledPair(target); + } + + private static void TestSimplePair(Component.Contracts.IKeyValuePairTesting target) + { + int key = 5; + int value = 27; + + Assert.AreEqual(new KeyValuePair(key, value), target.MakeSimplePair(key, value)); + } + + private static void TestMarshaledPair(Component.Contracts.IKeyValuePairTesting target) + { + string key = "Key"; + string value = "Value"; + + Assert.AreEqual(new KeyValuePair(key, value), target.MakeMarshaledPair(key, value)); + } + } +} diff --git a/tests/src/Interop/WinRT/NETClients/Primitives/NETClientPrimitives.csproj b/tests/src/Interop/WinRT/NETClients/Primitives/NETClientPrimitives.csproj new file mode 100644 index 0000000..990f513 --- /dev/null +++ b/tests/src/Interop/WinRT/NETClients/Primitives/NETClientPrimitives.csproj @@ -0,0 +1,41 @@ + + + + + Debug + AnyCPU + NETClientPrimitives + 2.0 + {85C57688-DA98-4DE3-AC9B-526E4747434C} + Exe + {209912F9-0DA1-4184-9CC1-8D583BAF4A28};{87799F5D-CEBD-499D-BDBA-B2C6105CD766} + + true + true + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/WinRT/NETClients/Primitives/NullableTests.cs b/tests/src/Interop/WinRT/NETClients/Primitives/NullableTests.cs new file mode 100644 index 0000000..ed450c2 --- /dev/null +++ b/tests/src/Interop/WinRT/NETClients/Primitives/NullableTests.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +using TestLibrary; + +namespace NetClient +{ + public class NullableTests + { + public static void RunTest() + { + Component.Contracts.INullableTesting target = (Component.Contracts.INullableTesting)WinRTNativeComponent.GetObjectFromNativeComponent("Component.Contracts.NullableTesting"); + Assert.IsTrue(target.IsNull(null)); + Assert.IsFalse(target.IsNull(5)); + Assert.AreEqual(5, target.GetIntValue(5)); + } + } +} diff --git a/tests/src/Interop/WinRT/NETClients/Primitives/Program.cs b/tests/src/Interop/WinRT/NETClients/Primitives/Program.cs new file mode 100644 index 0000000..64bcea1 --- /dev/null +++ b/tests/src/Interop/WinRT/NETClients/Primitives/Program.cs @@ -0,0 +1,38 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +namespace NetClient +{ + using System; + + class Program + { + static int Main(string[] args) + { + if (!TestLibrary.Utilities.IsWinRTSupported) + { + return 100; + } + + try + { + BooleanTests.RunTest(); + EnumTests.RunTest(); + StringTests.RunTest(); + NullableTests.RunTest(); + TypeTests.RunTest(); + ExceptionTests.RunTest(); + ArrayTests.RunTest(); + KeyValuePairTests.RunTest(); + UriTests.RunTest(); + } + catch (System.Exception ex) + { + Console.WriteLine(ex); + return 101; + } + return 100; + } + } +} diff --git a/tests/src/Interop/WinRT/NETClients/Primitives/StringTests.cs b/tests/src/Interop/WinRT/NETClients/Primitives/StringTests.cs new file mode 100644 index 0000000..e7fe27b --- /dev/null +++ b/tests/src/Interop/WinRT/NETClients/Primitives/StringTests.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +using TestLibrary; + +namespace NetClient +{ + public class StringTests + { + public static void RunTest() + { + Component.Contracts.IStringTesting target = (Component.Contracts.IStringTesting)WinRTNativeComponent.GetObjectFromNativeComponent("Component.Contracts.StringTesting"); + string left = "Hello C++/WinRT"; + string right = " from .NET Core"; + Assert.AreEqual(string.Concat(left, right), target.ConcatStrings(left, right)); + } + } +} diff --git a/tests/src/Interop/WinRT/NETClients/Primitives/TypeTests.cs b/tests/src/Interop/WinRT/NETClients/Primitives/TypeTests.cs new file mode 100644 index 0000000..c2f1364 --- /dev/null +++ b/tests/src/Interop/WinRT/NETClients/Primitives/TypeTests.cs @@ -0,0 +1,25 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +using System; +using TestLibrary; + +namespace NetClient +{ + public class TypeTests + { + public static void RunTest() + { + Component.Contracts.ITypeTesting target = (Component.Contracts.ITypeTesting)WinRTNativeComponent.GetObjectFromNativeComponent("Component.Contracts.TypeTesting"); + + // Non-WinRT managed types pass their assembly-qualified name + Assert.AreEqual(typeof(TypeTests).AssemblyQualifiedName, target.GetTypeName(typeof(TypeTests))); + + // WinRT types pass their full name (not assembly-qualified) + Assert.AreEqual(typeof(Component.Contracts.ITypeTesting).FullName, target.GetTypeName(typeof(Component.Contracts.ITypeTesting))); + + // Projected types pass the name of the type they are projected from + Assert.AreEqual("Windows.UI.Xaml.Interop.TypeName", target.GetTypeName(typeof(Type))); + } + } +} diff --git a/tests/src/Interop/WinRT/NETClients/Primitives/UriTests.cs b/tests/src/Interop/WinRT/NETClients/Primitives/UriTests.cs new file mode 100644 index 0000000..0d319f1 --- /dev/null +++ b/tests/src/Interop/WinRT/NETClients/Primitives/UriTests.cs @@ -0,0 +1,19 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +using System; +using TestLibrary; + +namespace NetClient +{ + public class UriTests + { + public static void RunTest() + { + Component.Contracts.IUriTesting target = (Component.Contracts.IUriTesting)WinRTNativeComponent.GetObjectFromNativeComponent("Component.Contracts.UriTesting"); + Uri managedUri = new Uri("https://dot.net"); + Assert.AreEqual(managedUri.ToString(), target.GetFromUri(managedUri)); + Assert.AreEqual(managedUri, target.CreateUriFromString(managedUri.ToString())); + } + } +} diff --git a/tests/src/Interop/WinRT/NativeComponent/CMakeLists.txt b/tests/src/Interop/WinRT/NativeComponent/CMakeLists.txt new file mode 100644 index 0000000..00cef94 --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/CMakeLists.txt @@ -0,0 +1,116 @@ +cmake_minimum_required (VERSION 2.8.12) +project (WinRTNativeComponent) +include_directories( ${INC_PLATFORM_DIR} ) +include ("${CLR_INTEROP_TEST_ROOT}/Interop.cmake") +include_directories("../Contracts") +include_directories(${CMAKE_CURRENT_SOURCE_DIR}) + +set(SOURCES + Component.Contracts.ArrayTesting.cpp + Component.Contracts.BindingProjectionsTesting.cpp + Component.Contracts.BindingViewModel.cpp + Component.Contracts.BooleanTesting.cpp + Component.Contracts.EnumTesting.cpp + Component.Contracts.ExceptionTesting.cpp + Component.Contracts.KeyValuePairTesting.cpp + Component.Contracts.NullableTesting.cpp + Component.Contracts.StringTesting.cpp + Component.Contracts.TypeTesting.cpp + Component.Contracts.UriTesting.cpp +) + +set (MIDL_GENERATED_WINMD ${CMAKE_CURRENT_BINARY_DIR}/WinMD/Component.Contracts.winmd) +file(TO_NATIVE_PATH ${MIDL_GENERATED_WINMD} MIDL_GENERATED_WINMD_WINDOWS_PATH) + +if(NOT DEFINED CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION OR CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION STREQUAL "" ) + message(FATAL_ERROR "Windows SDK is required for the WinRT interop tests build.") +else() + message("Using Windows SDK version ${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION} for WinRT interop tests.") +endif() + +set (PROGRAM_FILES_X86 "ProgramFiles(x86)") +set (WINDOWS_KITS_DIR "$ENV{${PROGRAM_FILES_X86}}/Windows Kits/10") +if (NOT EXISTS ${WINDOWS_KITS_DIR}) + set (WINDOWS_KITS_DIR "$ENV{ProgramFiles}/Windows Kits/10") +endif() +set (METADATA_DIR "${WINDOWS_KITS_DIR}/References/${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}/windows.foundation.foundationcontract/*" ) +set (REFERENCE_WINMDS + "${WINDOWS_KITS_DIR}/References/${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}/Windows.Foundation.FoundationContract/*/Windows.Foundation.FoundationContract.winmd" + "${WINDOWS_KITS_DIR}/References/${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}/Windows.Foundation.UniversalApiContract/*/Windows.Foundation.UniversalApiContract.winmd") + +file(GLOB RESOLVED_METADATA_DIR ${METADATA_DIR}) +file(TO_NATIVE_PATH ${RESOLVED_METADATA_DIR} METADATA_DIR_ARGUMENT) + +file(GLOB_RECURSE RESOLVED_REFERENCE_WINMDS ${REFERENCE_WINMDS}) + +set (REFERENCE_WINMD_ARGS "") +foreach(WINMD ${RESOLVED_REFERENCE_WINMDS}) + file(TO_NATIVE_PATH ${WINMD} WINMD_WINDOWS) + set(WINMD_WINDOWS "${WINMD_WINDOWS}") + string(PREPEND WINMD_WINDOWS "/reference") + list(APPEND REFERENCE_WINMD_ARGS ${WINMD_WINDOWS}) +endforeach() + +set (MIDL_FILE ../Contracts/Component.Contracts.idl) +set (MIDL_COMMAND_LINE_ARGS + /winrt + /metadata_dir ${METADATA_DIR_ARGUMENT} + /W1 + /enum_class + /ns_prefix + /target "NT60" + /nomidl + /h "nul" + ${REFERENCE_WINMD_ARGS} +) + +find_program(MIDLRT midlrt) + +add_custom_command( + OUTPUT ${MIDL_GENERATED_WINMD} + COMMAND ${MIDLRT} ${MIDL_COMMAND_LINE_ARGS} ${MIDL_FILE} /winmd ${MIDL_GENERATED_WINMD_WINDOWS_PATH} + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + DEPENDS ${MIDL_FILE} +) + +set_source_files_properties(${MIDL_GENERATED_WINMD} PROPERTIES GENERATED TRUE) + +set (CPP_WINRT_OUTPUT_FOLDER ${CMAKE_CURRENT_BINARY_DIR}/Generated) + +set (CPP_WINRT_OUTPUT_FILES + ${CPP_WINRT_OUTPUT_FOLDER}/winrt/impl/Component.Contracts.0.h + ${CPP_WINRT_OUTPUT_FOLDER}/winrt/impl/Component.Contracts.1.h + ${CPP_WINRT_OUTPUT_FOLDER}/winrt/impl/Component.Contracts.2.h + ${CPP_WINRT_OUTPUT_FOLDER}/winrt/Component.Contracts.h + ${CPP_WINRT_OUTPUT_FOLDER}/module.g.cpp +) + +include_directories(${CPP_WINRT_OUTPUT_FOLDER}) + +find_program(CPPWINRT cppwinrt) + +add_custom_command( + OUTPUT ${CPP_WINRT_OUTPUT_FILES} + COMMAND ${CPPWINRT} -name Contracts -comp ${CMAKE_CURRENT_SOURCE_DIR} -in ${MIDL_GENERATED_WINMD} -ref ${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION} -out ${CPP_WINRT_OUTPUT_FOLDER} + DEPENDS ${MIDL_GENERATED_WINMD} +) + +set_source_files_properties(${CPP_WINRT_OUTPUT_FILES} PROPERTIES GENERATED TRUE) + +list(APPEND SOURCES ${CPP_WINRT_OUTPUT_FOLDER}/module.g.cpp) + +if (WIN32) + list(APPEND SOURCES Exports.def) +endif() + +# add the executable +add_library (WinRTNativeComponent SHARED ${SOURCES}) +target_link_libraries(WinRTNativeComponent ${LINK_LIBRARIES_ADDITIONAL}) +set_target_properties(WinRTNativeComponent PROPERTIES CXX_STANDARD 17) + +if(WIN32) + target_link_libraries(WinRTNativeComponent RuntimeObject.lib) +endif() + +# add the install targets +install (TARGETS WinRTNativeComponent DESTINATION bin) diff --git a/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.ArrayTesting.cpp b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.ArrayTesting.cpp new file mode 100644 index 0000000..3c5dafc --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.ArrayTesting.cpp @@ -0,0 +1,19 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +#include "pch.h" +#include "Component.Contracts.ArrayTesting.h" +#include + +namespace winrt::Component::Contracts::implementation +{ + int32_t ArrayTesting::Sum(array_view array) + { + return std::accumulate(array.begin(), array.end(), 0); + } + + bool ArrayTesting::Xor(array_view array) + { + return std::accumulate(array.begin(), array.end(), false, [](bool left, bool right) { return left ^ right; }); + } +} diff --git a/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.ArrayTesting.h b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.ArrayTesting.h new file mode 100644 index 0000000..5ad383b --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.ArrayTesting.h @@ -0,0 +1,24 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +#pragma once + +#include "Component/Contracts/ArrayTesting.g.h" + +namespace winrt::Component::Contracts::implementation +{ + struct ArrayTesting : ArrayTestingT + { + ArrayTesting() = default; + + int32_t Sum(array_view array); + bool Xor(array_view array); + }; +} + +namespace winrt::Component::Contracts::factory_implementation +{ + struct ArrayTesting : ArrayTestingT + { + }; +} diff --git a/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BindingProjectionsTesting.cpp b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BindingProjectionsTesting.cpp new file mode 100644 index 0000000..5c32369 --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BindingProjectionsTesting.cpp @@ -0,0 +1,20 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +#include "pch.h" +#include "Component.Contracts.BindingProjectionsTesting.h" +#include "Component.Contracts.BindingViewModel.h" +#include + +namespace winrt::Component::Contracts::implementation +{ + Component::Contracts::IBindingViewModel BindingProjectionsTesting::CreateViewModel() + { + return make(); + } + + Windows::Foundation::IClosable BindingProjectionsTesting::InitializeXamlFrameworkForCurrentThread() + { + return Windows::UI::Xaml::Hosting::WindowsXamlManager::InitializeForCurrentThread(); + } +} diff --git a/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BindingProjectionsTesting.h b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BindingProjectionsTesting.h new file mode 100644 index 0000000..3813840 --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BindingProjectionsTesting.h @@ -0,0 +1,25 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +#pragma once + +#include "Component/Contracts/BindingProjectionsTesting.g.h" + +namespace winrt::Component::Contracts::implementation +{ + struct BindingProjectionsTesting : BindingProjectionsTestingT + { + BindingProjectionsTesting() = default; + + Component::Contracts::IBindingViewModel CreateViewModel(); + + Windows::Foundation::IClosable InitializeXamlFrameworkForCurrentThread(); + }; +} + +namespace winrt::Component::Contracts::factory_implementation +{ + struct BindingProjectionsTesting : BindingProjectionsTestingT + { + }; +} diff --git a/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BindingViewModel.cpp b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BindingViewModel.cpp new file mode 100644 index 0000000..47b8dff --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BindingViewModel.cpp @@ -0,0 +1,40 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +#include "pch.h" +#include "Component.Contracts.BindingViewModel.h" +#include + +namespace winrt::Component::Contracts::implementation +{ + Windows::UI::Xaml::Interop::INotifyCollectionChanged BindingViewModel::Collection() + { + return m_collection; + } + + void BindingViewModel::AddElement(int32_t i) + { + m_collection.push_back(i); + } + + hstring BindingViewModel::Name() + { + return m_name; + } + + void BindingViewModel::Name(hstring const& value) + { + m_name = value; + m_propertyChangedEvent(*this, Windows::UI::Xaml::Data::PropertyChangedEventArgs(hstring(W("Name")))); + } + + winrt::event_token BindingViewModel::PropertyChanged(Windows::UI::Xaml::Data::PropertyChangedEventHandler const& handler) + { + return m_propertyChangedEvent.add(handler); + } + + void BindingViewModel::PropertyChanged(winrt::event_token const& token) noexcept + { + m_propertyChangedEvent.remove(token); + } +} diff --git a/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BindingViewModel.h b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BindingViewModel.h new file mode 100644 index 0000000..d394432 --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BindingViewModel.h @@ -0,0 +1,161 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +#pragma once + +#include "Component/Contracts/BindingViewModel.g.h" +#include + +template +struct BindableIteratorWrapper : winrt::implements, winrt::Windows::UI::Xaml::Interop::IBindableIterator> +{ + BindableIteratorWrapper(winrt::Windows::Foundation::Collections::IIterator&& iterator) + :m_iterator(std::move(iterator)) + {} + + winrt::Windows::Foundation::IInspectable Current() + { + return winrt::box_value(m_iterator.Current()); + } + + bool HasCurrent() + { + return m_iterator.HasCurrent(); + } + + bool MoveNext() + { + return m_iterator.MoveNext(); + } + +private: + winrt::Windows::Foundation::Collections::IIterator m_iterator; +}; + +template +struct BindableVectorWrapper : winrt::implements, winrt::Windows::UI::Xaml::Interop::IBindableVector> +{ + BindableVectorWrapper(winrt::Windows::Foundation::Collections::IVector&& elements) + :m_elements(std::move(elements)) + { + } + + winrt::Windows::UI::Xaml::Interop::IBindableIterator First() + { + return winrt::make>(m_elements.First()); + } + + uint32_t Size() + { + return m_elements.Size(); + } + + void Append(winrt::Windows::Foundation::IInspectable const& value) + { + m_elements.Append(winrt::unbox_value(value)); + } + + void Clear() + { + m_elements.Clear(); + } + + winrt::Windows::Foundation::IInspectable GetAt(uint32_t index) + { + return winrt::box_value(m_elements.GetAt(index)); + } + + winrt::Windows::UI::Xaml::Interop::IBindableVectorView GetView() + { + throw winrt::hresult_not_implemented(); + } + + bool IndexOf(winrt::Windows::Foundation::IInspectable const& value, uint32_t& index) + { + return m_elements.IndexOf(winrt::unbox_value(value), index); + } + + void InsertAt(uint32_t index, winrt::Windows::Foundation::IInspectable const& value) + { + m_elements.InsertAt(index, winrt::unbox_value(value)); + } + + void RemoveAt(uint32_t index) + { + m_elements.RemoveAt(index); + } + + void RemoveAtEnd() + { + m_elements.RemoveAtEnd(); + } + + void SetAt(uint32_t index, winrt::Windows::Foundation::IInspectable const& value) + { + m_elements.SetAt(index, winrt::unbox_value(value)); + } +private: + winrt::Windows::Foundation::Collections::IVector m_elements; +}; + +template> +struct ObservableCollection : winrt::implements, winrt::Windows::UI::Xaml::Interop::INotifyCollectionChanged> +{ + ObservableCollection() = default; + + winrt::event_token CollectionChanged(winrt::Windows::UI::Xaml::Interop::NotifyCollectionChangedEventHandler const& handler) + { + return m_CollectionChangedEvent.add(handler); + } + + void CollectionChanged(winrt::event_token const& token) noexcept + { + m_CollectionChangedEvent.remove(token); + } + + void push_back(const T& value) + { + m_elements.push_back(value); + + winrt::Windows::UI::Xaml::Interop::NotifyCollectionChangedEventArgs args( + winrt::Windows::UI::Xaml::Interop::NotifyCollectionChangedAction::Add, + winrt::make>(winrt::single_threaded_vector(std::vector{value})), + nullptr, + (int32_t)(m_elements.size() - 1), + -1 + ); + m_CollectionChangedEvent(*this, args); + } + +private: + Container m_elements; + winrt::event m_CollectionChangedEvent; +}; + + +namespace winrt::Component::Contracts::implementation +{ + struct BindingViewModel : BindingViewModelT + { + BindingViewModel() = default; + + Windows::UI::Xaml::Interop::INotifyCollectionChanged Collection(); + void AddElement(int32_t i); + hstring Name(); + void Name(hstring const& value); + winrt::event_token PropertyChanged(Windows::UI::Xaml::Data::PropertyChangedEventHandler const& handler); + void PropertyChanged(winrt::event_token const& token) noexcept; + + private: + hstring m_name; + winrt::event m_propertyChangedEvent; + ObservableCollection m_collection; + }; +} + +namespace winrt::Component::Contracts::factory_implementation +{ + struct BindingViewModel : BindingViewModelT + { + }; +} diff --git a/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BooleanTesting.cpp b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BooleanTesting.cpp new file mode 100644 index 0000000..16ad984 --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BooleanTesting.cpp @@ -0,0 +1,13 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +#include "pch.h" +#include "Component.Contracts.BooleanTesting.h" + +namespace winrt::Component::Contracts::implementation +{ + bool BooleanTesting::And(bool left, bool right) + { + return left && right; + } +} diff --git a/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BooleanTesting.h b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BooleanTesting.h new file mode 100644 index 0000000..c8449ef --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.BooleanTesting.h @@ -0,0 +1,23 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +#pragma once + +#include "Component/Contracts/BooleanTesting.g.h" + +namespace winrt::Component::Contracts::implementation +{ + struct BooleanTesting : BooleanTestingT + { + BooleanTesting() = default; + + bool And(bool left, bool right); + }; +} + +namespace winrt::Component::Contracts::factory_implementation +{ + struct BooleanTesting : BooleanTestingT + { + }; +} diff --git a/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.EnumTesting.cpp b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.EnumTesting.cpp new file mode 100644 index 0000000..07ffd92 --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.EnumTesting.cpp @@ -0,0 +1,15 @@ +#include "pch.h" +#include "Component.Contracts.EnumTesting.h" + +namespace winrt::Component::Contracts::implementation +{ + Component::Contracts::TestEnum EnumTesting::GetA() + { + return TestEnum::A; + } + + bool EnumTesting::IsB(Component::Contracts::TestEnum const& val) + { + return val == TestEnum::B; + } +} diff --git a/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.EnumTesting.h b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.EnumTesting.h new file mode 100644 index 0000000..f01dffe --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.EnumTesting.h @@ -0,0 +1,21 @@ +#pragma once + +#include "Component/Contracts/EnumTesting.g.h" + +namespace winrt::Component::Contracts::implementation +{ + struct EnumTesting : EnumTestingT + { + EnumTesting() = default; + + Component::Contracts::TestEnum GetA(); + bool IsB(Component::Contracts::TestEnum const& val); + }; +} + +namespace winrt::Component::Contracts::factory_implementation +{ + struct EnumTesting : EnumTestingT + { + }; +} diff --git a/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.ExceptionTesting.cpp b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.ExceptionTesting.cpp new file mode 100644 index 0000000..7d99492 --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.ExceptionTesting.cpp @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +#include "pch.h" +#include "Component.Contracts.ExceptionTesting.h" + +namespace winrt::Component::Contracts::implementation +{ + void ExceptionTesting::ThrowException(winrt::hresult const& hr) + { + winrt::throw_hresult(hr); + } + + winrt::hresult ExceptionTesting::GetException(int32_t hr) + { + return {hr}; + } +} diff --git a/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.ExceptionTesting.h b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.ExceptionTesting.h new file mode 100644 index 0000000..5335986 --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.ExceptionTesting.h @@ -0,0 +1,24 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +#pragma once + +#include "Component/Contracts/ExceptionTesting.g.h" + +namespace winrt::Component::Contracts::implementation +{ + struct ExceptionTesting : ExceptionTestingT + { + ExceptionTesting() = default; + + void ThrowException(winrt::hresult const& hr); + winrt::hresult GetException(int32_t hr); + }; +} + +namespace winrt::Component::Contracts::factory_implementation +{ + struct ExceptionTesting : ExceptionTestingT + { + }; +} diff --git a/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.KeyValuePairTesting.cpp b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.KeyValuePairTesting.cpp new file mode 100644 index 0000000..b6b9213 --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.KeyValuePairTesting.cpp @@ -0,0 +1,48 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +#include "pch.h" +#include "Component.Contracts.KeyValuePairTesting.h" +#include +#include + +template +struct pair_wrapper : winrt::implements, winrt::Windows::Foundation::Collections::IKeyValuePair> +{ + pair_wrapper(const K& key, const V& value) + :key{ key }, + value{ value } + {} + + K Key() + { + return key; + } + + V Value() + { + return value; + } + +private: + K key; + V value; +}; + +namespace winrt::Component::Contracts::implementation +{ + Windows::Foundation::Collections::IKeyValuePair KeyValuePairTesting::MakeSimplePair(int32_t key, int32_t value) + { + return make>(key, value); + } + + Windows::Foundation::Collections::IKeyValuePair KeyValuePairTesting::MakeMarshaledPair(hstring const& key, hstring const& value) + { + return make>(key, value); + } + + Windows::Foundation::Collections::IKeyValuePair> KeyValuePairTesting::MakeProjectedPair(int32_t key, array_view values) + { + return pair_wrapper>{key, winrt::single_threaded_vector(std::vector(values.begin(), values.end()))}; + } +} diff --git a/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.KeyValuePairTesting.h b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.KeyValuePairTesting.h new file mode 100644 index 0000000..1e8167c --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.KeyValuePairTesting.h @@ -0,0 +1,25 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +#pragma once + +#include "Component/Contracts/KeyValuePairTesting.g.h" + +namespace winrt::Component::Contracts::implementation +{ + struct KeyValuePairTesting : KeyValuePairTestingT + { + KeyValuePairTesting() = default; + + Windows::Foundation::Collections::IKeyValuePair MakeSimplePair(int32_t key, int32_t value); + Windows::Foundation::Collections::IKeyValuePair MakeMarshaledPair(hstring const& key, hstring const& value); + Windows::Foundation::Collections::IKeyValuePair> MakeProjectedPair(int32_t key, array_view values); + }; +} + +namespace winrt::Component::Contracts::factory_implementation +{ + struct KeyValuePairTesting : KeyValuePairTestingT + { + }; +} diff --git a/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.NullableTesting.cpp b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.NullableTesting.cpp new file mode 100644 index 0000000..8cbd5e2 --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.NullableTesting.cpp @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +#include "pch.h" +#include "Component.Contracts.NullableTesting.h" + +namespace winrt::Component::Contracts::implementation +{ + bool NullableTesting::IsNull(Windows::Foundation::IReference const& value) + { + return value == nullptr; + } + + int32_t NullableTesting::GetIntValue(Windows::Foundation::IReference const& value) + { + return winrt::unbox_value(value); + } +} diff --git a/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.NullableTesting.h b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.NullableTesting.h new file mode 100644 index 0000000..44ecd5e --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.NullableTesting.h @@ -0,0 +1,24 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +#pragma once + +#include "Component/Contracts/NullableTesting.g.h" + +namespace winrt::Component::Contracts::implementation +{ + struct NullableTesting : NullableTestingT + { + NullableTesting() = default; + + bool IsNull(Windows::Foundation::IReference const& value); + int32_t GetIntValue(Windows::Foundation::IReference const& value); + }; +} + +namespace winrt::Component::Contracts::factory_implementation +{ + struct NullableTesting : NullableTestingT + { + }; +} diff --git a/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.StringTesting.cpp b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.StringTesting.cpp new file mode 100644 index 0000000..7b691cd --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.StringTesting.cpp @@ -0,0 +1,13 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +#include "pch.h" +#include "Component.Contracts.StringTesting.h" + +namespace winrt::Component::Contracts::implementation +{ + hstring StringTesting::ConcatStrings(hstring const& left, hstring const& right) + { + return left + right; + } +} diff --git a/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.StringTesting.h b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.StringTesting.h new file mode 100644 index 0000000..2d06e3e --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.StringTesting.h @@ -0,0 +1,23 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +#pragma once + +#include "Component/Contracts/StringTesting.g.h" + +namespace winrt::Component::Contracts::implementation +{ + struct StringTesting : StringTestingT + { + StringTesting() = default; + + hstring ConcatStrings(hstring const& left, hstring const& right); + }; +} + +namespace winrt::Component::Contracts::factory_implementation +{ + struct StringTesting : StringTestingT + { + }; +} diff --git a/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.TypeTesting.cpp b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.TypeTesting.cpp new file mode 100644 index 0000000..2cc79a8 --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.TypeTesting.cpp @@ -0,0 +1,13 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +#include "pch.h" +#include "Component.Contracts.TypeTesting.h" + +namespace winrt::Component::Contracts::implementation +{ + hstring TypeTesting::GetTypeName(Windows::UI::Xaml::Interop::TypeName const& typeName) + { + return typeName.Name; + } +} diff --git a/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.TypeTesting.h b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.TypeTesting.h new file mode 100644 index 0000000..1a4b233 --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.TypeTesting.h @@ -0,0 +1,23 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +#pragma once + +#include "Component/Contracts/TypeTesting.g.h" + +namespace winrt::Component::Contracts::implementation +{ + struct TypeTesting : TypeTestingT + { + TypeTesting() = default; + + hstring GetTypeName(Windows::UI::Xaml::Interop::TypeName const& typeName); + }; +} + +namespace winrt::Component::Contracts::factory_implementation +{ + struct TypeTesting : TypeTestingT + { + }; +} diff --git a/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.UriTesting.cpp b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.UriTesting.cpp new file mode 100644 index 0000000..9812021 --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.UriTesting.cpp @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +#include "pch.h" +#include "Component.Contracts.UriTesting.h" + +namespace winrt::Component::Contracts::implementation +{ + hstring UriTesting::GetFromUri(Windows::Foundation::Uri const& uri) + { + return uri.ToString(); + } + + Windows::Foundation::Uri UriTesting::CreateUriFromString(hstring const& uri) + { + return {uri}; + } +} diff --git a/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.UriTesting.h b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.UriTesting.h new file mode 100644 index 0000000..c8cda59 --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Component.Contracts.UriTesting.h @@ -0,0 +1,24 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +#pragma once + +#include "Component/Contracts/UriTesting.g.h" + +namespace winrt::Component::Contracts::implementation +{ + struct UriTesting : UriTestingT + { + UriTesting() = default; + + hstring GetFromUri(Windows::Foundation::Uri const& uri); + Windows::Foundation::Uri CreateUriFromString(hstring const& uri); + }; +} + +namespace winrt::Component::Contracts::factory_implementation +{ + struct UriTesting : UriTestingT + { + }; +} diff --git a/tests/src/Interop/WinRT/NativeComponent/Exports.def b/tests/src/Interop/WinRT/NativeComponent/Exports.def new file mode 100644 index 0000000..6e3d53b --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/Exports.def @@ -0,0 +1,3 @@ +EXPORTS + DllCanUnloadNow = WINRT_CanUnloadNow PRIVATE + DllGetActivationFactory = WINRT_GetActivationFactory PRIVATE diff --git a/tests/src/Interop/WinRT/NativeComponent/pch.h b/tests/src/Interop/WinRT/NativeComponent/pch.h new file mode 100644 index 0000000..ebe6de1 --- /dev/null +++ b/tests/src/Interop/WinRT/NativeComponent/pch.h @@ -0,0 +1,10 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +// The cppwinrt tool expects there to be a pch.h file in an include-directory that includes +// winrt/base.h. +#ifndef PCH_H +#define PCH_H +#include +#endif -- 2.7.4