[flutter_plugin_tools] Build gtest unit tests (#4492)

Author: stuartmorgan-g

packages/url_launcher/url_launcher/example/linux/flutter/CMakeLists.txt

@@ -78,7 +78,8 @@ add_custom_command(
  COMMAND ${CMAKE_COMMAND} -E env
  ${FLUTTER_TOOL_ENVIRONMENT}
  "${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.sh"
- linux-x64 ${CMAKE_BUILD_TYPE}
+ ${FLUTTER_TARGET_PLATFORM} ${CMAKE_BUILD_TYPE}
+ VERBATIM
 )
 add_custom_target(flutter_assemble DEPENDS
  "${FLUTTER_LIBRARY}"

packages/url_launcher/url_launcher/example/windows/flutter/generated_plugin_registrant.cc

@@ -6,9 +6,9 @@
 
 #include "generated_plugin_registrant.h"
 
-#include <url_launcher_windows/url_launcher_plugin.h>
+#include <url_launcher_windows/url_launcher_windows.h>
 
 void RegisterPlugins(flutter::PluginRegistry* registry) {
- UrlLauncherPluginRegisterWithRegistrar(
- registry->GetRegistrarForPlugin("UrlLauncherPlugin"));
+ UrlLauncherWindowsRegisterWithRegistrar(
+ registry->GetRegistrarForPlugin("UrlLauncherWindows"));
 }

packages/url_launcher/url_launcher_linux/example/linux/CMakeLists.txt

@@ -45,6 +45,8 @@ add_dependencies(${BINARY_NAME} flutter_assemble)
 
 # Enable the test target.
 set(include_url_launcher_linux_tests TRUE)
+# Provide an alias for the test target using the name expected by repo tooling.
+add_custom_target(unit_tests DEPENDS url_launcher_linux_test)
 
 # Generated plugin build rules, which manage building the plugins and adding
 # them to the application.

packages/url_launcher/url_launcher_windows/example/windows/CMakeLists.txt

@@ -48,6 +48,8 @@ add_subdirectory("runner")
 
 # Enable the test target.
 set(include_url_launcher_windows_tests TRUE)
+# Provide an alias for the test target using the name expected by repo tooling.
+add_custom_target(unit_tests DEPENDS url_launcher_windows_test)
 
 # Generated plugin build rules, which manage building the plugins and adding
 # them to the application.

script/tool/CHANGELOG.md

@@ -1,5 +1,7 @@
 ## NEXT
 
+- `native-test` now builds unit tests before running them on Windows and Linux,
+ matching the behavior of other platforms.
 - Added `--log-timing` to add timing information to package headers in looping
  commands.
 

script/tool/lib/src/common/cmake.dart

@@ -0,0 +1,118 @@
+// 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.
+
+import 'package:file/file.dart';
+import 'package:flutter_plugin_tools/src/common/core.dart';
+import 'package:platform/platform.dart';
+
+import 'process_runner.dart';
+
+const String _cacheCommandKey = 'CMAKE_COMMAND:INTERNAL';
+
+/// A utility class for interacting with CMake projects.
+class CMakeProject {
+ /// Creates an instance that runs commands for [project] with the given
+ /// [processRunner].
+ CMakeProject(
+ this.flutterProject, {
+ required this.buildMode,
+ this.processRunner = const ProcessRunner(),
+ this.platform = const LocalPlatform(),
+ });
+
+ /// The directory of a Flutter project to run Gradle commands in.
+ final Directory flutterProject;
+
+ /// The [ProcessRunner] used to run commands. Overridable for testing.
+ final ProcessRunner processRunner;
+
+ /// The platform that commands are being run on.
+ final Platform platform;
+
+ /// The build mode (e.g., Debug, Release).
+ ///
+ /// This is a constructor paramater because on Linux many properties depend
+ /// on the build mode since it uses a single-configuration generator.
+ final String buildMode;
+
+ late final String _cmakeCommand = _determineCmakeCommand();
+
+ /// The project's platform directory name.
+ String get _platformDirName => platform.isWindows ? 'windows' : 'linux';
+
+ /// The project's 'example' build directory for this instance's platform.
+ Directory get buildDirectory {
+ Directory buildDir =
+ flutterProject.childDirectory('build').childDirectory(_platformDirName);
+ if (platform.isLinux) {
+ buildDir = buildDir
+ // TODO(stuartmorgan): Support arm64 if that ever becomes a supported
+ // CI configuration for the repository.
+ .childDirectory('x64')
+ // Linux uses a single-config generator, so the base build directory
+ // includes the configuration.
+ .childDirectory(buildMode.toLowerCase());
+ }
+ return buildDir;
+ }
+
+ File get _cacheFile => buildDirectory.childFile('CMakeCache.txt');
+
+ /// Returns the CMake command to run build commands for this project.
+ ///
+ /// Assumes the project has been built at least once, such that the CMake
+ /// generation step has run.
+ String getCmakeCommand() {
+ return _cmakeCommand;
+ }
+
+ /// Returns the CMake command to run build commands for this project. This is
+ /// used to initialize _cmakeCommand, and should not be called directly.
+ ///
+ /// Assumes the project has been built at least once, such that the CMake
+ /// generation step has run.
+ String _determineCmakeCommand() {
+ // On Linux 'cmake' is expected to be in the path, so doesn't need to
+ // be lookup up and cached.
+ if (platform.isLinux) {
+ return 'cmake';
+ }
+ final File cacheFile = _cacheFile;
+ String? command;
+ for (String line in cacheFile.readAsLinesSync()) {
+ line = line.trim();
+ if (line.startsWith(_cacheCommandKey)) {
+ command = line.substring(line.indexOf('=') + 1).trim();
+ break;
+ }
+ }
+ if (command == null) {
+ printError('Unable to find CMake command in ${cacheFile.path}');
+ throw ToolExit(100);
+ }
+ return command;
+ }
+
+ /// Whether or not the project is ready to have CMake commands run on it
+ /// (i.e., whether the `flutter` tool has generated the necessary files).
+ bool isConfigured() => _cacheFile.existsSync();
+
+ /// Runs a `cmake` command with the given parameters.
+ Future<int> runBuild(
+ String target, {
+ List<String> arguments = const <String>[],
+ }) {
+ return processRunner.runAndStream(
+ getCmakeCommand(),
+ <String>[
+ '--build',
+ buildDirectory.path,
+ '--target',
+ target,
+ if (platform.isWindows) ...<String>['--config', buildMode],
+ ...arguments,
+ ],
+ );
+ }
+}

script/tool/lib/src/common/gradle.dart

@@ -14,9 +14,6 @@ const String _gradleWrapperNonWindows = 'gradlew';
 class GradleProject {
  /// Creates an instance that runs commands for [project] with the given
  /// [processRunner].
- ///
- /// If [log] is true, commands run by this instance will long various status
- /// messages.
  GradleProject(
  this.flutterProject, {
  this.processRunner = const ProcessRunner(),

script/tool/lib/src/native_test_command.dart

@@ -5,6 +5,7 @@
 import 'package:file/file.dart';
 import 'package:platform/platform.dart';
 
+import 'common/cmake.dart';
 import 'common/core.dart';
 import 'common/gradle.dart';
 import 'common/package_looping_command.dart';
@@ -456,8 +457,8 @@ this command.
  file.basename.endsWith('_tests.exe');
  }
 
- return _runGoogleTestTests(plugin,
- buildDirectoryName: 'windows', isTestBinary: isTestBinary);
+ return _runGoogleTestTests(plugin, 'Windows', 'Debug',
+ isTestBinary: isTestBinary);
  }
 
  Future<_PlatformResult> _testLinux(
@@ -471,8 +472,16 @@ this command.
  file.basename.endsWith('_tests');
  }
 
- return _runGoogleTestTests(plugin,
- buildDirectoryName: 'linux', isTestBinary: isTestBinary);
+ // Since Linux uses a single-config generator, building-examples only
+ // generates the build files for release, so the tests have to be run in
+ // release mode as well.
+ //
+ // TODO(stuartmorgan): Consider adding a command to `flutter` that would
+ // generate build files without doing a build, and using that instead of
+ // relying on running build-examples. See
+ // https://github.com/flutter/flutter/issues/93407.
+ return _runGoogleTestTests(plugin, 'Linux', 'Release',
+ isTestBinary: isTestBinary);
  }
 
  /// Finds every file in the [buildDirectoryName] subdirectory of [plugin]'s
@@ -482,38 +491,66 @@ this command.
  /// The binaries are assumed to be Google Test test binaries, thus returning
  /// zero for success and non-zero for failure.
  Future<_PlatformResult> _runGoogleTestTests(
- RepositoryPackage plugin, {
- required String buildDirectoryName,
+ RepositoryPackage plugin,
+ String platformName,
+ String buildMode, {
  required bool Function(File) isTestBinary,
  }) async {
  final List<File> testBinaries = <File>[];
+ bool hasMissingBuild = false;
+ bool buildFailed = false;
  for (final RepositoryPackage example in plugin.getExamples()) {
- final Directory buildDir = example.directory
- .childDirectory('build')
- .childDirectory(buildDirectoryName);
- if (!buildDir.existsSync()) {
+ final CMakeProject project = CMakeProject(example.directory,
+ buildMode: buildMode,
+ processRunner: processRunner,
+ platform: platform);
+ if (!project.isConfigured()) {
+ printError('ERROR: Run "flutter build" on ${example.displayName}, '
+ 'or run this tool\'s "build-examples" command, for the target '
+ 'platform before executing tests.');
+ hasMissingBuild = true;
  continue;
  }
- testBinaries.addAll(buildDir
+
+ // By repository convention, example projects create an aggregate target
+ // called 'unit_tests' that builds all unit tests (usually just an alias
+ // for a specific test target).
+ final int exitCode = await project.runBuild('unit_tests');
+ if (exitCode != 0) {
+ printError('${example.displayName} unit tests failed to build.');
+ buildFailed = true;
+ }
+
+ testBinaries.addAll(project.buildDirectory
  .listSync(recursive: true)
  .whereType<File>()
  .where(isTestBinary)
  .where((File file) {
- // Only run the release build of the unit tests, to avoid running the
- // same tests multiple times. Release is used rather than debug since
- // `build-examples` builds release versions.
+ // Only run the `buildMode` build of the unit tests, to avoid running
+ // the same tests multiple times.
  final List<String> components = path.split(file.path);
- return components.contains('release') || components.contains('Release');
+ return components.contains(buildMode) ||
+ components.contains(buildMode.toLowerCase());
  }));
  }
 
+ if (hasMissingBuild) {
+ return _PlatformResult(RunState.failed,
+ error: 'Examples must be built before testing.');
+ }
+
+ if (buildFailed) {
+ return _PlatformResult(RunState.failed,
+ error: 'Failed to build $platformName unit tests.');
+ }
+
  if (testBinaries.isEmpty) {
  final String binaryExtension = platform.isWindows ? '.exe' : '';
  printError(
  'No test binaries found. At least one *_test(s)$binaryExtension '
  'binary should be built by the example(s)');
  return _PlatformResult(RunState.failed,
- error: 'No $buildDirectoryName unit tests found');
+ error: 'No $platformName unit tests found');
  }
 
  bool passing = true;