flutter_flutter/packages/flutter_tools/test/integration.shard/test_utils.dart

// Copyright 2014 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:file/local.dart';
import 'package:flutter_tools/src/base/io.dart';
import 'package:flutter_tools/src/base/platform.dart';
import 'package:process/process.dart';
import 'package:vm_service/vm_service.dart';

import '../src/common.dart';
import 'test_driver.dart';

/// The [FileSystem] for the integration test environment.
const FileSystem fileSystem = LocalFileSystem();

/// The (real) `flutter` binary (i.e. `{ROOT}/bin/flutter`) to execute in tests.
final String flutterBin = fileSystem.path.join(
  getFlutterRoot(),
  'bin',
  platform.isWindows ? 'flutter.bat' : 'flutter',
);

/// The [Platform] for the integration test environment.
const Platform platform = LocalPlatform();

/// The [ProcessManager] for the integration test environment.
const ProcessManager processManager = LocalProcessManager();

/// Creates a temporary directory but resolves any symlinks to return the real
/// underlying path to avoid issues with breakpoints/hot reload.
/// https://github.com/flutter/flutter/pull/21741
Directory createResolvedTempDirectorySync(String prefix) {
  assert(prefix.endsWith('.'));
  final Directory tempDirectory = fileSystem.systemTempDirectory.createTempSync('flutter_$prefix');
  return fileSystem.directory(tempDirectory.resolveSymbolicLinksSync());
}

void writeFile(String path, String content, {bool writeFutureModifiedDate = false}) {
  final File file = fileSystem.file(path)
    ..createSync(recursive: true)
    ..writeAsStringSync(content, flush: true);
  // Some integration tests on Windows to not see this file as being modified
  // recently enough for the hot reload to pick this change up unless the
  // modified time is written in the future.
  if (writeFutureModifiedDate) {
    file.setLastModifiedSync(DateTime.now().add(const Duration(seconds: 5)));
  }
}

void writeBytesFile(String path, List<int> content) {
  fileSystem.file(path)
    ..createSync(recursive: true)
    ..writeAsBytesSync(content, flush: true);
}

Future<void> getPackages(String folder) async {
  final command = <String>[fileSystem.path.join(getFlutterRoot(), 'bin', 'flutter'), 'pub', 'get'];
  final ProcessResult result = await processManager.run(command, workingDirectory: folder);
  if (result.exitCode != 0) {
    throw Exception('flutter pub get failed: ${result.stderr}\n${result.stdout}');
  }
}

const kLocalEngineEnvironment = 'FLUTTER_LOCAL_ENGINE';
const kLocalEngineHostEnvironment = 'FLUTTER_LOCAL_ENGINE_HOST';
const kLocalEngineLocation = 'FLUTTER_LOCAL_ENGINE_SRC_PATH';

List<String> getLocalEngineArguments() {
  return <String>[
    if (platform.environment.containsKey(kLocalEngineEnvironment))
      '--local-engine=${platform.environment[kLocalEngineEnvironment]}',
    if (platform.environment.containsKey(kLocalEngineLocation))
      '--local-engine-src-path=${platform.environment[kLocalEngineLocation]}',
    if (platform.environment.containsKey(kLocalEngineHostEnvironment))
      '--local-engine-host=${platform.environment[kLocalEngineHostEnvironment]}',
  ];
}

Future<void> pollForServiceExtensionValue<T>({
  required FlutterTestDriver testDriver,
  required String extension,
  required T continuePollingValue,
  required Matcher matches,
  String valueKey = 'value',
}) async {
  for (var i = 0; i < 10; i++) {
    final Response response = await testDriver.callServiceExtension(extension);
    if (response.json?[valueKey] as T == continuePollingValue) {
      await Future<void>.delayed(const Duration(seconds: 1));
    } else {
      expect(response.json?[valueKey] as T, matches);
      return;
    }
  }
  fail(
    "Did not find expected value for service extension '$extension'. All call"
    " attempts responded with '$continuePollingValue'.",
  );
}

abstract final class AppleTestUtils {
  static const requiredSymbols = <String>[
    '_kDartIsolateSnapshotData',
    '_kDartIsolateSnapshotInstructions',
    '_kDartVmSnapshotData',
    '_kDartVmSnapshotInstructions',
  ];

  static List<String> getExportedSymbols(String dwarfPath) {
    final ProcessResult nm = processManager.runSync(<String>[
      'nm',
      '--debug-syms', // nm docs: 'Show all symbols, even debugger only'
      '--defined-only',
      '--just-symbol-name',
      dwarfPath,
      '-arch',
      'arm64',
    ]);
    final String nmOutput = (nm.stdout as String).trim();
    return nmOutput.isEmpty ? const <String>[] : nmOutput.split('\n');
  }
}

/// Matcher to be used for [ProcessResult] returned
/// from a process run
///
/// The default for [exitCode] will be 0 while
/// [stdoutPattern] and [stderrPattern] are both optional
class ProcessResultMatcher extends Matcher {
  const ProcessResultMatcher({this.exitCode = 0, this.stdoutPattern, this.stderrPattern});

  /// The expected exit code to get returned from a process run
  final int exitCode;

  /// Substring to find in the process's stdout
  final Pattern? stdoutPattern;

  /// Substring to find in the process's stderr
  final Pattern? stderrPattern;

  @override
  Description describe(Description description) {
    description.add('a process with exit code $exitCode');
    if (stdoutPattern != null) {
      description.add(' and stdout: "$stdoutPattern"');
    }
    if (stderrPattern != null) {
      description.add(' and stderr: "$stderrPattern"');
    }

    return description;
  }

  @override
  bool matches(dynamic item, Map<dynamic, dynamic> matchState) {
    final result = item as ProcessResult;
    var foundStdout = true;
    var foundStderr = true;

    final stdout = result.stdout as String;
    final stderr = result.stderr as String;
    if (stdoutPattern != null) {
      foundStdout = stdout.contains(stdoutPattern!);
      matchState['stdout'] = stdout;
    } else if (stdout.isNotEmpty) {
      // even if we were not asserting on stdout, show stdout for debug purposes
      matchState['stdout'] = stdout;
    }

    if (stderrPattern != null) {
      foundStderr = stderr.contains(stderrPattern!);
      matchState['stderr'] = stderr;
    } else if (stderr.isNotEmpty) {
      matchState['stderr'] = stderr;
    }

    return result.exitCode == exitCode && foundStdout && foundStderr;
  }

  @override
  Description describeMismatch(
    Object? item,
    Description mismatchDescription,
    Map<dynamic, dynamic> matchState,
    bool verbose,
  ) {
    final result = item! as ProcessResult;

    if (result.exitCode != exitCode) {
      mismatchDescription.add('Actual exitCode was ${result.exitCode}\n');
    }

    if (matchState.containsKey('stdout')) {
      mismatchDescription.add('Actual stdout:\n${matchState["stdout"]}\n');
    }

    if (matchState.containsKey('stderr')) {
      mismatchDescription.add('Actual stderr:\n${matchState["stderr"]}\n');
    }

    return mismatchDescription;
  }
}