From 5e20c7f3d6194ef366a075371f9faee19ac68038 Mon Sep 17 00:00:00 2001 From: Zeng Jiang Date: Sun, 11 Nov 2018 03:59:07 +0800 Subject: [PATCH] Add PInvoke/BestFitMapping tests (#19269) * Add PInvoke/BestFitMapping tests * Fix warning * Make native side of tests xplat. * Clean up managed side of the test build. * Disable BestFitMapping tests off Windows. * Individually disable tests. * Disable the two tests that I missed last time. --- tests/src/Interop/CMakeLists.txt | 2 + .../PInvoke/BestFitMapping/Char/AFF_PFF/AFF_PFF.cs | 182 ++++++++++ .../BestFitMapping/Char/AFF_PFF/AFF_PFF.csproj | 38 +++ .../PInvoke/BestFitMapping/Char/AFF_PFT/AFF_PFT.cs | 174 ++++++++++ .../BestFitMapping/Char/AFF_PFT/AFF_PFT.csproj | 38 +++ .../PInvoke/BestFitMapping/Char/AFF_PTF/AFF_PTF.cs | 193 +++++++++++ .../BestFitMapping/Char/AFF_PTF/AFF_PTF.csproj | 38 +++ .../PInvoke/BestFitMapping/Char/AFF_PTT/AFF_PTT.cs | 182 ++++++++++ .../BestFitMapping/Char/AFF_PTT/AFF_PTT.csproj | 38 +++ .../PInvoke/BestFitMapping/Char/AFT_PFF/AFT_PFF.cs | 182 ++++++++++ .../BestFitMapping/Char/AFT_PFF/AFT_PFF.csproj | 38 +++ .../PInvoke/BestFitMapping/Char/AFT_PFT/AFT_PFT.cs | 176 ++++++++++ .../BestFitMapping/Char/AFT_PFT/AFT_PFT.csproj | 38 +++ .../PInvoke/BestFitMapping/Char/AFT_PTF/AFT_PTF.cs | 194 +++++++++++ .../BestFitMapping/Char/AFT_PTF/AFT_PTF.csproj | 38 +++ .../PInvoke/BestFitMapping/Char/AFT_PTT/AFT_PTT.cs | 182 ++++++++++ .../BestFitMapping/Char/AFT_PTT/AFT_PTT.csproj | 38 +++ .../PInvoke/BestFitMapping/Char/ATF_PFF/ATF_PFF.cs | 182 ++++++++++ .../BestFitMapping/Char/ATF_PFF/ATF_PFF.csproj | 38 +++ .../PInvoke/BestFitMapping/Char/ATF_PFT/ATF_PFT.cs | 175 ++++++++++ .../BestFitMapping/Char/ATF_PFT/ATF_PFT.csproj | 38 +++ .../PInvoke/BestFitMapping/Char/ATF_PTF/ATF_PTF.cs | 194 +++++++++++ .../BestFitMapping/Char/ATF_PTF/ATF_PTF.csproj | 38 +++ .../PInvoke/BestFitMapping/Char/ATF_PTT/ATF_PTT.cs | 182 ++++++++++ .../BestFitMapping/Char/ATF_PTT/ATF_PTT.csproj | 38 +++ .../PInvoke/BestFitMapping/Char/ATT_PFF/ATT_PFF.cs | 182 ++++++++++ .../BestFitMapping/Char/ATT_PFF/ATT_PFF.csproj | 38 +++ .../PInvoke/BestFitMapping/Char/ATT_PFT/ATT_PFT.cs | 176 ++++++++++ .../BestFitMapping/Char/ATT_PFT/ATT_PFT.csproj | 38 +++ .../PInvoke/BestFitMapping/Char/ATT_PTF/ATT_PTF.cs | 194 +++++++++++ .../BestFitMapping/Char/ATT_PTF/ATT_PTF.csproj | 38 +++ .../PInvoke/BestFitMapping/Char/ATT_PTT/ATT_PTT.cs | 182 ++++++++++ .../BestFitMapping/Char/ATT_PTT/ATT_PTT.csproj | 38 +++ .../Assembly_False_False/Assembly_False_False.cs | 182 ++++++++++ .../Assembly_False_False.csproj | 38 +++ .../Assembly_False_True/Assembly_False_True.cs | 176 ++++++++++ .../Assembly_False_True/Assembly_False_True.csproj | 38 +++ .../Assembly_True_False/Assembly_True_False.cs | 231 +++++++++++++ .../Assembly_True_False/Assembly_True_False.csproj | 38 +++ .../Char/Assembly_True_True/Assembly_True_True.cs | 183 +++++++++++ .../Assembly_True_True/Assembly_True_True.csproj | 38 +++ .../BestFitMapping/Char/BestFitMappingNative.cpp | 98 ++++++ .../PInvoke/BestFitMapping/Char/CMakeLists.txt | 12 + .../Pinvoke_False_False/Pinvoke_False_False.cs | 180 ++++++++++ .../Pinvoke_False_False/Pinvoke_False_False.csproj | 38 +++ .../Char/Pinvoke_False_True/Pinvoke_False_True.cs | 174 ++++++++++ .../Pinvoke_False_True/Pinvoke_False_True.csproj | 38 +++ .../Char/Pinvoke_True_False/Pinvoke_True_False.cs | 192 +++++++++++ .../Pinvoke_True_False/Pinvoke_True_False.csproj | 38 +++ .../Char/Pinvoke_True_True/Pinvoke_True_True.cs | 180 ++++++++++ .../Pinvoke_True_True/Pinvoke_True_True.csproj | 38 +++ .../BestFitMapping/LPStr/AFF_PFF/AFF_PFF.cs | 358 ++++++++++++++++++++ .../BestFitMapping/LPStr/AFF_PFF/AFF_PFF.csproj | 39 +++ .../BestFitMapping/LPStr/AFF_PFT/AFF_PFT.cs | 345 +++++++++++++++++++ .../BestFitMapping/LPStr/AFF_PFT/AFF_PFT.csproj | 38 +++ .../BestFitMapping/LPStr/AFF_PTF/AFF_PTF.cs | 342 +++++++++++++++++++ .../BestFitMapping/LPStr/AFF_PTF/AFF_PTF.csproj | 38 +++ .../BestFitMapping/LPStr/AFF_PTT/AFF_PTT.cs | 331 +++++++++++++++++++ .../BestFitMapping/LPStr/AFF_PTT/AFF_PTT.csproj | 38 +++ .../BestFitMapping/LPStr/AFT_PFF/AFT_PFF.cs | 354 ++++++++++++++++++++ .../BestFitMapping/LPStr/AFT_PFF/AFT_PFF.csproj | 38 +++ .../BestFitMapping/LPStr/AFT_PFT/AFT_PFT.cs | 343 +++++++++++++++++++ .../BestFitMapping/LPStr/AFT_PFT/AFT_PFT.csproj | 38 +++ .../BestFitMapping/LPStr/AFT_PTF/AFT_PTF.cs | 337 +++++++++++++++++++ .../BestFitMapping/LPStr/AFT_PTF/AFT_PTF.csproj | 38 +++ .../BestFitMapping/LPStr/AFT_PTT/AFT_PTT.cs | 365 +++++++++++++++++++++ .../BestFitMapping/LPStr/AFT_PTT/AFT_PTT.csproj | 38 +++ .../BestFitMapping/LPStr/ATF_PFF/ATF_PFF.cs | 353 ++++++++++++++++++++ .../BestFitMapping/LPStr/ATF_PFF/ATF_PFF.csproj | 38 +++ .../BestFitMapping/LPStr/ATF_PFT/ATF_PFT.cs | 341 +++++++++++++++++++ .../BestFitMapping/LPStr/ATF_PFT/ATF_PFT.csproj | 38 +++ .../BestFitMapping/LPStr/ATF_PTF/ATF_PTF.cs | 338 +++++++++++++++++++ .../BestFitMapping/LPStr/ATF_PTF/ATF_PTF.csproj | 38 +++ .../BestFitMapping/LPStr/ATF_PTT/ATF_PTT.cs | 330 +++++++++++++++++++ .../BestFitMapping/LPStr/ATF_PTT/ATF_PTT.csproj | 38 +++ .../BestFitMapping/LPStr/ATT_PFF/ATT_PFF.cs | 355 ++++++++++++++++++++ .../BestFitMapping/LPStr/ATT_PFF/ATT_PFF.csproj | 38 +++ .../BestFitMapping/LPStr/ATT_PFT/ATT_PFT.cs | 344 +++++++++++++++++++ .../BestFitMapping/LPStr/ATT_PFT/ATT_PFT.csproj | 38 +++ .../BestFitMapping/LPStr/ATT_PTF/ATT_PTF.cs | 339 +++++++++++++++++++ .../BestFitMapping/LPStr/ATT_PTF/ATT_PTF.csproj | 38 +++ .../BestFitMapping/LPStr/ATT_PTT/ATT_PTT.cs | 332 +++++++++++++++++++ .../BestFitMapping/LPStr/ATT_PTT/ATT_PTT.csproj | 38 +++ .../Assembly_False_False/Assembly_False_False.cs | 350 ++++++++++++++++++++ .../Assembly_False_False.csproj | 38 +++ .../Assembly_False_True/Assembly_False_True.cs | 339 +++++++++++++++++++ .../Assembly_False_True/Assembly_False_True.csproj | 38 +++ .../Assembly_True_False/Assembly_True_False.cs | 335 +++++++++++++++++++ .../Assembly_True_False/Assembly_True_False.csproj | 38 +++ .../LPStr/Assembly_True_True/Assembly_True_True.cs | 331 +++++++++++++++++++ .../Assembly_True_True/Assembly_True_True.csproj | 38 +++ .../BestFitMapping/LPStr/BestFitMappingNative.cpp | 146 +++++++++ .../PInvoke/BestFitMapping/LPStr/CMakeLists.txt | 13 + .../Pinvoke_False_False/Pinvoke_False_False.cs | 353 ++++++++++++++++++++ .../Pinvoke_False_False/Pinvoke_False_False.csproj | 38 +++ .../LPStr/Pinvoke_False_True/Pinvoke_False_True.cs | 340 +++++++++++++++++++ .../Pinvoke_False_True/Pinvoke_False_True.csproj | 38 +++ .../LPStr/Pinvoke_True_False/Pinvoke_True_False.cs | 337 +++++++++++++++++++ .../Pinvoke_True_False/Pinvoke_True_False.csproj | 38 +++ .../LPStr/Pinvoke_True_True/Pinvoke_True_True.cs | 329 +++++++++++++++++++ .../Pinvoke_True_True/Pinvoke_True_True.csproj | 38 +++ 101 files changed, 14747 insertions(+) create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PFF/AFF_PFF.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PFF/AFF_PFF.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PFT/AFF_PFT.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PFT/AFF_PFT.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PTF/AFF_PTF.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PTF/AFF_PTF.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PTT/AFF_PTT.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PTT/AFF_PTT.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PFF/AFT_PFF.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PFF/AFT_PFF.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PFT/AFT_PFT.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PFT/AFT_PFT.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PTF/AFT_PTF.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PTF/AFT_PTF.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PTT/AFT_PTT.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PTT/AFT_PTT.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PFF/ATF_PFF.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PFF/ATF_PFF.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PFT/ATF_PFT.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PFT/ATF_PFT.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PTF/ATF_PTF.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PTF/ATF_PTF.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PTT/ATF_PTT.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PTT/ATF_PTT.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PFF/ATT_PFF.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PFF/ATT_PFF.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PFT/ATT_PFT.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PFT/ATT_PFT.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PTF/ATT_PTF.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PTF/ATT_PTF.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PTT/ATT_PTT.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PTT/ATT_PTT.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_False_False/Assembly_False_False.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_False_False/Assembly_False_False.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_False_True/Assembly_False_True.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_False_True/Assembly_False_True.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_True_False/Assembly_True_False.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_True_False/Assembly_True_False.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_True_True/Assembly_True_True.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_True_True/Assembly_True_True.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/BestFitMappingNative.cpp create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/CMakeLists.txt create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_False_False/Pinvoke_False_False.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_False_False/Pinvoke_False_False.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_False_True/Pinvoke_False_True.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_False_True/Pinvoke_False_True.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_True_False/Pinvoke_True_False.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_True_False/Pinvoke_True_False.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_True_True/Pinvoke_True_True.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_True_True/Pinvoke_True_True.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PFF/AFF_PFF.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PFF/AFF_PFF.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PFT/AFF_PFT.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PFT/AFF_PFT.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PTF/AFF_PTF.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PTF/AFF_PTF.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PTT/AFF_PTT.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PTT/AFF_PTT.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PFF/AFT_PFF.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PFF/AFT_PFF.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PFT/AFT_PFT.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PFT/AFT_PFT.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PTF/AFT_PTF.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PTF/AFT_PTF.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PTT/AFT_PTT.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PTT/AFT_PTT.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PFF/ATF_PFF.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PFF/ATF_PFF.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PFT/ATF_PFT.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PFT/ATF_PFT.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PTF/ATF_PTF.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PTF/ATF_PTF.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PTT/ATF_PTT.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PTT/ATF_PTT.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PFF/ATT_PFF.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PFF/ATT_PFF.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PFT/ATT_PFT.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PFT/ATT_PFT.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PTF/ATT_PTF.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PTF/ATT_PTF.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PTT/ATT_PTT.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PTT/ATT_PTT.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_False_False/Assembly_False_False.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_False_False/Assembly_False_False.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_False_True/Assembly_False_True.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_False_True/Assembly_False_True.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_True_False/Assembly_True_False.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_True_False/Assembly_True_False.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_True_True/Assembly_True_True.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_True_True/Assembly_True_True.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/BestFitMappingNative.cpp create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/CMakeLists.txt create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_False_False/Pinvoke_False_False.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_False_False/Pinvoke_False_False.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_False_True/Pinvoke_False_True.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_False_True/Pinvoke_False_True.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_True_False/Pinvoke_True_False.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_True_False/Pinvoke_True_False.csproj create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_True_True/Pinvoke_True_True.cs create mode 100644 tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_True_True/Pinvoke_True_True.csproj diff --git a/tests/src/Interop/CMakeLists.txt b/tests/src/Interop/CMakeLists.txt index 4fe5cef..9c78b1d 100644 --- a/tests/src/Interop/CMakeLists.txt +++ b/tests/src/Interop/CMakeLists.txt @@ -12,6 +12,8 @@ list(APPEND LINK_LIBRARIES_ADDITIONAL platformdefines) SET(CLR_INTEROP_TEST_ROOT ${CMAKE_CURRENT_SOURCE_DIR}) include_directories(common) +add_subdirectory(PInvoke/BestFitMapping/Char) +add_subdirectory(PInvoke/BestFitMapping/LPStr) add_subdirectory(PInvoke/Delegate/MarshalDelegateAsField) add_subdirectory(PInvoke/Delegate/MarshalDelegateAsParam) add_subdirectory(PInvoke/Primitives/Int) diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PFF/AFF_PFF.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PFF/AFF_PFF.cs new file mode 100644 index 0000000..68d9ccd --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PFF/AFF_PFF.cs @@ -0,0 +1,182 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(false, ThrowOnUnmappableChar = false)] + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.IsTrue(Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc3"); + + cTemp = GetValidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc4"); + + cTemp = GetInvalidChar(); + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc5"); + Assert.AreEqual('?', cTemp, "[Error] Location tc6"); + + cTemp = GetValidChar(); + char cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc7"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc8"); + } + + static void testCharBufferString() + { + Assert.IsTrue(CharBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs4"); + + cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs5"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tcbs6"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs7"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs8"); + } + + static void testCharBufferStringBuilder() + { + StringBuilder sb = GetInvalidStringBuilder(); + Assert.IsTrue(CharBuffer_In_StringBuilder(sb), "[Error] Location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb4"); + + cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb6"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb7"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb8"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PFF/AFF_PFF.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PFF/AFF_PFF.csproj new file mode 100644 index 0000000..0e53455 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PFF/AFF_PFF.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + AFF_PFF + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PFT/AFF_PFT.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PFT/AFF_PFT.cs new file mode 100644 index 0000000..268d74d --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PFT/AFF_PFT.cs @@ -0,0 +1,174 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(false, ThrowOnUnmappableChar = false)] + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.Throws(() => Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + Assert.Throws(() => Char_InByRef(ref cTemp), "[Error] Location tc3"); + + cTemp = GetValidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc4"); + + cTemp = GetInvalidChar(); + Assert.Throws(() => Char_InOutByRef(ref cTemp), "[Error] Location tc5"); + + cTemp = GetValidChar(); + char cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc6"); + } + + static void testCharBufferString() + { + Assert.Throws(() => CharBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + Assert.Throws(() => CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs4"); + + cTemp = GetInvalidString(); + Assert.Throws(() => CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs5"); + + cTemp = GetValidString(); + String cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs6"); + } + + static void testCharBufferStringBuilder() + { + Assert.Throws(() => CharBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb4"); + + cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb"); + + cTemp = GetValidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb6"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb7"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PFT/AFF_PFT.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PFT/AFF_PFT.csproj new file mode 100644 index 0000000..36f3a37 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PFT/AFF_PFT.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + AFF_PFT + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PTF/AFF_PTF.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PTF/AFF_PTF.cs new file mode 100644 index 0000000..abf8527 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PTF/AFF_PTF.cs @@ -0,0 +1,193 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(false, ThrowOnUnmappableChar = false)] + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.IsTrue(Char_In(GetInvalidChar()), "[Error] Location tc1"); + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + char cTempClone = cTemp; + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc3"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc4"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc5"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc6"); + + cTemp = GetInvalidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc7"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tc8"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc9"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc10"); + } + + static void testCharBufferString() + { + Assert.IsTrue(CharBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs4"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs5"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs6"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs7"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tcbs8"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs9"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs10"); + } + + static void testCharBufferStringBuilder() + { + Assert.IsTrue(CharBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb4"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb6"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb7"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb8"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb9"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb10"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PTF/AFF_PTF.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PTF/AFF_PTF.csproj new file mode 100644 index 0000000..171581f --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PTF/AFF_PTF.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + AFF_PTF + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PTT/AFF_PTT.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PTT/AFF_PTT.cs new file mode 100644 index 0000000..2679a60 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PTT/AFF_PTT.cs @@ -0,0 +1,182 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(false, ThrowOnUnmappableChar = false)] + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.IsTrue(Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + char cTempClone = GetInvalidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc3"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc4"); + + cTemp = GetInvalidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc5"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc6"); + } + + static void testCharBufferString() + { + Assert.IsTrue(CharBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = GetInvalidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs4"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs5"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs6"); + } + + static void testCharBufferStringBuilder() + { + Assert.IsTrue(CharBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb4"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb6"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PTT/AFF_PTT.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PTT/AFF_PTT.csproj new file mode 100644 index 0000000..0f5152e --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFF_PTT/AFF_PTT.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + AFF_PTT + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PFF/AFT_PFF.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PFF/AFT_PFF.cs new file mode 100644 index 0000000..eecd969 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PFF/AFT_PFF.cs @@ -0,0 +1,182 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(false, ThrowOnUnmappableChar = true)] + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.IsTrue(Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc3"); + + cTemp = GetValidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc4"); + + cTemp = GetInvalidChar(); + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc5"); + Assert.AreEqual('?', cTemp, "[Error] Location tc66"); + + cTemp = GetValidChar(); + char cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc7"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc8"); + } + + static void testCharBufferString() + { + Assert.IsTrue(CharBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs4"); + + cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs5"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tcbs6"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs7"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs88"); + } + + static void testCharBufferStringBuilder() + { + StringBuilder sb = GetInvalidStringBuilder(); + Assert.IsTrue(CharBuffer_In_StringBuilder(sb), "[Error] Location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb4"); + + cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb6"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb7"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb8"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PFF/AFT_PFF.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PFF/AFT_PFF.csproj new file mode 100644 index 0000000..9a50cc5 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PFF/AFT_PFF.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + AFT_PFF + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PFT/AFT_PFT.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PFT/AFT_PFT.cs new file mode 100644 index 0000000..b052ee4 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PFT/AFT_PFT.cs @@ -0,0 +1,176 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(false, ThrowOnUnmappableChar = true)] + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.Throws(() => Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + Assert.Throws(() => Char_InByRef(ref cTemp), "[Error] Location tc3"); + + cTemp = GetValidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc4"); + + cTemp = GetInvalidChar(); + Assert.Throws(() => Char_InOutByRef(ref cTemp), "[Error] Location tc5"); + + cTemp = GetValidChar(); + char cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc6"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc7"); + } + + static void testCharBufferString() + { + Assert.Throws(() => CharBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + Assert.Throws(() => CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs4"); + + cTemp = GetInvalidString(); + Assert.Throws(() => CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs5"); + + cTemp = GetValidString(); + String cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs6"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs7"); + } + + static void testCharBufferStringBuilder() + { + Assert.Throws(() => CharBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb4"); + + cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + + cTemp = GetValidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb6"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb7"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PFT/AFT_PFT.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PFT/AFT_PFT.csproj new file mode 100644 index 0000000..19004f1 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PFT/AFT_PFT.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + AFT_PFT + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PTF/AFT_PTF.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PTF/AFT_PTF.cs new file mode 100644 index 0000000..352fa25 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PTF/AFT_PTF.cs @@ -0,0 +1,194 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(false, ThrowOnUnmappableChar = true)] + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.IsTrue(Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + char cTempClone = cTemp; + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc3"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc4"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc5"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc6"); + + cTemp = GetInvalidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc7"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tc8"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc9"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc10"); + } + + static void testCharBufferString() + { + Assert.IsTrue(CharBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs4"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs5"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs6"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs7"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tcbs8"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Locationtcbs9"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs10"); + } + + static void testCharBufferStringBuilder() + { + Assert.IsTrue(CharBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb4"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb6"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb7"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb8"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb9"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb10"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PTF/AFT_PTF.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PTF/AFT_PTF.csproj new file mode 100644 index 0000000..333f28f --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PTF/AFT_PTF.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + AFT_PTF + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PTT/AFT_PTT.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PTT/AFT_PTT.cs new file mode 100644 index 0000000..c3e1448 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PTT/AFT_PTT.cs @@ -0,0 +1,182 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(false, ThrowOnUnmappableChar = true)] + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.IsTrue(Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + char cTempClone = GetInvalidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc3"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc4"); + + cTemp = GetInvalidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc5"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc6"); + } + + static void testCharBufferString() + { + Assert.IsTrue(CharBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = GetInvalidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs4"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs5"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs6"); + } + + static void testCharBufferStringBuilder() + { + Assert.IsTrue(CharBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb4"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb6"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PTT/AFT_PTT.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PTT/AFT_PTT.csproj new file mode 100644 index 0000000..1945f5b --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/AFT_PTT/AFT_PTT.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + AFT_PTT + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PFF/ATF_PFF.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PFF/ATF_PFF.cs new file mode 100644 index 0000000..65743cb --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PFF/ATF_PFF.cs @@ -0,0 +1,182 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(true, ThrowOnUnmappableChar = false)] + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.IsTrue(Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc3"); + + cTemp = GetValidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc4"); + + cTemp = GetInvalidChar(); + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc5"); + Assert.AreEqual('?', cTemp, "[Error] Location tc6"); + + cTemp = GetValidChar(); + char cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc7"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc8"); + } + + static void testCharBufferString() + { + Assert.IsTrue(CharBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs4"); + + cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs5"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tcbs6"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs7"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs8"); + } + + static void testCharBufferStringBuilder() + { + StringBuilder sb = GetInvalidStringBuilder(); + Assert.IsTrue(CharBuffer_In_StringBuilder(sb), "[Error] Location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb4"); + + cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb6"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb7"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb8"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PFF/ATF_PFF.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PFF/ATF_PFF.csproj new file mode 100644 index 0000000..1c2dc11 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PFF/ATF_PFF.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + ATF_PFF + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PFT/ATF_PFT.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PFT/ATF_PFT.cs new file mode 100644 index 0000000..7d7ce5d --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PFT/ATF_PFT.cs @@ -0,0 +1,175 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(true, ThrowOnUnmappableChar = false)] + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.Throws(() => Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + Assert.Throws(() => Char_InByRef(ref cTemp), "[Error] Location tc3"); + + cTemp = GetValidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc4"); + + cTemp = GetInvalidChar(); + Assert.Throws(() => Char_InOutByRef(ref cTemp), "[Error] Location tc5"); + + cTemp = GetValidChar(); + char cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc6"); + } + + static void testCharBufferString() + { + Assert.Throws(() => CharBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + Assert.Throws(() => CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs4"); + + cTemp = GetInvalidString(); + Assert.Throws(() => CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs5"); + + cTemp = GetValidString(); + String cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs6"); + } + + static void testCharBufferStringBuilder() + { + Assert.Throws(() => CharBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb4"); + + cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + + cTemp = GetValidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb6"); + + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb7"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PFT/ATF_PFT.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PFT/ATF_PFT.csproj new file mode 100644 index 0000000..d4d25d8 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PFT/ATF_PFT.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + ATF_PFT + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PTF/ATF_PTF.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PTF/ATF_PTF.cs new file mode 100644 index 0000000..284587f --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PTF/ATF_PTF.cs @@ -0,0 +1,194 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(true, ThrowOnUnmappableChar = false)] + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.IsTrue(Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + char cTempClone = cTemp; + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc3"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc4"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc5"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc6"); + + cTemp = GetInvalidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc7"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tc8"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc9"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc10"); + } + + static void testCharBufferString() + { + Assert.IsTrue(CharBuffer_In_String(GetInvalidString()), "Error location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "Error location tcbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "Error location tcbs3"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs4"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "Error location tcbs5"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs6"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "Error location tcbs7"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tcbs8"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "Error location tcbs9"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs10"); + } + + static void testCharBufferStringBuilder() + { + Assert.IsTrue(CharBuffer_In_StringBuilder(GetInvalidStringBuilder()), "Error location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "Error location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "Error location tcbsb3"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "Error location tcbsb4"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "Error location tcbsb5"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "Error location tcbsb6"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "Error location tcbsb7"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "Error location tcbsb8"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "Error location tcbsb9"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "Error location tcbsb10"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PTF/ATF_PTF.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PTF/ATF_PTF.csproj new file mode 100644 index 0000000..e19e134 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PTF/ATF_PTF.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + ATF_PTF + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PTT/ATF_PTT.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PTT/ATF_PTT.cs new file mode 100644 index 0000000..726480e --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PTT/ATF_PTT.cs @@ -0,0 +1,182 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(true, ThrowOnUnmappableChar = false)] + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.IsTrue(Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + char cTempClone = GetInvalidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc3"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc4"); + + cTemp = GetInvalidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc5"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc6"); + } + + static void testCharBufferString() + { + Assert.IsTrue(CharBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = GetInvalidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs4"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs5"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs6"); + } + + static void testCharBufferStringBuilder() + { + Assert.IsTrue(CharBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb4"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb6"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PTT/ATF_PTT.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PTT/ATF_PTT.csproj new file mode 100644 index 0000000..3c1bb92 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATF_PTT/ATF_PTT.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + ATF_PTT + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PFF/ATT_PFF.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PFF/ATT_PFF.cs new file mode 100644 index 0000000..d73a5ac --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PFF/ATT_PFF.cs @@ -0,0 +1,182 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(true, ThrowOnUnmappableChar = true)] + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.IsTrue(Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc3"); + + cTemp = GetValidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc4"); + + cTemp = GetInvalidChar(); + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc5"); + Assert.AreEqual('?', cTemp, "[Error] Location tc6"); + + cTemp = GetValidChar(); + char cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc7"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc6"); + } + + static void testCharBufferString() + { + Assert.IsTrue(CharBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs4"); + + cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs5"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tcbs6"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs7"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs8"); + } + + static void testCharBufferStringBuilder() + { + StringBuilder sb = GetInvalidStringBuilder(); + Assert.IsTrue(CharBuffer_In_StringBuilder(sb), "[Error] Location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb4"); + + cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb6"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb7"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb8"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PFF/ATT_PFF.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PFF/ATT_PFF.csproj new file mode 100644 index 0000000..d84322f --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PFF/ATT_PFF.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + ATT_PFF + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PFT/ATT_PFT.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PFT/ATT_PFT.cs new file mode 100644 index 0000000..91ea8ef --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PFT/ATT_PFT.cs @@ -0,0 +1,176 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(true, ThrowOnUnmappableChar = true)] + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.Throws(() => Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + Assert.Throws(() => Char_InByRef(ref cTemp), "[Error] Location tc3"); + + cTemp = GetValidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location t4"); + + cTemp = GetInvalidChar(); + Assert.Throws(() => Char_InOutByRef(ref cTemp), "[Error] Location tc55"); + + cTemp = GetValidChar(); + char cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc6"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc7"); + } + + static void testCharBufferString() + { + Assert.Throws(() => CharBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + Assert.Throws(() => CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs4"); + + cTemp = GetInvalidString(); + Assert.Throws(() => CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs5"); + + cTemp = GetValidString(); + String cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs6"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs7"); + } + + static void testCharBufferStringBuilder() + { + Assert.Throws(() => CharBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb4"); + + cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + + cTemp = GetValidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb6"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb7"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PFT/ATT_PFT.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PFT/ATT_PFT.csproj new file mode 100644 index 0000000..0d84e2c --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PFT/ATT_PFT.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + ATT_PFT + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PTF/ATT_PTF.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PTF/ATT_PTF.cs new file mode 100644 index 0000000..feef5e9 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PTF/ATT_PTF.cs @@ -0,0 +1,194 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(true, ThrowOnUnmappableChar = true)] + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.IsTrue(Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + char cTempClone = cTemp; + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc3"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc4"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc5"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc6"); + + cTemp = GetInvalidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc7"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tc8"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc9"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc10"); + } + + static void testCharBufferString() + { + Assert.IsTrue(CharBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs4"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs5"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs6"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs7"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tcbs8"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs9"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs10"); + } + + static void testCharBufferStringBuilder() + { + Assert.IsTrue(CharBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb4"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb6"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb7"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb8"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb9"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb10"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PTF/ATT_PTF.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PTF/ATT_PTF.csproj new file mode 100644 index 0000000..543f7d0 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PTF/ATT_PTF.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + ATT_PTF + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PTT/ATT_PTT.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PTT/ATT_PTT.cs new file mode 100644 index 0000000..f9c4dcd --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PTT/ATT_PTT.cs @@ -0,0 +1,182 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(true, ThrowOnUnmappableChar = true)] + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.IsTrue(Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + char cTempClone = GetInvalidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc3"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc4"); + + cTemp = GetInvalidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc5"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc6"); + } + + static void testCharBufferString() + { + Assert.IsTrue(CharBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = GetInvalidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs4"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs5"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs6"); + } + + static void testCharBufferStringBuilder() + { + Assert.IsTrue(CharBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb4"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb6"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PTT/ATT_PTT.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PTT/ATT_PTT.csproj new file mode 100644 index 0000000..610dc28 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/ATT_PTT/ATT_PTT.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + ATT_PTT + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_False_False/Assembly_False_False.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_False_False/Assembly_False_False.cs new file mode 100644 index 0000000..f3bcaf7 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_False_False/Assembly_False_False.cs @@ -0,0 +1,182 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(false, ThrowOnUnmappableChar = false)] + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative")] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.IsTrue(Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc3"); + + cTemp = GetValidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc4"); + + cTemp = GetInvalidChar(); + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc5"); + Assert.AreEqual('?', cTemp, "[Error] Location tc6"); + + cTemp = GetValidChar(); + char cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc7"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc8"); + } + + static void testCharBufferString() + { + Assert.IsTrue(CharBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs4"); + + cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs5"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tcbs6"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs7"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs8"); + } + + static void testCharBufferStringBuilder() + { + StringBuilder sb = GetInvalidStringBuilder(); + Assert.IsTrue(CharBuffer_In_StringBuilder(sb), "[Error] Location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb4"); + + cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb6"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb7"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb8"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_False_False/Assembly_False_False.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_False_False/Assembly_False_False.csproj new file mode 100644 index 0000000..827b819 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_False_False/Assembly_False_False.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + Assembly_False_False + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_False_True/Assembly_False_True.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_False_True/Assembly_False_True.cs new file mode 100644 index 0000000..e4f77ce --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_False_True/Assembly_False_True.cs @@ -0,0 +1,176 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(false, ThrowOnUnmappableChar = true)] + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative")] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.Throws(() => Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + Assert.Throws(() => Char_InByRef(ref cTemp), "[Error] Location tc3"); + + cTemp = GetValidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc4"); + + cTemp = GetInvalidChar(); + Assert.Throws(() => Char_InOutByRef(ref cTemp), "[Error] Location tc5"); + + cTemp = GetValidChar(); + char cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc6"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc7"); + } + + static void testCharBufferString() + { + Assert.Throws(() => CharBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + Assert.Throws(() => CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs4"); + + cTemp = GetInvalidString(); + Assert.Throws(() => CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs5"); + + cTemp = GetValidString(); + String cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs6"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs7"); + } + + static void testCharBufferStringBuilder() + { + Assert.Throws(() => CharBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb4"); + + cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + + cTemp = GetValidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb6"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb7"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_False_True/Assembly_False_True.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_False_True/Assembly_False_True.csproj new file mode 100644 index 0000000..8bed898 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_False_True/Assembly_False_True.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + Assembly_False_True + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_True_False/Assembly_True_False.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_True_False/Assembly_True_False.cs new file mode 100644 index 0000000..fbe5742 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_True_False/Assembly_True_False.cs @@ -0,0 +1,231 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(true, ThrowOnUnmappableChar = false)] + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative")] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool Char_InOut_ArrayWithOffset([In, Out]ArrayWithOffset charArrayWithOffset); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.IsTrue(Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + char cTempClone = cTemp; + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc3"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc4"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc5"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc6"); + + cTemp = GetInvalidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc7"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tc8"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc9"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc10"); + } + + static void testCharBufferString() + { + Assert.IsTrue(CharBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs4"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs5"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs6"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs7"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tcbs8"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs9"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs10"); + } + + static void testCharBufferStringBuilder() + { + Assert.IsTrue(CharBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb4"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb6"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb7"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb8"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb9"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb10"); + } + + static char[] GetInvalidArray() + { + char[] c = new char[3]; + + c[0] = (char)0x2216; + c[1] = (char)0x2216; + c[2] = (char)0x2216; + + return c; + } + + static char[] GetValidArray() + { + char[] c = new char[3]; + + c[0] = 'a'; + c[1] = 'b'; + c[2] = 'c'; + + return c; + } + + static void testCharArrayWithOffset() + { + char[] c = GetInvalidArray(); + ArrayWithOffset arrWOff_0 = new ArrayWithOffset(c, 0); + Assert.IsTrue(Char_InOut_ArrayWithOffset(arrWOff_0), "[Error] Location ctlpsawo11"); + + c = GetValidArray(); + ArrayWithOffset arrWOff_1 = new ArrayWithOffset(c, 1); + Assert.IsTrue(Char_InOut_ArrayWithOffset(arrWOff_1), "[Error] Location ctlpsawo22"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + testCharArrayWithOffset(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_True_False/Assembly_True_False.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_True_False/Assembly_True_False.csproj new file mode 100644 index 0000000..5f3a467 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_True_False/Assembly_True_False.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + Assembly_True_False + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_True_True/Assembly_True_True.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_True_True/Assembly_True_True.cs new file mode 100644 index 0000000..ac07323 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_True_True/Assembly_True_True.cs @@ -0,0 +1,183 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(true, ThrowOnUnmappableChar = true)] + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative")] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative")] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.IsTrue(Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + char cTempClone = GetInvalidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc3"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc4"); + + cTemp = GetInvalidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc5"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc6"); + } + + static void testCharBufferString() + { + Assert.IsTrue(CharBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = GetInvalidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs4"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs5"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs6"); + } + + static void testCharBufferStringBuilder() + { + Assert.IsTrue(CharBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb4"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb6"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_True_True/Assembly_True_True.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_True_True/Assembly_True_True.csproj new file mode 100644 index 0000000..c889e45 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/Assembly_True_True/Assembly_True_True.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + Assembly_True_True + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/BestFitMappingNative.cpp b/tests/src/Interop/PInvoke/BestFitMapping/Char/BestFitMappingNative.cpp new file mode 100644 index 0000000..d8a0a2f --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/BestFitMappingNative.cpp @@ -0,0 +1,98 @@ +// 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 +#include +#include +#include + + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE Char_In(char c) +{ + printf ("Char_In "); + printf ("%c",c); + printf ("\n"); + + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE Char_InByRef(char* c) +{ + printf ("Char_InByRef "); + printf ("%c",*c); + printf ("\n"); + + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE Char_InOutByRef(char* c) +{ + printf ("Char_InOutByRef "); + printf ("%c",*c); + printf ("\n"); + + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE CharBuffer_In_String(char* c) +{ + printf ("native %s \n", c); + + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE CharBuffer_InByRef_String(char** c) +{ + printf ("native %s \n", *c); + + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE CharBuffer_InOutByRef_String(char** c) +{ + printf ("native %s \n", *c); + + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE CharBuffer_In_StringBuilder(char* c) +{ + printf ("native %s \n", c); + + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE CharBuffer_InByRef_StringBuilder(char** c) +{ + printf ("native %s \n", *c); + + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE CharBuffer_InOutByRef_StringBuilder(char** c) +{ + printf ("native %s \n", *c); + + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE Char_In_ArrayWithOffset (char* pArrayWithOffset) +{ + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE Char_InOut_ArrayWithOffset (char* pArrayWithOffset) +{ + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE Char_InByRef_ArrayWithOffset (char** ppArrayWithOffset) +{ + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE Char_InOutByRef_ArrayWithOffset (char** ppArrayWithOffset) +{ + return TRUE; +} diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/CMakeLists.txt b/tests/src/Interop/PInvoke/BestFitMapping/Char/CMakeLists.txt new file mode 100644 index 0000000..430abbe --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/CMakeLists.txt @@ -0,0 +1,12 @@ +#VCXPROJ +cmake_minimum_required (VERSION 2.6) +project (Char_BestFitMappingNative) +include ("${CLR_INTEROP_TEST_ROOT}/Interop.cmake") +include_directories(${INC_PLATFORM_DIR}) +set(SOURCES + BestFitMappingNative.cpp +) +add_library (Char_BestFitMappingNative SHARED ${SOURCES}) +target_link_libraries(Char_BestFitMappingNative ${LINK_LIBRARIES_ADDITIONAL}) +# add the install targets +install (TARGETS Char_BestFitMappingNative DESTINATION bin) diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_False_False/Pinvoke_False_False.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_False_False/Pinvoke_False_False.cs new file mode 100644 index 0000000..b62b02d --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_False_False/Pinvoke_False_False.cs @@ -0,0 +1,180 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.IsTrue(Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc3"); + + cTemp = GetValidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location t4"); + + cTemp = GetInvalidChar(); + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc55"); + Assert.AreEqual('?', cTemp, "[Error] Location tc6"); + + cTemp = GetValidChar(); + char cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc7"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc6"); + } + + static void testCharBufferString() + { + Assert.IsTrue(CharBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs4"); + + cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs5"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tcbs6"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs77"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs8"); + } + + static void testCharBufferStringBuilder() + { + StringBuilder sb = GetInvalidStringBuilder(); + Assert.IsTrue(CharBuffer_In_StringBuilder(sb), "[Error] Location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb4"); + + cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb6"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb7"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb8"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_False_False/Pinvoke_False_False.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_False_False/Pinvoke_False_False.csproj new file mode 100644 index 0000000..a7649f5 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_False_False/Pinvoke_False_False.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + Pinvoke_False_False + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_False_True/Pinvoke_False_True.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_False_True/Pinvoke_False_True.cs new file mode 100644 index 0000000..a49669c --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_False_True/Pinvoke_False_True.cs @@ -0,0 +1,174 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.Throws(() => Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + Assert.Throws(() => Char_InByRef(ref cTemp), "[Error] Location tc3"); + + cTemp = GetValidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc4"); + + cTemp = GetInvalidChar(); + Assert.Throws(() => Char_InOutByRef(ref cTemp), "[Error] Location tc5"); + + cTemp = GetValidChar(); + char cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc6"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc7"); + } + + static void testCharBufferString() + { + Assert.Throws(() => CharBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + Assert.Throws(() => CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs4"); + + cTemp = GetInvalidString(); + Assert.Throws(() => CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs5"); + + cTemp = GetValidString(); + String cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs6"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs7"); + } + + static void testCharBufferStringBuilder() + { + Assert.Throws(() => CharBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb4"); + + cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + + cTemp = GetValidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb6"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb7"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_False_True/Pinvoke_False_True.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_False_True/Pinvoke_False_True.csproj new file mode 100644 index 0000000..7fbd92b --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_False_True/Pinvoke_False_True.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + Pinvoke_False_True + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_True_False/Pinvoke_True_False.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_True_False/Pinvoke_True_False.cs new file mode 100644 index 0000000..2a13da8 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_True_False/Pinvoke_True_False.cs @@ -0,0 +1,192 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.IsTrue(Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + char cTempClone = cTemp; + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc3"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc4"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc5"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc6"); + + cTemp = GetInvalidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc7"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tc8"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc9"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tc10"); + } + + static void testCharBufferString() + { + Assert.IsTrue(CharBuffer_In_String(GetInvalidString()), "Error location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "Error location tcbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "Error location tcbs3"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs4"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "Error location tcbs5"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs6"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "Error location tcbs7"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tcbs8"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "Error location tcbs9"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs10"); + } + + static void testCharBufferStringBuilder() + { + Assert.IsTrue(CharBuffer_In_StringBuilder(GetInvalidStringBuilder()), "Error location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "Error location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "Error location tcbsb3"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb4"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "Error location tcbsb5"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb6"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "Error location tcbsb7"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb8"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "Error location tcbsb9"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb10"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_True_False/Pinvoke_True_False.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_True_False/Pinvoke_True_False.csproj new file mode 100644 index 0000000..3f8263c --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_True_False/Pinvoke_True_False.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + Pinvoke_True_False + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_True_True/Pinvoke_True_True.cs b/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_True_True/Pinvoke_True_True.cs new file mode 100644 index 0000000..97bfa75 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_True_True/Pinvoke_True_True.cs @@ -0,0 +1,180 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +public class BFM_CharMarshaler +{ + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool Char_In([In]char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool Char_InByRef([In]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool Char_InOutByRef([In, Out]ref char c); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_In_String([In]String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InByRef_String([In]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InOutByRef_String([In, Out]ref String s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_In_StringBuilder([In]StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InByRef_StringBuilder([In]ref StringBuilder s); + + [DllImport("Char_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool CharBuffer_InOutByRef_StringBuilder([In, Out]ref StringBuilder s); + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + return sbl; + } + + static char GetInvalidChar() + { + return (char)0x2216; + } + + static char GetValidChar() + { + return 'c'; + } + + static void testChar() + { + Assert.IsTrue(Char_In(GetInvalidChar()), "[Error] Location tc1"); + + Assert.IsTrue(Char_In(GetValidChar()), "[Error] Location tc2"); + + char cTemp = GetInvalidChar(); + char cTempClone = GetInvalidChar(); + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc3"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InByRef(ref cTemp), "[Error] Location tc4"); + + cTemp = GetInvalidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location t5"); + + cTemp = GetValidChar(); + cTempClone = cTemp; + Assert.IsTrue(Char_InOutByRef(ref cTemp), "[Error] Location tc6"); + } + + static void testCharBufferString() + { + Assert.IsTrue(CharBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(CharBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = GetInvalidString(); + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs4"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs5"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs6"); + } + + static void testCharBufferStringBuilder() + { + Assert.IsTrue(CharBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tcbsb1"); + + Assert.IsTrue(CharBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb4"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(CharBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb6"); + } + + static void runTest() + { + testChar(); + testCharBufferString(); + testCharBufferStringBuilder(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_True_True/Pinvoke_True_True.csproj b/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_True_True/Pinvoke_True_True.csproj new file mode 100644 index 0000000..84f2dc6 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/Char/Pinvoke_True_True/Pinvoke_True_True.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + Pinvoke_True_True + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PFF/AFF_PFF.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PFF/AFF_PFF.cs new file mode 100644 index 0000000..2c955af --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PFF/AFF_PFF.cs @@ -0,0 +1,358 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(false, ThrowOnUnmappableChar = false)] + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(false, ThrowOnUnmappableChar = false)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(false, ThrowOnUnmappableChar = false)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.IsTrue(LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs4"); + + cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs5"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tcbs6"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs7"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs88"); + } + + static void testLPStrBufferStringBuilder() + { + StringBuilder sb = GetInvalidStringBuilder(); + Assert.IsTrue(LPStrBuffer_In_StringBuilder(sb), "[Error] Location tcbsb1"); + + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); +; + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb4"); + + cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb6"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb7"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tcbsb8"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferStruct() + { + LPStrTestStruct lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Struct_String(lpss), "[Error] Location tlpsbs1"); + + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbs2"); + + LPStrTestStruct cTemp = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbs3"); + + cTemp = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbs4"); + + cTemp = GetInvalidStruct(); + LPStrTestStruct cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbs5"); + Assert.AreNotEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbs6"); + + cTemp = GetValidStruct(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbs7"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbs8"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass lpss = new LPStrTestClass(); + lpss.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(lpss), "[Error] Location tlpsbc1"); + + lpss.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(lpss), "[Error] Location tlpsbc2"); + + LPStrTestClass cTemp = new LPStrTestClass(); + cTemp.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc3"); + + cTemp.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc4"); + + cTemp.str = GetInvalidString(); + LPStrTestClass cTempClone = new LPStrTestClass(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc5"); + Assert.AreNotEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbc6"); + + cTemp.str = GetValidString(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc7"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbc8"); + } + + static void testLPStrBufferArray() + { + String[] lpss = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(lpss), "[Error] Location tlpsba1"); + + Assert.IsTrue(LPStrBuffer_In_Array_String(GetValidArray()), "[Error] Location tlpsba2"); + + String[] cTemp = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba3"); + + cTemp = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba4"); + + cTemp = GetInvalidArray(); + String[] cTempClone = new String[3]; + cTempClone[0] = cTemp[0]; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba5"); + Assert.AreNotEqual(cTempClone[0], cTemp[0], "[Error] Location tlpsba6"); + + cTemp = GetValidArray(); + cTempClone[0] = cTemp[0]; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba7"); + Assert.AreEqual(cTempClone[0], cTemp[0], "[Error] Location tlpsba8"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsba11"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsba22"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsba33"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsba44"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + + LPStrTestStruct[] lpssClone = new LPStrTestStruct[2]; + lpssClone[0].str = lpss[0].str; + lpssClone[1].str = lpss[1].str; + + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsba55"); + Assert.AreNotEqual(lpssClone[0].str, lpss[0].str, "[Error] Location tlpsba66"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + + lpssClone = new LPStrTestStruct[2]; + lpssClone[0].str = lpss[0].str; + lpssClone[1].str = lpss[1].str; + + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsba77"); + Assert.AreEqual(lpssClone[0].str, lpss[0].str, "[Error] Location tlpsba88"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PFF/AFF_PFF.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PFF/AFF_PFF.csproj new file mode 100644 index 0000000..c893ece --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PFF/AFF_PFF.csproj @@ -0,0 +1,39 @@ + + + + + Debug + AnyCPU + AFF_PFF + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PFT/AFF_PFT.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PFT/AFF_PFT.cs new file mode 100644 index 0000000..a34b14b --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PFT/AFF_PFT.cs @@ -0,0 +1,345 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(false, ThrowOnUnmappableChar = false)] + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(false, ThrowOnUnmappableChar = true)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(false, ThrowOnUnmappableChar = true)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + // struct attribute should override PI flags for BFM + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.Throws(() => LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tlpsbs1"); + + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tlpsbs2"); + + String cTemp = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs4"); + + cTemp = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs5"); + + cTemp = GetValidString(); + String cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs6"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs7"); + } + + static void testLPStrBufferStringBuilder() + { + Assert.Throws(() => LPStrBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tlpsbsb1"); + + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tlpsbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb4"); + + cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb5"); + + cTemp = GetValidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb6"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb7"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferStruct() + { + Assert.Throws(() => LPStrBuffer_In_Struct_String(GetInvalidStruct()), "[Error] Location tlpsbst1"); + + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst2"); + + LPStrTestStruct cTemp = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst3"); + + cTemp = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst4"); + + cTemp = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst5"); + + cTemp = GetValidStruct(); + LPStrTestStruct cTempClone = new LPStrTestStruct(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst6"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbst7"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass cTest = new LPStrTestClass(); + cTest.str = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_In_Class_String(cTest), "[Error] Location tlpsbc1"); + + cTest.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(cTest), "[Error] Location tlpsbc2"); + + LPStrTestClass cTemp = new LPStrTestClass(); + cTemp.str = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc3"); + + cTemp.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc4"); + + cTemp.str = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc5"); + + LPStrTestClass cTempClone = new LPStrTestClass(); + cTemp.str = GetValidString(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc6"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbc7"); + } + + static void testLPStrBufferArray() + { + String[] cTest = null; + cTest = GetInvalidArray(); + Assert.Throws(() => LPStrBuffer_In_Array_String(cTest), "[Error] Location tlpsba1"); + + cTest = GetValidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(cTest), "[Error] Location tlpsba2"); + + String[] cTemp = GetInvalidArray(); + Assert.Throws(() => LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba3"); + + cTemp = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba4"); + + cTemp = GetInvalidArray(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba5"); + + String[] cTempClone = new String[3]; + cTemp = GetValidArray(); + cTempClone[0] = cTemp[0]; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba6"); + Assert.AreEqual(cTempClone[0], cTemp[0], "[Error] Location tlpsba7"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = null; + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos1"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + LPStrTestStruct[] lpssClone = new LPStrTestStruct[2]; + lpssClone[0].str = lpss[0].str; + lpssClone[1].str = lpss[1].str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos6"); + Assert.AreEqual(lpss[0].str, lpssClone[0].str, "[Error] Location tlpsbaos7"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } + catch (Exception e) + { + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PFT/AFF_PFT.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PFT/AFF_PFT.csproj new file mode 100644 index 0000000..36f3a37 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PFT/AFF_PFT.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + AFF_PFT + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PTF/AFF_PTF.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PTF/AFF_PTF.cs new file mode 100644 index 0000000..95c3be7 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PTF/AFF_PTF.cs @@ -0,0 +1,342 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(false, ThrowOnUnmappableChar = false)] + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(true, ThrowOnUnmappableChar = false)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(true, ThrowOnUnmappableChar = false)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.IsTrue(LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tlpsbs1"); + + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tlpsbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs3"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs4"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs5"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs6"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs7"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tlpsbs8"); + + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs9"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs10"); + } + + static void testLPStrBufferStringBuilder() + { + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tlpsbsb1"); + + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tlpsbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb3"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb4"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb5"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb6"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb7"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb8"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb9"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb10"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static void testLPStrBufferStruct() + { + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetInvalidStruct()), "[Error] Location tlpsbst1"); + + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst2"); + + LPStrTestStruct lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst3"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst4"); + + lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst5"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst6"); + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferArray() + { + String[] s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba1"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba2"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba3"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba4"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba5"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba6"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass sClass = new LPStrTestClass(); + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpsbc1"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpsbc2"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpsbc3"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpsbc4"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpsbc5"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpsbc6"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos1"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos6"); + + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } + catch (Exception e) + { + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PTF/AFF_PTF.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PTF/AFF_PTF.csproj new file mode 100644 index 0000000..171581f --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PTF/AFF_PTF.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + AFF_PTF + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PTT/AFF_PTT.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PTT/AFF_PTT.cs new file mode 100644 index 0000000..aa0b82e --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PTT/AFF_PTT.cs @@ -0,0 +1,331 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(false, ThrowOnUnmappableChar = false)] + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(true, ThrowOnUnmappableChar = true)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(true, ThrowOnUnmappableChar = true)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.IsTrue(LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tlpsbs1"); + + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tlpsbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs3"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs4"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs5"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs6"); + } + + static void testLPStrBufferStringBuilder() + { + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tlpsbsb1"); + + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tlpsbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb3"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb4"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb5"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb6"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static void testLPStrBufferStruct() + { + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetInvalidStruct()), "[Error] Location tlpsbst1"); + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst2"); + + LPStrTestStruct lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst3"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst4"); + + lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst5"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst6"); + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferArray() + { + String[] s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba1"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba2"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba3"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba4"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba5"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba6"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass sClass = new LPStrTestClass(); + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpsbc1"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpsbc2"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpsbc3"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpsbc4"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpsbc5"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpsbc6"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos1"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos6"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } + catch (Exception e) + { + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PTT/AFF_PTT.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PTT/AFF_PTT.csproj new file mode 100644 index 0000000..0f5152e --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFF_PTT/AFF_PTT.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + AFF_PTT + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PFF/AFT_PFF.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PFF/AFT_PFF.cs new file mode 100644 index 0000000..24dee80 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PFF/AFT_PFF.cs @@ -0,0 +1,354 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(false, ThrowOnUnmappableChar = true)] + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(false, ThrowOnUnmappableChar = false)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(false, ThrowOnUnmappableChar = false)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.IsTrue(LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs4"); + + cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs5"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tcbs6"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs7"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tcbs8"); + } + + static void testLPStrBufferStringBuilder() + { + StringBuilder sb = GetInvalidStringBuilder(); + Assert.IsTrue(LPStrBuffer_In_StringBuilder(sb), "[Error] Location tlpsbsb1"); + + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tlpsbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb4"); + + cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb5"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb6"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb7"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb8"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferStruct() + { + LPStrTestStruct lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Struct_String(lpss), "[Error] Location tlpsbst1"); + + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst2"); + + LPStrTestStruct cTemp = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst3"); + + cTemp = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst4"); + + cTemp = GetInvalidStruct(); + LPStrTestStruct cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst5"); + Assert.AreNotEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbst6"); + + cTemp = GetValidStruct(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst7"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbst8"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass lpss = new LPStrTestClass(); + lpss.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(lpss), "[Error] Location tlpsbc1"); + + lpss.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(lpss), "[Error] Location tlpsbc2"); + + LPStrTestClass cTemp = new LPStrTestClass(); + cTemp.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc3"); + + cTemp.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc4"); + + cTemp.str = GetInvalidString(); + LPStrTestClass cTempClone = new LPStrTestClass(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc5"); + Assert.AreNotEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbc6"); + + cTemp.str = GetValidString(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc7"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbc8"); + } + + static void testLPStrBufferArray() + { + String[] lpss = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(lpss), "[Error] Location tlpsba1"); + Assert.IsTrue(LPStrBuffer_In_Array_String(GetValidArray()), "[Error] Location tlpsba2"); + + String[] cTemp = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba3"); + + cTemp = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba4"); + + cTemp = GetInvalidArray(); + String[] cTempClone = new String[3]; + cTempClone[0] = cTemp[0]; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba5"); + Assert.AreNotEqual(cTempClone[0], cTemp[0], "[Error] Location ttlpsba6"); + + cTemp = GetValidArray(); + cTempClone[0] = cTemp[0]; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba7"); + Assert.AreEqual(cTempClone[0], cTemp[0], "[Error] Location tlpsba8"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos1"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + LPStrTestStruct[] lpssClone = new LPStrTestStruct[2]; + lpssClone[0].str = lpss[0].str; + lpssClone[1].str = lpss[1].str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + Assert.AreNotEqual(lpss[0].str, lpssClone[0].str, "[Error] Location tlpsbaos6"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + lpssClone = new LPStrTestStruct[2]; + lpssClone[0].str = lpss[0].str; + lpssClone[1].str = lpss[1].str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos7"); + Assert.AreEqual(lpss[0].str, lpssClone[0].str, "[Error] Location tlpsbaos8"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } + catch (Exception e) + { + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PFF/AFT_PFF.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PFF/AFT_PFF.csproj new file mode 100644 index 0000000..9a50cc5 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PFF/AFT_PFF.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + AFT_PFF + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PFT/AFT_PFT.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PFT/AFT_PFT.cs new file mode 100644 index 0000000..4b57b4d --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PFT/AFT_PFT.cs @@ -0,0 +1,343 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(false, ThrowOnUnmappableChar = true)] + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(false, ThrowOnUnmappableChar = true)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(false, ThrowOnUnmappableChar = true)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.Throws(() => LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tlpsbs1"); + + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tlpsbs2"); + + String cTemp = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs4"); + + cTemp = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs5"); + + cTemp = GetValidString(); + String cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs6"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs7"); + } + + static void testLPStrBufferStringBuilder() + { + Assert.Throws(() => LPStrBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tlpsbsb1"); + + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tlpsbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb4"); + + cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb5"); + + cTemp = GetValidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb6"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb7"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferStruct() + { + Assert.Throws(() => LPStrBuffer_In_Struct_String(GetInvalidStruct()), "[Error] Location tlpsbst1"); + + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst2"); + + LPStrTestStruct cTemp = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst3"); + + cTemp = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst4"); + + cTemp = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst5"); + + cTemp = GetValidStruct(); + LPStrTestStruct cTempClone = new LPStrTestStruct(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst6"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbst7"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass cTest = new LPStrTestClass(); + cTest.str = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_In_Class_String(cTest), "[Error] Location tlpsbc1"); + + cTest.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(cTest), "[Error] Location tlpsbc2"); + + LPStrTestClass cTemp = new LPStrTestClass(); + cTemp.str = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc3"); + + cTemp.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc4"); + + cTemp.str = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc5"); + + cTemp.str = GetValidString(); + LPStrTestClass cTempClone = new LPStrTestClass(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc6"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbc7"); + } + + static void testLPStrBufferArray() + { + String[] cTest = null; + cTest = GetInvalidArray(); + Assert.Throws(() => LPStrBuffer_In_Array_String(cTest), "[Error] Location tlpsba1"); + + cTest = GetValidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(cTest), "[Error] Location tlpsba2"); + + String[] cTemp = GetInvalidArray(); + Assert.Throws(() => LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba3"); + + cTemp = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba4"); + + cTemp = GetInvalidArray(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba5"); + + cTemp = GetValidArray(); + String[] cTempClone = new String[3]; + cTempClone[0] = cTemp[0]; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba6"); + Assert.AreEqual(cTempClone[0], cTemp[0], "[Error] Location tlpsba7"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = null; + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos1"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + LPStrTestStruct[] lpssClone = new LPStrTestStruct[2]; + lpssClone[0].str = lpss[0].str; + lpssClone[1].str = lpss[1].str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos6"); + Assert.AreEqual(lpss[0].str, lpssClone[0].str, "[Error] Location tlpsbaos7"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } + catch (Exception e) + { + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PFT/AFT_PFT.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PFT/AFT_PFT.csproj new file mode 100644 index 0000000..19004f1 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PFT/AFT_PFT.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + AFT_PFT + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PTF/AFT_PTF.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PTF/AFT_PTF.cs new file mode 100644 index 0000000..9f5b274 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PTF/AFT_PTF.cs @@ -0,0 +1,337 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(false, ThrowOnUnmappableChar = true)] + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(true, ThrowOnUnmappableChar = false)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(true, ThrowOnUnmappableChar = false)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.IsTrue(LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tlpsbs1"); + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tlpsbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs3"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs4"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs5"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs6"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs7"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tlpsbs8"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs9"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs10"); + } + + static void testLPStrBufferStringBuilder() + { + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tlpsbsb1"); + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tlpsbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb3"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb4"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb5"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb6"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb7"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb8"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb9"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb10"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static void testLPStrBufferStruct() + { + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetInvalidStruct()), "[Error] Location tlpsbst1"); + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst2"); + + LPStrTestStruct lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst3"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst4"); + + lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst5"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst6"); + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferArray() + { + String[] s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba1"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba2"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba3"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba4"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba5"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba6"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass sClass = new LPStrTestClass(); + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpsbc1"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpsbc2"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpsbc3"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpsbc4"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpsbc5"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpsbc6"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos1"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos6"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } + catch (Exception e) + { + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PTF/AFT_PTF.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PTF/AFT_PTF.csproj new file mode 100644 index 0000000..333f28f --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PTF/AFT_PTF.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + AFT_PTF + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PTT/AFT_PTT.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PTT/AFT_PTT.cs new file mode 100644 index 0000000..86e9f89 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PTT/AFT_PTT.cs @@ -0,0 +1,365 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + + +[assembly: BestFitMapping(false, ThrowOnUnmappableChar = true)] + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(true)] +public struct LPStrTestStruct_nothrow +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(true, ThrowOnUnmappableChar = true)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(true, ThrowOnUnmappableChar = true)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Struct_String_nothrow([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct_nothrow strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.IsTrue(LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tlpsbs1"); + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tlpsbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs3"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs4"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs5"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs6"); + } + + static void testLPStrBufferStringBuilder() + { + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tlpsbsb1"); + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tlpsbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb3"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb4"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb5"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb6"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static LPStrTestStruct_nothrow GetInvalidStruct_nothrow() + { + LPStrTestStruct_nothrow inValidStruct = new LPStrTestStruct_nothrow(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + static LPStrTestStruct_nothrow GetValidStruct_nothrow() + { + LPStrTestStruct_nothrow validStruct = new LPStrTestStruct_nothrow(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static void testLPStrBufferStruct() + { + LPStrTestStruct_nothrow lpss_nt = GetInvalidStruct_nothrow(); + Assert.IsTrue(LPStrBuffer_In_Struct_String_nothrow(lpss_nt), "[Error] Location tlpsbst1"); + + lpss_nt = GetValidStruct_nothrow(); + Assert.IsTrue(LPStrBuffer_In_Struct_String_nothrow(lpss_nt), "[Error] Location tlpsbst2"); + + LPStrTestStruct lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Struct_String(lpss), "[Error] Location tlpsbst3"); + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst4"); + + lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst5"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst6"); + + lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst7"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst8"); + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferArray() + { + String[] s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba1"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba2"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba3"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba4"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba5"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba6"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass sClass = new LPStrTestClass(); + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpsbc1"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpsbc2"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpsbc3"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpsbc4"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpsbc5"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpsbc6"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos1"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos6"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } + catch (Exception e) + { + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PTT/AFT_PTT.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PTT/AFT_PTT.csproj new file mode 100644 index 0000000..1945f5b --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/AFT_PTT/AFT_PTT.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + AFT_PTT + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PFF/ATF_PFF.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PFF/ATF_PFF.cs new file mode 100644 index 0000000..48d940c --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PFF/ATF_PFF.cs @@ -0,0 +1,353 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(true, ThrowOnUnmappableChar = false)] + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(false, ThrowOnUnmappableChar = false)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(false, ThrowOnUnmappableChar = false)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.IsTrue(LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tlpsbs1"); + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tlpsbs2"); + + String cTemp = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs4"); + + cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs5"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tlpsbs6"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs7"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs8"); + } + + static void testLPStrBufferStringBuilder() + { + StringBuilder sb = GetInvalidStringBuilder(); + Assert.IsTrue(LPStrBuffer_In_StringBuilder(sb), "[Error] Location tlpsbsb1"); + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tlpsbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb4"); + + cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb5"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb6"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb7"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb8"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferStruct() + { + LPStrTestStruct lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Struct_String(lpss), "[Error] Location tlpsbst1"); + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst2"); + + LPStrTestStruct cTemp = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst3"); + + cTemp = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst4"); + + cTemp = GetInvalidStruct(); + LPStrTestStruct cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst5"); + Assert.AreNotEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbst6"); + + cTemp = GetValidStruct(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst7"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbst8"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass lpss = new LPStrTestClass(); + lpss.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(lpss), "[Error] Location tlpsbc1"); + + lpss.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(lpss), "[Error] Location tlpsbc2"); + + LPStrTestClass cTemp = new LPStrTestClass(); + cTemp.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc3"); + + cTemp.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc4"); + + cTemp.str = GetInvalidString(); + LPStrTestClass cTempClone = new LPStrTestClass(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc5"); + Assert.AreNotEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbc6"); + + cTemp.str = GetValidString(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc7"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbc8"); + } + + static void testLPStrBufferArray() + { + String[] lpss = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(lpss), "[Error] Location tlpsba1"); + Assert.IsTrue(LPStrBuffer_In_Array_String(GetValidArray()), "[Error] Location tlpsba2"); + + String[] cTemp = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba3"); + + cTemp = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba4"); + + cTemp = GetInvalidArray(); + String[] cTempClone = new String[3]; + cTempClone[0] = cTemp[0]; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba5"); + Assert.AreNotEqual(cTempClone[0], cTemp[0], "[Error] Location tlpsba6"); + + cTemp = GetValidArray(); + cTempClone[0] = cTemp[0]; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba7"); + Assert.AreEqual(cTempClone[0], cTemp[0], "[Error] Location tlpsba8"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos1"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + + LPStrTestStruct[] lpssClone = new LPStrTestStruct[2]; + lpssClone[0].str = lpss[0].str; + lpssClone[1].str = lpss[1].str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + Assert.AreNotEqual(lpss[0].str, lpssClone[0].str, "[Error] Location tlpsbaos6"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + lpssClone = new LPStrTestStruct[2]; + lpssClone[0].str = lpss[0].str; + lpssClone[1].str = lpss[1].str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos7"); + Assert.AreEqual(lpss[0].str, lpssClone[0].str, "[Error] Location tlpsbaos8"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } + catch (Exception e) + { + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PFF/ATF_PFF.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PFF/ATF_PFF.csproj new file mode 100644 index 0000000..1c2dc11 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PFF/ATF_PFF.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + ATF_PFF + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PFT/ATF_PFT.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PFT/ATF_PFT.cs new file mode 100644 index 0000000..86a0571 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PFT/ATF_PFT.cs @@ -0,0 +1,341 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(true, ThrowOnUnmappableChar = false)] + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(false, ThrowOnUnmappableChar = true)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(false, ThrowOnUnmappableChar = true)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.Throws(() => LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tlpsbs1"); + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tlpsbs2"); + + String cTemp = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs4"); + + cTemp = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs5"); + + cTemp = GetValidString(); + String cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs6"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs7"); + } + + static void testLPStrBufferStringBuilder() + { + Assert.Throws(() => LPStrBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tlpsbsb1"); + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tlpsbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb4"); + + cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb5"); + + cTemp = GetValidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb6"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb7"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferStruct() + { + Assert.Throws(() => LPStrBuffer_In_Struct_String(GetInvalidStruct()), "[Error] Location tlpsbst1"); + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst2"); + + LPStrTestStruct cTemp = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst3"); + + cTemp = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst4"); + + cTemp = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst5"); + + cTemp = GetValidStruct(); + LPStrTestStruct cTempClone = new LPStrTestStruct(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst6"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbst7"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass cTest = new LPStrTestClass(); + cTest.str = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_In_Class_String(cTest), "[Error] Location tlpsbc1"); + + cTest.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(cTest), "[Error] Location tlpsbc2"); + + LPStrTestClass cTemp = new LPStrTestClass(); + cTemp.str = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc3"); + + cTemp.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc4"); + + cTemp.str = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc5"); + + cTemp.str = GetValidString(); + LPStrTestClass cTempClone = new LPStrTestClass(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc6"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbc7"); + } + + static void testLPStrBufferArray() + { + String[] cTest = null; + cTest = GetInvalidArray(); + Assert.Throws(() => LPStrBuffer_In_Array_String(cTest), "[Error] Location tlpsba1"); + + cTest = GetValidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(cTest), "[Error] Location tlpsba2"); + + String[] cTemp = GetInvalidArray(); + Assert.Throws(() => LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba3"); + + cTemp = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba4"); + + cTemp = GetInvalidArray(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba5"); + + cTemp = GetValidArray(); + String[] cTempClone = new String[3]; + cTempClone[0] = cTemp[0]; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba6"); + Assert.AreEqual(cTempClone[0], cTemp[0], "[Error] Location tlpsba7"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = null; + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos1"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + LPStrTestStruct[] lpssClone = new LPStrTestStruct[2]; + lpssClone[0].str = lpss[0].str; + lpssClone[1].str = lpss[1].str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos6"); + Assert.AreEqual(lpss[0].str, lpssClone[0].str, "[Error] Location tlpsbaos7"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } + catch (Exception e) + { + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PFT/ATF_PFT.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PFT/ATF_PFT.csproj new file mode 100644 index 0000000..d4d25d8 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PFT/ATF_PFT.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + ATF_PFT + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PTF/ATF_PTF.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PTF/ATF_PTF.cs new file mode 100644 index 0000000..19f1ae5 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PTF/ATF_PTF.cs @@ -0,0 +1,338 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(true, ThrowOnUnmappableChar = false)] + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(true, ThrowOnUnmappableChar = false)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(true, ThrowOnUnmappableChar = false)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.IsTrue(LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tlpsbs1"); + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tlpsbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs3"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs4"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs5"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs6"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs7"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tlpsbs8"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs9"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs10"); + } + + static void testLPStrBufferStringBuilder() + { + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tlpsbsb1"); + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tlpsbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb3"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb4"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb5"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb6"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb7"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb8"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb9"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb10"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static void testLPStrBufferStruct() + { + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetInvalidStruct()), "[Error] Location tlpsbst1"); + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst2"); + + LPStrTestStruct lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst3"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst4"); + + lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst5"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst6"); + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferArray() + { + String[] s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba1"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba2"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba3"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba4"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba5"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba6"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass sClass = new LPStrTestClass(); + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpsbc1"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpsbc2"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpsbc3"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpsbc4"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpsbc5"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpsbc6"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos1"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos6"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } + catch (Exception e) + { + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PTF/ATF_PTF.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PTF/ATF_PTF.csproj new file mode 100644 index 0000000..e19e134 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PTF/ATF_PTF.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + ATF_PTF + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PTT/ATF_PTT.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PTT/ATF_PTT.cs new file mode 100644 index 0000000..3961ae6 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PTT/ATF_PTT.cs @@ -0,0 +1,330 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(true, ThrowOnUnmappableChar = false)] + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(true, ThrowOnUnmappableChar = true)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(true, ThrowOnUnmappableChar = true)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.IsTrue(LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tlpsbs1"); + + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tlpsbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs3"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs4"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs5"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs6"); + } + + static void testLPStrBufferStringBuilder() + { + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tlpsbsb1"); + + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tlpsbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb3"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb4"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb5"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb6"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static void testLPStrBufferStruct() + { + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetInvalidStruct()), "[Error] Location tlpsbst1"); + + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst2"); + + LPStrTestStruct lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst3"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst4"); + + lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst5"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst6"); + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferArray() + { + String[] s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba1"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba2"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba3"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba4"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba5"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba6"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass sClass = new LPStrTestClass(); + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpbc1"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpbc2"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpbc3"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpbc4"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpbc5"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpbc6"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos1"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos6"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PTT/ATF_PTT.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PTT/ATF_PTT.csproj new file mode 100644 index 0000000..3c1bb92 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATF_PTT/ATF_PTT.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + ATF_PTT + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PFF/ATT_PFF.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PFF/ATT_PFF.cs new file mode 100644 index 0000000..3c6e5f2 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PFF/ATT_PFF.cs @@ -0,0 +1,355 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(true, ThrowOnUnmappableChar = true)] + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(false, ThrowOnUnmappableChar = false)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(false, ThrowOnUnmappableChar = false)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.IsTrue(LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tlpsbs1"); + + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tlpsbs2"); + + String cTemp = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs4"); + + cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs5"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tlpsbs6"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs7"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs6"); + } + + static void testLPStrBufferStringBuilder() + { + StringBuilder sb = GetInvalidStringBuilder(); + Assert.IsTrue(LPStrBuffer_In_StringBuilder(sb), "[Error] Location tlpsbsb1"); + + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tlpsbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb4"); + + cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb5"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb6"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb7"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb8"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferStruct() + { + LPStrTestStruct lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Struct_String(lpss), "[Error] Location tlpsbst1"); + + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst2"); + + LPStrTestStruct cTemp = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst3"); + + cTemp = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst4"); + + cTemp = GetInvalidStruct(); + LPStrTestStruct cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst5"); + Assert.AreNotEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbsqt6"); + + cTemp = GetValidStruct(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst7"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbst8"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass lpss = new LPStrTestClass(); + lpss.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(lpss), "[Error] Location tlpsbc1"); + + lpss.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(lpss), "[Error] Location tlpsbc2"); + + LPStrTestClass cTemp = new LPStrTestClass(); + cTemp.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc3"); + + cTemp.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc4"); + + cTemp.str = GetInvalidString(); + LPStrTestClass cTempClone = new LPStrTestClass(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc5"); + Assert.AreNotEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbc6"); + + cTemp.str = GetValidString(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc7"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbc8"); + } + + static void testLPStrBufferArray() + { + String[] lpss = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(lpss), "[Error] Location tlpsba1"); + + Assert.IsTrue(LPStrBuffer_In_Array_String(GetValidArray()), "[Error] Location tlpsba2"); + + String[] cTemp = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba3"); + + cTemp = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba4"); + + cTemp = GetInvalidArray(); + String[] cTempClone = new String[3]; + cTempClone[0] = cTemp[0]; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba5"); + Assert.AreNotEqual(cTempClone[0], cTemp[0], "[Error] Location tlpsba6"); + + cTemp = GetValidArray(); + cTempClone[0] = cTemp[0]; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba7"); + Assert.AreEqual(cTempClone[0], cTemp[0], "[Error] Location tlpsba8"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos1"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + LPStrTestStruct[] lpssClone = new LPStrTestStruct[2]; + lpssClone[0].str = lpss[0].str; + lpssClone[1].str = lpss[1].str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + Assert.AreNotEqual(lpssClone[0].str, lpss[0].str, "[Error] Location tlpsbaos6"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + lpssClone = new LPStrTestStruct[2]; + lpssClone[0].str = lpss[0].str; + lpssClone[1].str = lpss[1].str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos7"); + Assert.AreEqual(lpssClone[0].str, lpss[0].str, "[Error] Location tlpsbaos8"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PFF/ATT_PFF.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PFF/ATT_PFF.csproj new file mode 100644 index 0000000..d84322f --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PFF/ATT_PFF.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + ATT_PFF + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PFT/ATT_PFT.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PFT/ATT_PFT.cs new file mode 100644 index 0000000..2717198 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PFT/ATT_PFT.cs @@ -0,0 +1,344 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(true, ThrowOnUnmappableChar = true)] + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(false, ThrowOnUnmappableChar = true)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(false, ThrowOnUnmappableChar = true)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.Throws(() => LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tlpsbs1"); + + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tlpsbs2"); + + String cTemp = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs4"); + + cTemp = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs5"); + + cTemp = GetValidString(); + String cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs6"); + + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs7"); + } + + static void testLPStrBufferStringBuilder() + { + Assert.Throws(() => LPStrBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tlpsbsb1"); + + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tlpsbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb4"); + + cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb5"); + + cTemp = GetValidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb6"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb7"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferStruct() + { + Assert.Throws(() => LPStrBuffer_In_Struct_String(GetInvalidStruct()), "[Error] Location tlpsbst1"); + + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst2"); + + LPStrTestStruct cTemp = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst3"); + + cTemp = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst4"); + + cTemp = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst5"); + + cTemp = GetValidStruct(); + LPStrTestStruct cTempClone = new LPStrTestStruct(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst6"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbst7"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass cTest = new LPStrTestClass(); + cTest.str = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_In_Class_String(cTest), "[Error] Location tlpsbc1"); + + cTest.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(cTest), "[Error] Location tlpsbc2"); + + LPStrTestClass cTemp = new LPStrTestClass(); + cTemp.str = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc3"); + + cTemp.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc4"); + + cTemp.str = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc5"); + + cTemp.str = GetValidString(); + LPStrTestClass cTempClone = new LPStrTestClass(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc6"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbc7"); + } + + static void testLPStrBufferArray() + { + String[] cTest = null; + cTest = GetInvalidArray(); + Assert.Throws(() => LPStrBuffer_In_Array_String(cTest), "[Error] Location tlpsba1"); + + cTest = GetValidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(cTest), "[Error] Location tlpsba2"); + + String[] cTemp = GetInvalidArray(); + Assert.Throws(() => LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba3"); + + cTemp = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba4"); + + cTemp = GetInvalidArray(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba5"); + + cTemp = GetValidArray(); + String[] cTempClone = new String[3]; + cTempClone[0] = cTemp[0]; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba6"); + Assert.AreEqual(cTempClone[0], cTemp[0], "[Error] Location tlpsba7"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = null; + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos1"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + + LPStrTestStruct[] lpssClone = new LPStrTestStruct[2]; + lpssClone[0].str = lpss[0].str; + lpssClone[1].str = lpss[1].str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos6"); + Assert.AreEqual(lpss[0].str, lpssClone[0].str, "[Error] Location tlpsbaos7"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PFT/ATT_PFT.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PFT/ATT_PFT.csproj new file mode 100644 index 0000000..0d84e2c --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PFT/ATT_PFT.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + ATT_PFT + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PTF/ATT_PTF.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PTF/ATT_PTF.cs new file mode 100644 index 0000000..fde1e0d --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PTF/ATT_PTF.cs @@ -0,0 +1,339 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(true, ThrowOnUnmappableChar = true)] + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(true, ThrowOnUnmappableChar = false)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(true, ThrowOnUnmappableChar = false)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.IsTrue(LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tlpsbs1"); + + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tlpsbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs3"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs4"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs5"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs6"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs7"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tlpsbs8"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs9"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs10"); + } + + static void testLPStrBufferStringBuilder() + { + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tlpsbsb1"); + + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tlpsbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb3"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb4"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb5"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb6"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb7"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb8"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb9"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb10"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static void testLPStrBufferStruct() + { + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetInvalidStruct()), "[Error] Location tlpsbst1"); + + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst2"); + + LPStrTestStruct lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst3"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst4"); + + lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst5"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst6"); + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferArray() + { + String[] s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba1"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba2"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba3"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba4"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba5"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba6"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass sClass = new LPStrTestClass(); + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpbc1"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpbc2"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpbc3"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpbc4"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpbc5"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpbc6"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos1"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos6"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PTF/ATT_PTF.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PTF/ATT_PTF.csproj new file mode 100644 index 0000000..543f7d0 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PTF/ATT_PTF.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + ATT_PTF + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PTT/ATT_PTT.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PTT/ATT_PTT.cs new file mode 100644 index 0000000..9318fd6 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PTT/ATT_PTT.cs @@ -0,0 +1,332 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(true, ThrowOnUnmappableChar = true)] + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(true, ThrowOnUnmappableChar = true)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(true, ThrowOnUnmappableChar = true)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.IsTrue(LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tlpsbs1"); + + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tlpsbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs3"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs4"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs5"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs6"); + } + + static void testLPStrBufferStringBuilder() + { + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tlpsbsb1"); + + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tlpsbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb3"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb4"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb5"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb6"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static void testLPStrBufferStruct() + { + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetInvalidStruct()), "[Error] Location tlpsbst1"); + + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst2"); + + LPStrTestStruct lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst3"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst4"); + + lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst5"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst6"); + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferArray() + { + String[] s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba1"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba2"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba3"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba4"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba5"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba6"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass sClass = new LPStrTestClass(); + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpbc1"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpbc2"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpbc3"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpbc4"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpbc5"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpbc6"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos1"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos6"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PTT/ATT_PTT.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PTT/ATT_PTT.csproj new file mode 100644 index 0000000..610dc28 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/ATT_PTT/ATT_PTT.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + ATT_PTT + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_False_False/Assembly_False_False.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_False_False/Assembly_False_False.cs new file mode 100644 index 0000000..ca2efb0 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_False_False/Assembly_False_False.cs @@ -0,0 +1,350 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(false, ThrowOnUnmappableChar = false)] + +[StructLayout(LayoutKind.Sequential)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.IsTrue(LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tlpsbs1"); + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tlpsbs2"); + + String cTemp = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs4"); + + cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs5"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tlpsbs6"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs7"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs8"); + } + + static void testLPStrBufferStringBuilder() + { + StringBuilder sb = GetInvalidStringBuilder(); + Assert.IsTrue(LPStrBuffer_In_StringBuilder(sb), "[Error] Location tlpsbsb1"); + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tlpsbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb4"); + + cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb5"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb6"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb7"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb8"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferStruct() + { + LPStrTestStruct lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Struct_String(lpss), "[Error] Location tlpsbst1"); + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst2"); + + LPStrTestStruct cTemp = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst3"); + + cTemp = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst4"); + + cTemp = GetInvalidStruct(); + LPStrTestStruct cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst5"); + Assert.AreNotEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbst6"); + + cTemp = GetValidStruct(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst7"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbst8"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass lpss = new LPStrTestClass(); + lpss.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(lpss), "[Error] Location tlpsbc1"); + + lpss.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(lpss), "[Error] Location tlpsbc2"); + + LPStrTestClass cTemp = new LPStrTestClass(); + cTemp.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc3"); + + cTemp.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc4"); + + cTemp.str = GetInvalidString(); + LPStrTestClass cTempClone = new LPStrTestClass(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc5"); + Assert.AreNotEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbc6"); + + cTemp.str = GetValidString(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc7"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbc8"); + } + + static void testLPStrBufferArray() + { + String[] lpss = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(lpss), "[Error] Location tlpsba1"); + Assert.IsTrue(LPStrBuffer_In_Array_String(GetValidArray()), "[Error] Location tlpsba2"); + + String[] cTemp = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba3"); + + cTemp = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba4"); + + cTemp = GetInvalidArray(); + String[] cTempClone = new String[3]; + cTempClone[0] = cTemp[0]; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba5"); + Assert.AreNotEqual(cTempClone[0], cTemp[0], "[Error] Location tlpsba6"); + + cTemp = GetValidArray(); + cTempClone[0] = cTemp[0]; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba7"); + Assert.AreEqual(cTempClone[0], cTemp[0], "[Error] Location tlpsba8"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos1"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + LPStrTestStruct[] lpssClone = new LPStrTestStruct[2]; + lpssClone[0].str = lpss[0].str; + lpssClone[1].str = lpss[1].str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + Assert.AreNotEqual(lpss[0].str, lpssClone[0].str, "[Error] Location tlpsbaos6"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + lpssClone = new LPStrTestStruct[2]; + lpssClone[0].str = lpss[0].str; + lpssClone[1].str = lpss[1].str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos7"); + Assert.AreEqual(lpss[0].str, lpssClone[0].str , "[Error] Location tlpsbaos8"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } + catch (Exception e) + { + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_False_False/Assembly_False_False.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_False_False/Assembly_False_False.csproj new file mode 100644 index 0000000..827b819 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_False_False/Assembly_False_False.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + Assembly_False_False + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_False_True/Assembly_False_True.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_False_True/Assembly_False_True.cs new file mode 100644 index 0000000..7cca5c2 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_False_True/Assembly_False_True.cs @@ -0,0 +1,339 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(false, ThrowOnUnmappableChar = true)] + +[StructLayout(LayoutKind.Sequential)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.Throws(() => LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tlpsbs1"); + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tlpsbs2"); + + String cTemp = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs4"); + + cTemp = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs5"); + + cTemp = GetValidString(); + String cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs6"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs7"); + } + + static void testLPStrBufferStringBuilder() + { + Assert.Throws(() => LPStrBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tlpsbsb1"); + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tlpsbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb4"); + + cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb5"); + + cTemp = GetValidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb6"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString() , "[Error] Location tlpsbsb7"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferStruct() + { + Assert.Throws(() => LPStrBuffer_In_Struct_String(GetInvalidStruct()), "[Error] Location tlpsbst1"); + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst2"); + + LPStrTestStruct cTemp = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst3"); + + cTemp = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst4"); + + cTemp = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst5"); + + cTemp = GetValidStruct(); + LPStrTestStruct cTempClone = new LPStrTestStruct(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst6"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbst7"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass cTest = new LPStrTestClass(); + cTest.str = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_In_Class_String(cTest), "[Error] Location tlpsbc1"); + + cTest.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(cTest), "[Error] Location tlpsbc2"); + + LPStrTestClass cTemp = new LPStrTestClass(); + cTemp.str = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc3"); + + cTemp.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc4"); + + cTemp.str = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc5"); + + cTemp.str = GetValidString(); + LPStrTestClass cTempClone = new LPStrTestClass(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc6"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbc7"); + } + + static void testLPStrBufferArray() + { + String[] cTest = null; + cTest = GetInvalidArray(); + Assert.Throws(() => LPStrBuffer_In_Array_String(cTest), "[Error] Location tlpsba1"); + + cTest = GetValidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(cTest), "[Error] Location tlpsba2"); + + String[] cTemp = GetInvalidArray(); + Assert.Throws(() => LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba3"); + + cTemp = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba4"); + + cTemp = GetInvalidArray(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba5"); + + cTemp = GetValidArray(); + String[] cTempClone = new String[3]; + cTempClone[0] = cTemp[0]; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba6"); + Assert.AreEqual(cTempClone[0], cTemp[0], "[Error] Location tlpsba7"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = null; + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos1"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + LPStrTestStruct[] lpssClone = new LPStrTestStruct[2]; + lpssClone[0].str = lpss[0].str; + lpssClone[1].str = lpss[1].str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos6"); + Assert.AreEqual(lpss[0].str, lpssClone[0].str, "[Error] Location tlpsbaos7"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } + catch (Exception e) + { + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_False_True/Assembly_False_True.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_False_True/Assembly_False_True.csproj new file mode 100644 index 0000000..8bed898 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_False_True/Assembly_False_True.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + Assembly_False_True + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_True_False/Assembly_True_False.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_True_False/Assembly_True_False.cs new file mode 100644 index 0000000..781ade3 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_True_False/Assembly_True_False.cs @@ -0,0 +1,335 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(true, ThrowOnUnmappableChar = false)] + +[StructLayout(LayoutKind.Sequential)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.IsTrue(LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tlpsbs1"); + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tlpsbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs3"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs4"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs5"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs6"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs7"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tlpsbs8"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs9"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs10"); + } + + static void testLPStrBufferStringBuilder() + { + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tlpsbsb1"); + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tlpsbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb3"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb4"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb5"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb6"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb7"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb8"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb9"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb10"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static void testLPStrBufferStruct() + { + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetInvalidStruct()), "[Error] Location tlpsbst1"); + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst2"); + + LPStrTestStruct lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst3"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst4"); + + lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst5"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst6"); + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferArray() + { + String[] s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba1"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba2"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba3"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba4"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba5"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba6"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass sClass = new LPStrTestClass(); + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpsbc1"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpsbc2"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpsbc3"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpsbc4"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpsbc5"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpsbc6"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos1"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos6"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } + catch (Exception e) + { + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_True_False/Assembly_True_False.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_True_False/Assembly_True_False.csproj new file mode 100644 index 0000000..5f3a467 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_True_False/Assembly_True_False.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + Assembly_True_False + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_True_True/Assembly_True_True.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_True_True/Assembly_True_True.cs new file mode 100644 index 0000000..e2ab60b --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_True_True/Assembly_True_True.cs @@ -0,0 +1,331 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[assembly: BestFitMapping(true, ThrowOnUnmappableChar = true)] + +[StructLayout(LayoutKind.Sequential)] +//[BestFitMapping(true, ThrowOnUnmappableChar=true)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +//[BestFitMapping(true, ThrowOnUnmappableChar=true)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative")] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.IsTrue(LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tlpsbs1"); + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tlpsbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs3"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs4"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs5"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs6"); + + } + + static void testLPStrBufferStringBuilder() + { + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tlpsbsb1"); + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tlpsbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb3"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb4"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb5"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb6"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static void testLPStrBufferStruct() + { + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetInvalidStruct()), "[Error] Location tlpsbst1"); + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst2"); + + LPStrTestStruct lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst3"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst4"); + + lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst5"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst6"); + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferArray() + { + String[] s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba1"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba2"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba3"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba4"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba5"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba6"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass sClass = new LPStrTestClass(); + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpsbc1"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpsbc2"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpsbc3"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpsbc4"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpsbc5"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpsbc6"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos1"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos6"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } + catch (Exception e) + { + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_True_True/Assembly_True_True.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_True_True/Assembly_True_True.csproj new file mode 100644 index 0000000..c889e45 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Assembly_True_True/Assembly_True_True.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + Assembly_True_True + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/BestFitMappingNative.cpp b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/BestFitMappingNative.cpp new file mode 100644 index 0000000..f5326f2 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/BestFitMappingNative.cpp @@ -0,0 +1,146 @@ +// 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 +#include +#include +#include + +typedef struct TLPStr_Test_Struct +{ + LPSTR pStr; +} LPStr_Test_Struct; + +typedef struct TLPStr_Test_Class +{ + LPSTR pStr; +} LPStr_Test_Class; + +typedef struct TLPStrTestStructOfArrays +{ + LPSTR pStr1; + LPSTR pStr2; +} LPStrTestStructOfArrays; + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE LPStrBuffer_In_String(LPSTR pStr) +{ + printf ("xx %s \n", pStr); + + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE LPStrBuffer_InByRef_String(LPSTR* ppStr) +{ + printf ("yy %s \n", *ppStr); + + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE LPStrBuffer_InOutByRef_String(LPSTR* ppStr) +{ + printf ("zz %s \n", *ppStr); + + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE LPStrBuffer_In_StringBuilder(LPSTR pStr) +{ + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE LPStrBuffer_InByRef_StringBuilder(LPSTR* ppStr) +{ + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE LPStrBuffer_InOutByRef_StringBuilder(LPSTR* ppStr) +{ + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE LPStrBuffer_In_Struct_String (LPStr_Test_Struct strStruct) +{ + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE LPStrBuffer_InByRef_Struct_String (LPStr_Test_Struct* pSstrStruct) +{ + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE LPStrBuffer_InOutByRef_Struct_String (LPStr_Test_Struct* pStrStruct) +{ + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE LPStrBuffer_In_Array_String (LPSTR str[]) +{ + printf ("%s \n", str[0]); + printf ("%s \n", str[1]); + printf ("%s \n", str[2]); + + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE LPStrBuffer_InByRef_Array_String (LPSTR* str[]) +{ + printf ("%s \n", (*str)[0]); + printf ("%s \n", (*str)[1]); + printf ("%s \n", (*str)[2]); + + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE LPStrBuffer_InOutByRef_Array_String (LPSTR* str[]) +{ + printf ("%s \n", (*str)[0]); + printf ("%s \n", (*str)[1]); + printf ("%s \n", (*str)[2]); + + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE LPStrBuffer_In_Class_String (LPStr_Test_Class strClass) +{ + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE LPStrBuffer_InByRef_Class_String (LPStr_Test_Class* pSstrClass) +{ + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE LPStrBuffer_InOutByRef_Class_String (LPStr_Test_Class* pStrClass) +{ + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE LPStrBuffer_In_Array_Struct (LPStr_Test_Struct str[]) +{ + printf ("** %s \n", str[0].pStr); + printf ("** %s \n", str[1].pStr); + + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE LPStrBuffer_InByRef_Array_Struct (LPStr_Test_Struct* str[]) +{ + printf ("++ %s \n", (*str)[0].pStr); + printf ("++ %s \n", (*str)[1].pStr); + + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE LPStrBuffer_InOutByRef_Array_Struct (LPStr_Test_Struct* str[]) +{ + printf ("-- %s \n", (*str)[0].pStr); + printf ("-- %s \n", (*str)[1].pStr); + + return TRUE; +} + +extern "C" bool DLL_EXPORT STDMETHODCALLTYPE LPStrBuffer_In_Struct_String_nothrow (LPStr_Test_Struct strStruct) +{ + return TRUE; +} diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/CMakeLists.txt b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/CMakeLists.txt new file mode 100644 index 0000000..a1940ee --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/CMakeLists.txt @@ -0,0 +1,13 @@ +#VCXPROJ +cmake_minimum_required (VERSION 2.6) +project (LPStr_BestFitMappingNative) +include ("${CLR_INTEROP_TEST_ROOT}/Interop.cmake") +include_directories(${INC_PLATFORM_DIR}) +set(SOURCES + BestFitMappingNative.cpp +) + +add_library (LPStr_BestFitMappingNative SHARED ${SOURCES}) +target_link_libraries(LPStr_BestFitMappingNative ${LINK_LIBRARIES_ADDITIONAL}) +# add the install targets +install (TARGETS LPStr_BestFitMappingNative DESTINATION bin) diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_False_False/Pinvoke_False_False.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_False_False/Pinvoke_False_False.cs new file mode 100644 index 0000000..d17d901 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_False_False/Pinvoke_False_False.cs @@ -0,0 +1,353 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(false, ThrowOnUnmappableChar = false)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(false, ThrowOnUnmappableChar = false)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.IsTrue(LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tlpsbs1"); + + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tlpsbs2"); + + String cTemp = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs4"); + + cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs5"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tlpsbs6"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs7"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs8"); + } + + static void testLPStrBufferStringBuilder() + { + StringBuilder sb = GetInvalidStringBuilder(); + Assert.IsTrue(LPStrBuffer_In_StringBuilder(sb), "[Error] Location tlpsbsb1"); + + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tlpsbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb4"); + + cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb5"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb6"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb7"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb8"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferStruct() + { + LPStrTestStruct lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Struct_String(lpss), "[Error] Location tlpsbst1"); + + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst2"); + + LPStrTestStruct cTemp = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst3"); + + cTemp = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst4"); + + cTemp = GetInvalidStruct(); + LPStrTestStruct cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst5"); + Assert.AreNotEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbst6"); + + cTemp = GetValidStruct(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst7"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbst8"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass lpss = new LPStrTestClass(); + lpss.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(lpss), "[Error] Location tlpsbc1"); + + lpss.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(lpss), "[Error] Location tlpsbc2"); + + LPStrTestClass cTemp = new LPStrTestClass(); + cTemp.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc3"); + + cTemp.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc4"); + + cTemp.str = GetInvalidString(); + LPStrTestClass cTempClone = new LPStrTestClass(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc5"); + Assert.AreNotEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbc6"); + + cTemp.str = GetValidString(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc7"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbc8"); + } + + static void testLPStrBufferArray() + { + String[] lpss = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(lpss), "[Error] Location tlpsba1"); + + Assert.IsTrue(LPStrBuffer_In_Array_String(GetValidArray()), "[Error] Location tlpsba2"); + + String[] cTemp = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba3"); + + cTemp = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba4"); + + cTemp = GetInvalidArray(); + String[] cTempClone = new String[3]; + cTempClone[0] = cTemp[0]; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba5"); + Assert.AreNotEqual(cTempClone[0], cTemp[0], "[Error] Location tlpsba6"); + + cTemp = GetValidArray(); + cTempClone[0] = cTemp[0]; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba7"); + Assert.AreEqual(cTempClone[0], cTemp[0], "[Error] Location tlpsba8"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos1"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + LPStrTestStruct[] lpssClone = new LPStrTestStruct[2]; + lpssClone[0].str = lpss[0].str; + lpssClone[1].str = lpss[1].str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + Assert.AreNotEqual(lpss[0].str, lpssClone[0].str, "[Error] Location tlpsbaos6"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + lpssClone = new LPStrTestStruct[2]; + lpssClone[0].str = lpss[0].str; + lpssClone[1].str = lpss[1].str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos7"); + Assert.AreEqual(lpss[0].str, lpssClone[0].str, "[Error] Location tlpsbaos8"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_False_False/Pinvoke_False_False.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_False_False/Pinvoke_False_False.csproj new file mode 100644 index 0000000..a7649f5 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_False_False/Pinvoke_False_False.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + Pinvoke_False_False + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_False_True/Pinvoke_False_True.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_False_True/Pinvoke_False_True.cs new file mode 100644 index 0000000..87e440c --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_False_True/Pinvoke_False_True.cs @@ -0,0 +1,340 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(false, ThrowOnUnmappableChar = true)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(false, ThrowOnUnmappableChar = true)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.Throws(() => LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tlpsbs1"); + + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tlpsbs2"); + + String cTemp = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs3"); + + cTemp = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs4"); + + cTemp = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs5"); + + cTemp = GetValidString(); + String cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs6"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs7"); + } + + static void testLPStrBufferStringBuilder() + { + Assert.Throws(() => LPStrBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tlpsbsb1"); + + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tlpsbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb3"); + + cTemp = GetValidStringBuilder(); + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb4"); + + cTemp = GetInvalidStringBuilder(); + Assert.Throws(() => LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb5"); + + cTemp = GetValidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb6"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb7"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferStruct() + { + Assert.Throws(() => LPStrBuffer_In_Struct_String(GetInvalidStruct()), "[Error] Location tlpsbst1"); + + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst2"); + + LPStrTestStruct cTemp = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst3"); + + cTemp = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst4"); + + cTemp = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst5"); + + cTemp = GetValidStruct(); + LPStrTestStruct cTempClone = new LPStrTestStruct(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref cTemp), "[Error] Location tlpsbst6"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbst7"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass cTest = new LPStrTestClass(); + cTest.str = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_In_Class_String(cTest), "[Error] Location tlpsbc1"); + + cTest.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(cTest), "[Error] Location tlpsbc2"); + + LPStrTestClass cTemp = new LPStrTestClass(); + cTemp.str = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc3"); + + cTemp.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref cTemp), "[Error] Location tlpsbc4"); + + cTemp.str = GetInvalidString(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc5"); + + cTemp.str = GetValidString(); + LPStrTestClass cTempClone = new LPStrTestClass(); + cTempClone.str = cTemp.str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref cTemp), "[Error] Location tlpsbc6"); + Assert.AreEqual(cTempClone.str, cTemp.str, "[Error] Location tlpsbc7"); + } + + static void testLPStrBufferArray() + { + String[] cTest = null; + cTest = GetInvalidArray(); + Assert.Throws(() => LPStrBuffer_In_Array_String(cTest), "[Error] Location tlpsba1"); + + cTest = GetValidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(cTest), "[Error] Location tlpsba2"); + + String[] cTemp = GetInvalidArray(); + Assert.Throws(() => LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba3"); + + cTemp = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref cTemp), "[Error] Location tlpsba4"); + + cTemp = GetInvalidArray(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba5"); + + cTemp = GetValidArray(); + String[] cTempClone = new String[3]; + cTempClone[0] = cTemp[0]; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref cTemp), "[Error] Location tlpsba6"); + Assert.AreEqual(cTempClone[0], cTemp[0], "[Error] Location tlpsba7"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = null; + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos1"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.Throws(() => LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + LPStrTestStruct[] lpssClone = new LPStrTestStruct[2]; + lpssClone[0].str = lpss[0].str; + lpssClone[1].str = lpss[1].str; + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos6"); + Assert.AreEqual(lpss[0].str, lpssClone[0].str, "[Error] Location tlpsbaos7"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_False_True/Pinvoke_False_True.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_False_True/Pinvoke_False_True.csproj new file mode 100644 index 0000000..7fbd92b --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_False_True/Pinvoke_False_True.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + Pinvoke_False_True + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_True_False/Pinvoke_True_False.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_True_False/Pinvoke_True_False.cs new file mode 100644 index 0000000..0b72972 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_True_False/Pinvoke_True_False.cs @@ -0,0 +1,337 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(true, ThrowOnUnmappableChar = false)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(true, ThrowOnUnmappableChar = false)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + sbl.Append('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.IsTrue(LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tlpsbs1"); + + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tlpsbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs3"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs4"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tlpsbs5"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs6"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs7"); + Assert.AreNotEqual(cTempClone, cTemp, "[Error] Location tlpsbs8"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tlpsbs9"); + Assert.AreEqual(cTempClone, cTemp, "[Error] Location tlpsbs10"); + } + + static void testLPStrBufferStringBuilder() + { + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tlpsbsb1"); + + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tlpsbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb3"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb4"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb5"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb6"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb7"); + Assert.AreNotEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb8"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tlpsbsb9"); + Assert.AreEqual(cTempClone.ToString(), cTemp.ToString(), "[Error] Location tlpsbsb10"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static void testLPStrBufferStruct() + { + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetInvalidStruct()), "[Error] Location tlpsbst1"); + + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst2"); + + LPStrTestStruct lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst3"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst4"); + + lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst5"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst6"); + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferArray() + { + String[] s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba1"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba2"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba3"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba4"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba5"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba6"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass sClass = new LPStrTestClass(); + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpsbc1"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpsbc2"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpsbc3"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpsbc4"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpsbc5"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpsbc6"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos11"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos6"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_True_False/Pinvoke_True_False.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_True_False/Pinvoke_True_False.csproj new file mode 100644 index 0000000..3f8263c --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_True_False/Pinvoke_True_False.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + Pinvoke_True_False + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_True_True/Pinvoke_True_True.cs b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_True_True/Pinvoke_True_True.cs new file mode 100644 index 0000000..0ae01d1 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_True_True/Pinvoke_True_True.cs @@ -0,0 +1,329 @@ +// 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.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(true, ThrowOnUnmappableChar = true)] +public struct LPStrTestStruct +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +[StructLayout(LayoutKind.Sequential)] +[BestFitMapping(true, ThrowOnUnmappableChar = true)] +public class LPStrTestClass +{ + [MarshalAs(UnmanagedType.LPStr)] + public String str; +} + +public class BFM_LPStrMarshaler +{ +#pragma warning disable 618 + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_String([In][MarshalAs(UnmanagedType.LPStr)]String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_String([In][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_String([In, Out][MarshalAs(UnmanagedType.LPStr)]ref String s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_StringBuilder([In][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_StringBuilder([In, Out][MarshalAs(UnmanagedType.LPStr)]ref StringBuilder s); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Struct_String([In][MarshalAs(UnmanagedType.Struct)]LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Struct_String([In][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Struct_String([In, Out][MarshalAs(UnmanagedType.Struct)]ref LPStrTestStruct strStruct); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Array_String([In][MarshalAs(UnmanagedType.LPArray)]String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Array_String([In][MarshalAs(UnmanagedType.LPArray)]ref String[] strArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Array_String([In, Out][MarshalAs(UnmanagedType.LPArray)]ref String[] Array); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_In_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InByRef_Class_String([In][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = true, ThrowOnUnmappableChar = true)] + public static extern bool LPStrBuffer_InOutByRef_Class_String([In, Out][MarshalAs(UnmanagedType.LPStruct)]ref LPStrTestClass strClass); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_In_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InByRef_Array_Struct([In][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); + + [DllImport("LPStr_BestFitMappingNative", BestFitMapping = false, ThrowOnUnmappableChar = false)] + public static extern bool LPStrBuffer_InOutByRef_Array_Struct([In, Out][MarshalAs(UnmanagedType.LPArray)]ref LPStrTestStruct[] structArray); +#pragma warning restore 618 + + static String GetValidString() + { + return "This is the initial test string."; + } + + static String GetInvalidString() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + return sbl.ToString(); + } + + static StringBuilder GetValidStringBuilder() + { + StringBuilder sb = new StringBuilder("test string."); + return sb; + } + + static StringBuilder GetInvalidStringBuilder() + { + StringBuilder sbl = new StringBuilder(); + sbl.Append((char)0x2216); + sbl.Append((char)0x2044); + sbl.Append((char)0x2215); + sbl.Append((char)0x0589); + sbl.Append((char)0x2236); + //sbl.Append ('乀'); + return sbl; + } + + static void testLPStrBufferString() + { + Assert.IsTrue(LPStrBuffer_In_String(GetInvalidString()), "[Error] Location tcbs1"); + + Assert.IsTrue(LPStrBuffer_In_String(GetValidString()), "[Error] Location tcbs2"); + + String cTemp = GetInvalidString(); + String cTempClone = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs3"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_String(ref cTemp), "[Error] Location tcbs4"); + + cTemp = GetInvalidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs5"); + + cTemp = GetValidString(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_String(ref cTemp), "[Error] Location tcbs6"); + } + + static void testLPStrBufferStringBuilder() + { + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetInvalidStringBuilder()), "[Error] Location tcbsb1"); + + Assert.IsTrue(LPStrBuffer_In_StringBuilder(GetValidStringBuilder()), "[Error] Location tcbsb2"); + + StringBuilder cTemp = GetInvalidStringBuilder(); + StringBuilder cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb3"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb4"); + + cTemp = GetInvalidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb5"); + + cTemp = GetValidStringBuilder(); + cTempClone = cTemp; + Assert.IsTrue(LPStrBuffer_InOutByRef_StringBuilder(ref cTemp), "[Error] Location tcbsb6"); + } + + static LPStrTestStruct GetInvalidStruct() + { + LPStrTestStruct inValidStruct = new LPStrTestStruct(); + inValidStruct.str = GetInvalidString(); + + return inValidStruct; + } + + + static LPStrTestStruct GetValidStruct() + { + LPStrTestStruct validStruct = new LPStrTestStruct(); + validStruct.str = GetValidString(); + + return validStruct; + } + + static void testLPStrBufferStruct() + { + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetInvalidStruct()), "[Error] Location tlpsbst1"); + + Assert.IsTrue(LPStrBuffer_In_Struct_String(GetValidStruct()), "[Error] Location tlpsbst2"); + + LPStrTestStruct lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst3"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Struct_String(ref lpss), "[Error] Location tlpsbst4"); + + lpss = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst5"); + + lpss = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Struct_String(ref lpss), "[Error] Location tlpsbst6"); + } + + static String[] GetValidArray() + { + String[] s = new String[3]; + + s[0] = GetValidString(); + s[1] = GetValidString(); + s[2] = GetValidString(); + + return s; + } + + static String[] GetInvalidArray() + { + String[] s = new String[3]; + + s[0] = GetInvalidString(); + s[1] = GetInvalidString(); + s[2] = GetInvalidString(); + + return s; + } + + static void testLPStrBufferArray() + { + String[] s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba1"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_In_Array_String(s), "[Error] Location tlpsba2"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba3"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_String(ref s), "[Error] Location tlpsba4"); + + s = GetInvalidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba5"); + + s = GetValidArray(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_String(ref s), "[Error] Location tlpsba6"); + } + + static void testLPStrBufferClass() + { + LPStrTestClass sClass = new LPStrTestClass(); + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpbc1"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_In_Class_String(sClass), "[Error] Location tlpbc2"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpbc3"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InByRef_Class_String(ref sClass), "[Error] Location tlpbc4"); + + sClass.str = GetInvalidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpbc5"); + + sClass.str = GetValidString(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Class_String(ref sClass), "[Error] Location tlpbc6"); + } + + static void testLPStrBufferArrayOfStructs() + { + LPStrTestStruct[] lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos1"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_In_Array_Struct(lpss), "[Error] Location tlpsbaos2"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos3"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos4"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetInvalidStruct(); + lpss[1] = GetInvalidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos5"); + + lpss = new LPStrTestStruct[2]; + lpss[0] = GetValidStruct(); + lpss[1] = GetValidStruct(); + Assert.IsTrue(LPStrBuffer_InOutByRef_Array_Struct(ref lpss), "[Error] Location tlpsbaos6"); + } + + static void runTest() + { + testLPStrBufferString(); + testLPStrBufferStringBuilder(); + testLPStrBufferStruct(); + testLPStrBufferArray(); + testLPStrBufferClass(); + testLPStrBufferArrayOfStructs(); + } + + public static int Main() + { + if (System.Globalization.CultureInfo.CurrentCulture.Name != "en-US") + { + Console.WriteLine("Non english platforms are not supported"); + Console.WriteLine("passing without running tests"); + + Console.WriteLine("--- Success"); + return 100; + } + + try + { + runTest(); + return 100; + } catch (Exception e){ + Console.WriteLine($"Test Failure: {e}"); + return 101; + } + } +} \ No newline at end of file diff --git a/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_True_True/Pinvoke_True_True.csproj b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_True_True/Pinvoke_True_True.csproj new file mode 100644 index 0000000..84f2dc6 --- /dev/null +++ b/tests/src/Interop/PInvoke/BestFitMapping/LPStr/Pinvoke_True_True/Pinvoke_True_True.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + Pinvoke_True_True + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\..\..\ + $(DefineConstants);STATIC + + true + true + + + + + + + False + + + + + + + + + + + + + + + -- 2.7.4