Fixed tests.

packages/local_auth/local_auth_windows/example/lib/main.dart

@@ -104,10 +104,9 @@ class _MyAppState extends State<MyApp> {
       return;
     }
 
-    setState(
-        () {
-          _authorized = authenticated ? 'Authorized' : 'Not Authorized';
-        });
+    setState(() {
+      _authorized = authenticated ? 'Authorized' : 'Not Authorized';
+    });
   }
 
   Future<void> _authenticateWithBiometrics() async {

packages/local_auth/local_auth_windows/example/windows/CMakeLists.txt

@@ -47,7 +47,7 @@ add_subdirectory(${FLUTTER_MANAGED_DIR})
 add_subdirectory("runner")
 
 # Enable the test target.
-set(local_auth_windows_tests TRUE)
+set(include_local_auth_windows_tests TRUE)
 # Provide an alias for the test target using the name expected by repo tooling.
 add_custom_target(unit_tests DEPENDS local_auth_windows_test)
 

packages/local_auth/local_auth_windows/windows/CMakeLists.txt

@@ -38,9 +38,14 @@ endif()
 
 include_directories(BEFORE SYSTEM ${CMAKE_BINARY_DIR}/include)
 
+list(APPEND PLUGIN_SOURCES
+  "local_auth_plugin.cpp"
+)
+
 add_library(${PLUGIN_NAME} SHARED
   "include/local_auth_windows/local_auth_plugin.h"
-  "local_auth_plugin.cpp"
+  "local_auth_windows.cpp"
+  "local_auth.h"
   ${PLUGIN_SOURCES}
 )
 apply_standard_settings(${PLUGIN_NAME})
@@ -67,7 +72,6 @@ enable_testing()
 # TODO(stuartmorgan): Consider using a single shared, pre-checked-in googletest
 # instance rather than downloading for each plugin. This approach makes sense
 # for a template, but not for a monorepo with many plugins.
-include(FetchContent)
 FetchContent_Declare(
   googletest
   URL https://github.com/google/googletest/archive/release-1.11.0.zip
@@ -84,11 +88,12 @@ FetchContent_MakeAvailable(googletest)
 add_executable(${TEST_RUNNER}
   test/mocks.h
   test/local_auth_plugin_test.cpp
-  test/local_auth_test.cpp
   ${PLUGIN_SOURCES}
 )
 apply_standard_settings(${TEST_RUNNER})
 target_include_directories(${TEST_RUNNER} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}")
+target_compile_features(${TEST_RUNNER} PRIVATE cxx_std_20)
+target_compile_options(${TEST_RUNNER} PRIVATE /await)
 target_link_libraries(${TEST_RUNNER} PRIVATE flutter_wrapper_plugin)
 target_link_libraries(${TEST_RUNNER} PRIVATE windowsapp)
 target_link_libraries(${TEST_RUNNER} PRIVATE gtest_main gmock)

packages/local_auth/local_auth_windows/windows/local_auth.h

@@ -0,0 +1,72 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <UserConsentVerifierInterop.h>
+
+#include "include/local_auth_windows/local_auth_plugin.h"
+
+// This must be included before many other Windows headers.
+#include <flutter/encodable_value.h>
+#include <flutter/method_channel.h>
+#include <flutter/plugin_registrar_windows.h>
+#include <flutter/standard_method_codec.h>
+#include <pplawait.h>
+#include <ppltasks.h>
+#include <windows.h>
+#include <winrt/Windows.Foundation.h>
+#include <winrt/Windows.Security.Credentials.UI.h>
+#include <winstring.h>
+
+#include <map>
+#include <memory>
+#include <sstream>
+
+namespace local_auth_windows {
+
+using namespace flutter;
+using namespace winrt;
+
+class UserConsentVerifier {
+ public:
+  UserConsentVerifier() {}
+  virtual ~UserConsentVerifier() = default;
+
+  virtual Windows::Foundation::IAsyncOperation<
+      Windows::Security::Credentials::UI::UserConsentVerificationResult>
+  RequestVerificationForWindowAsync(std::wstring localizedReason) = 0;
+  virtual Windows::Foundation::IAsyncOperation<
+      Windows::Security::Credentials::UI::UserConsentVerifierAvailability>
+  CheckAvailabilityAsync() = 0;
+
+  // Disallow copy and move.
+  UserConsentVerifier(const UserConsentVerifier&) = delete;
+  UserConsentVerifier& operator=(const UserConsentVerifier&) = delete;
+};
+
+class LocalAuthPlugin : public Plugin {
+ public:
+  static void RegisterWithRegistrar(PluginRegistrarWindows* registrar);
+
+  LocalAuthPlugin(std::function<HWND()> window_provider);
+  LocalAuthPlugin(std::unique_ptr<UserConsentVerifier> user_consent_verifier);
+
+  // Called when a method is called on this plugin's channel from Dart.
+  void HandleMethodCall(const MethodCall<EncodableValue>& method_call,
+                        std::unique_ptr<MethodResult<EncodableValue>> result);
+
+  virtual ~LocalAuthPlugin();
+
+ private:
+  std::unique_ptr<UserConsentVerifier> user_consent_verifier_;
+
+  winrt::fire_and_forget Authenticate(
+      const MethodCall<EncodableValue>& method_call,
+      std::unique_ptr<MethodResult<EncodableValue>> result);
+  winrt::fire_and_forget GetAvailableBiometrics(
+      std::unique_ptr<MethodResult<EncodableValue>> result);
+  winrt::fire_and_forget IsDeviceSupported(
+      std::unique_ptr<MethodResult<EncodableValue>> result);
+};
+
+}  // namespace local_auth_windows

packages/local_auth/local_auth_windows/windows/local_auth_plugin.cpp

@@ -1,26 +1,9 @@
 // Copyright 2013 The Flutter Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
-#include "include/local_auth_windows/local_auth_plugin.h"
-
-// This must be included before many other Windows headers.
-#include <UserConsentVerifierInterop.h>
-#include <flutter/encodable_value.h>
-#include <flutter/method_channel.h>
-#include <flutter/plugin_registrar_windows.h>
-#include <flutter/standard_method_codec.h>
-#include <pplawait.h>
-#include <ppltasks.h>
-#include <windows.h>
-#include <winrt/Windows.Foundation.h>
-#include <winrt/Windows.Security.Credentials.UI.h>
-#include <winstring.h>
-
-#include <map>
-#include <memory>
-#include <sstream>
-
-namespace {
+#include "local_auth.h"
+
+namespace local_auth_windows {
 
 using namespace flutter;
 using namespace winrt;
@@ -45,37 +28,77 @@ HWND GetRootWindow(flutter::FlutterView* view) {
 }
 
 // Converts the given UTF-8 string to UTF-16.
-std::wstring s2ws(const std::string& s) {
-  int len;
-  int slength = (int)s.length() + 1;
-  len = MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, 0, 0);
-  std::wstring r(len, L'\0');
-  MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, &r[0], len);
-  return r;
+std::wstring Utf16FromUtf8(const std::string& utf8_string) {
+  if (utf8_string.empty()) {
+    return std::wstring();
+  }
+  int target_length =
+      ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8_string.data(),
+                            static_cast<int>(utf8_string.length()), nullptr, 0);
+  if (target_length == 0) {
+    return std::wstring();
+  }
+  std::wstring utf16_string;
+  utf16_string.resize(target_length);
+  int converted_length =
+      ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8_string.data(),
+                            static_cast<int>(utf8_string.length()),
+                            utf16_string.data(), target_length);
+  if (converted_length == 0) {
+    return std::wstring();
+  }
+  return utf16_string;
 }
 
-class LocalAuthPlugin : public Plugin {
+class UserConsentVerifierImpl : public UserConsentVerifier {
  public:
-  static void RegisterWithRegistrar(PluginRegistrarWindows* registrar);
+  explicit UserConsentVerifierImpl(std::function<HWND()> window_provider)
+      : get_root_window_(std::move(window_provider)){};
+  virtual ~UserConsentVerifierImpl() = default;
+
+  Windows::Foundation::IAsyncOperation<
+      Windows::Security::Credentials::UI::UserConsentVerificationResult>
+  RequestVerificationForWindowAsync(std::wstring localizedReason) override {
+    auto userConsentVerifierInterop = winrt::get_activation_factory<
+        Windows::Security::Credentials::UI::UserConsentVerifier,
+        IUserConsentVerifierInterop>();
+
+    auto hWnd = get_root_window_();
+
+    HSTRING hReason;
+    if (WindowsCreateString(localizedReason.c_str(),
+                            static_cast<uint32_t>(localizedReason.size()),
+                            &hReason) != S_OK) {
+      return Windows::Security::Credentials::UI::UserConsentVerificationResult::
+          Canceled;
+    }
+
+    auto consentResult =
+        co_await winrt::capture<Windows::Foundation::IAsyncOperation<
+            Windows::Security::Credentials::UI::UserConsentVerificationResult>>(
+            userConsentVerifierInterop,
+            &::IUserConsentVerifierInterop::RequestVerificationForWindowAsync,
+            hWnd, hReason);
 
-  LocalAuthPlugin(flutter::PluginRegistrarWindows* registrar);
+    WindowsDeleteString(hReason);
 
-  virtual ~LocalAuthPlugin();
+    return consentResult;
+  }
+
+  Windows::Foundation::IAsyncOperation<
+      Windows::Security::Credentials::UI::UserConsentVerifierAvailability>
+  CheckAvailabilityAsync() override {
+    return Windows::Security::Credentials::UI::UserConsentVerifier::
+        CheckAvailabilityAsync();
+  }
+
+  // Disallow copy and move.
+  UserConsentVerifierImpl(const UserConsentVerifierImpl&) = delete;
+  UserConsentVerifierImpl& operator=(const UserConsentVerifierImpl&) = delete;
 
  private:
-  flutter::PluginRegistrarWindows* registrar_;
-
-  // Called when a method is called on this plugin's channel from Dart.
-  void HandleMethodCall(const MethodCall<EncodableValue>& method_call,
-                        std::unique_ptr<MethodResult<EncodableValue>> result);
-
-  winrt::fire_and_forget Authenticate(
-      const MethodCall<EncodableValue>& method_call,
-      std::unique_ptr<MethodResult<EncodableValue>> result);
-  winrt::fire_and_forget GetAvailableBiometrics(
-      std::unique_ptr<MethodResult<EncodableValue>> result);
-  winrt::fire_and_forget IsDeviceSupported(
-      std::unique_ptr<MethodResult<EncodableValue>> result);
+  // The provider for the root window to attach the dialog to.
+  std::function<HWND()> get_root_window_;
 };
 
 // static
@@ -84,7 +107,8 @@ void LocalAuthPlugin::RegisterWithRegistrar(PluginRegistrarWindows* registrar) {
       registrar->messenger(), "plugins.flutter.io/local_auth_windows",
       &StandardMethodCodec::GetInstance());
 
-  auto plugin = std::make_unique<LocalAuthPlugin>(registrar);
+  auto plugin = std::make_unique<LocalAuthPlugin>(
+      [registrar]() { return GetRootWindow(registrar->GetView()); });
 
   channel->SetMethodCallHandler(
       [plugin_pointer = plugin.get()](const auto& call, auto result) {
@@ -95,8 +119,13 @@ void LocalAuthPlugin::RegisterWithRegistrar(PluginRegistrarWindows* registrar) {
 }
 
 // Default constructor for LocalAuthPlugin
-LocalAuthPlugin::LocalAuthPlugin(flutter::PluginRegistrarWindows* registrar)
-    : registrar_(registrar) {}
+LocalAuthPlugin::LocalAuthPlugin(std::function<HWND()> window_provider)
+    : user_consent_verifier_(std::make_unique<UserConsentVerifierImpl>(
+          std::move(window_provider))) {}
+
+LocalAuthPlugin::LocalAuthPlugin(
+    std::unique_ptr<UserConsentVerifier> user_consent_verifier)
+    : user_consent_verifier_(std::move(user_consent_verifier)) {}
 
 LocalAuthPlugin::~LocalAuthPlugin() {}
 
@@ -118,7 +147,7 @@ void LocalAuthPlugin::HandleMethodCall(
 winrt::fire_and_forget LocalAuthPlugin::Authenticate(
     const MethodCall<EncodableValue>& method_call,
     std::unique_ptr<MethodResult<EncodableValue>> result) {
-  auto reasonW = s2ws(GetArgument<std::string>(
+  auto reasonW = Utf16FromUtf8(GetArgument<std::string>(
       "localizedReason", method_call.arguments(), std::string()));
 
   auto biometricOnly =
@@ -129,8 +158,8 @@ winrt::fire_and_forget LocalAuthPlugin::Authenticate(
     co_return;
   }
 
-  auto ucvAvailability = co_await Windows::Security::Credentials::UI::
-      UserConsentVerifier::CheckAvailabilityAsync();
+  auto ucvAvailability =
+      co_await user_consent_verifier_->CheckAvailabilityAsync();
 
   if (ucvAvailability ==
       Windows::Security::Credentials::UI::UserConsentVerifierAvailability::
@@ -149,39 +178,26 @@ winrt::fire_and_forget LocalAuthPlugin::Authenticate(
     co_return;
   }
 
-  auto userConsentVerifierInterop = winrt::get_activation_factory<
-      Windows::Security::Credentials::UI::UserConsentVerifier,
-      IUserConsentVerifierInterop>();
-
-  auto hWnd = GetRootWindow(registrar_->GetView());
-
-  HSTRING hReason;
-  WindowsCreateString(reasonW.c_str(), (uint32_t)reasonW.size(), &hReason);
-
   try {
     auto consentResult =
-        co_await winrt::capture<Windows::Foundation::IAsyncOperation<
-            Windows::Security::Credentials::UI::UserConsentVerificationResult>>(
-            userConsentVerifierInterop,
-            &::IUserConsentVerifierInterop::RequestVerificationForWindowAsync,
-            hWnd, hReason);
+        co_await user_consent_verifier_->RequestVerificationForWindowAsync(
+            reasonW);
 
     result->Success(EncodableValue(
         consentResult == Windows::Security::Credentials::UI::
                              UserConsentVerificationResult::Verified));
   } catch (...) {
     result->Success(EncodableValue(false));
   }
-  WindowsDeleteString(hReason);
 }
 
 // Returns biometric types available on device
 winrt::fire_and_forget LocalAuthPlugin::GetAvailableBiometrics(
     std::unique_ptr<MethodResult<EncodableValue>> result) {
   try {
     flutter::EncodableList biometrics;
-    auto ucvAvailability = co_await Windows::Security::Credentials::UI::
-        UserConsentVerifier::CheckAvailabilityAsync();
+    auto ucvAvailability =
+        co_await user_consent_verifier_->CheckAvailabilityAsync();
     if (ucvAvailability == Windows::Security::Credentials::UI::
                                UserConsentVerifierAvailability::Available) {
       biometrics.push_back(EncodableValue("fingerprint"));
@@ -197,18 +213,11 @@ winrt::fire_and_forget LocalAuthPlugin::GetAvailableBiometrics(
 // Returns whether the device supports Windows Hello or not
 winrt::fire_and_forget LocalAuthPlugin::IsDeviceSupported(
     std::unique_ptr<MethodResult<EncodableValue>> result) {
-  auto ucvAvailability = co_await Windows::Security::Credentials::UI::
-      UserConsentVerifier::CheckAvailabilityAsync();
+  auto ucvAvailability =
+      co_await user_consent_verifier_->CheckAvailabilityAsync();
   result->Success(EncodableValue(
       ucvAvailability == Windows::Security::Credentials::UI::
                              UserConsentVerifierAvailability::Available));
 }
 
-}  // namespace
-
-void LocalAuthPluginRegisterWithRegistrar(
-    FlutterDesktopPluginRegistrarRef registrar) {
-  LocalAuthPlugin::RegisterWithRegistrar(
-      PluginRegistrarManager::GetInstance()
-          ->GetRegistrar<PluginRegistrarWindows>(registrar));
-}
+}  // namespace local_auth_windows

packages/local_auth/local_auth_windows/windows/local_auth_windows.cpp

@@ -0,0 +1,15 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <flutter/plugin_registrar_windows.h>
+
+#include "include/local_auth_windows/local_auth_plugin.h"
+#include "local_auth.h"
+
+void LocalAuthPluginRegisterWithRegistrar(
+    FlutterDesktopPluginRegistrarRef registrar) {
+  local_auth_windows::LocalAuthPlugin::RegisterWithRegistrar(
+      flutter::PluginRegistrarManager::GetInstance()
+          ->GetRegistrar<flutter::PluginRegistrarWindows>(registrar));
+}