blob: d97a6a24de0bb1ec95ee88d5225cdffd18becd07 [file] [log] [blame]
// 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 'dart:async';
import 'package:fake_async/fake_async.dart';
import 'package:flutter_tools/src/base/io.dart';
import 'package:flutter_tools/src/base/logger.dart';
import 'package:flutter_tools/src/base/utils.dart';
import 'package:flutter_tools/src/build_info.dart';
import 'package:flutter_tools/src/convert.dart';
import 'package:flutter_tools/src/device.dart';
import 'package:flutter_tools/src/ios/iproxy.dart';
import 'package:flutter_tools/src/project.dart';
import 'package:test/fake.dart';
import '../src/common.dart';
import '../src/fake_devices.dart';
void main() {
group('DeviceManager', () {
testWithoutContext('getDevices', () async {
final FakeDevice device1 = FakeDevice('Nexus 5', '0553790d0a4e726f');
final FakeDevice device2 = FakeDevice('Nexus 5X', '01abfc49119c410e');
final FakeDevice device3 = FakeDevice('iPod touch', '82564b38861a9a5');
final List<Device> devices = <Device>[device1, device2, device3];
final DeviceManager deviceManager = TestDeviceManager(
devices,
logger: BufferLogger.test(),
);
expect(await deviceManager.getDevices(), devices);
});
testWithoutContext('getDeviceById exact matcher', () async {
final FakeDevice device1 = FakeDevice('Nexus 5', '0553790d0a4e726f');
final FakeDevice device2 = FakeDevice('Nexus 5X', '01abfc49119c410e');
final FakeDevice device3 = FakeDevice('iPod touch', '82564b38861a9a5');
final List<Device> devices = <Device>[device1, device2, device3];
final BufferLogger logger = BufferLogger.test();
// Include different device discoveries:
// 1. One that never completes to prove the first exact match is
// returned quickly.
// 2. One that throws, to prove matches can return when some succeed
// and others fail.
// 3. A device discoverer that succeeds.
final DeviceManager deviceManager = TestDeviceManager(
devices,
deviceDiscoveryOverrides: <DeviceDiscovery>[
ThrowingPollingDeviceDiscovery(),
LongPollingDeviceDiscovery(),
],
logger: logger,
);
Future<void> expectDevice(String id, List<Device> expected) async {
expect(await deviceManager.getDevicesById(id), expected);
}
await expectDevice('01abfc49119c410e', <Device>[device2]);
expect(logger.traceText, contains('Ignored error discovering 01abfc49119c410e'));
await expectDevice('Nexus 5X', <Device>[device2]);
expect(logger.traceText, contains('Ignored error discovering Nexus 5X'));
await expectDevice('0553790d0a4e726f', <Device>[device1]);
expect(logger.traceText, contains('Ignored error discovering 0553790d0a4e726f'));
});
testWithoutContext('getDeviceById exact matcher with well known ID', () async {
final FakeDevice device1 = FakeDevice('Windows', 'windows');
final FakeDevice device2 = FakeDevice('Nexus 5X', '01abfc49119c410e');
final FakeDevice device3 = FakeDevice('iPod touch', '82564b38861a9a5');
final List<Device> devices = <Device>[device1, device2, device3];
final BufferLogger logger = BufferLogger.test();
// Because the well known ID will match, no other device discovery will run.
final DeviceManager deviceManager = TestDeviceManager(
devices,
deviceDiscoveryOverrides: <DeviceDiscovery>[
ThrowingPollingDeviceDiscovery(),
LongPollingDeviceDiscovery(),
],
logger: logger,
wellKnownId: 'windows',
);
Future<void> expectDevice(String id, List<Device> expected) async {
deviceManager.specifiedDeviceId = id;
expect(await deviceManager.getDevicesById(id), expected);
}
await expectDevice('windows', <Device>[device1]);
expect(logger.traceText, isEmpty);
});
testWithoutContext('getDeviceById prefix matcher', () async {
final FakeDevice device1 = FakeDevice('Nexus 5', '0553790d0a4e726f');
final FakeDevice device2 = FakeDevice('Nexus 5X', '01abfc49119c410e');
final FakeDevice device3 = FakeDevice('iPod touch', '82564b38861a9a5');
final List<Device> devices = <Device>[device1, device2, device3];
final BufferLogger logger = BufferLogger.test();
// Include different device discoveries:
// 1. One that throws, to prove matches can return when some succeed
// and others fail.
// 2. A device discoverer that succeeds.
final DeviceManager deviceManager = TestDeviceManager(
devices,
deviceDiscoveryOverrides: <DeviceDiscovery>[
ThrowingPollingDeviceDiscovery(),
],
logger: logger,
);
Future<void> expectDevice(String id, List<Device> expected) async {
expect(await deviceManager.getDevicesById(id), expected);
}
await expectDevice('Nexus 5', <Device>[device1]);
expect(logger.traceText, contains('Ignored error discovering Nexus 5'));
await expectDevice('0553790', <Device>[device1]);
expect(logger.traceText, contains('Ignored error discovering 0553790'));
await expectDevice('Nexus', <Device>[device1, device2]);
expect(logger.traceText, contains('Ignored error discovering Nexus'));
});
testWithoutContext('getAllConnectedDevices caches', () async {
final FakeDevice device1 = FakeDevice('Nexus 5', '0553790d0a4e726f');
final TestDeviceManager deviceManager = TestDeviceManager(
<Device>[device1],
logger: BufferLogger.test(),
);
expect(await deviceManager.getAllConnectedDevices(), <Device>[device1]);
final FakeDevice device2 = FakeDevice('Nexus 5X', '01abfc49119c410e');
deviceManager.resetDevices(<Device>[device2]);
expect(await deviceManager.getAllConnectedDevices(), <Device>[device1]);
});
testWithoutContext('refreshAllConnectedDevices does not cache', () async {
final FakeDevice device1 = FakeDevice('Nexus 5', '0553790d0a4e726f');
final TestDeviceManager deviceManager = TestDeviceManager(
<Device>[device1],
logger: BufferLogger.test(),
);
expect(await deviceManager.refreshAllConnectedDevices(), <Device>[device1]);
final FakeDevice device2 = FakeDevice('Nexus 5X', '01abfc49119c410e');
deviceManager.resetDevices(<Device>[device2]);
expect(await deviceManager.refreshAllConnectedDevices(), <Device>[device2]);
});
});
testWithoutContext('PollingDeviceDiscovery startPolling', () {
FakeAsync().run((FakeAsync time) {
final FakePollingDeviceDiscovery pollingDeviceDiscovery = FakePollingDeviceDiscovery();
pollingDeviceDiscovery.startPolling();
time.elapse(const Duration(milliseconds: 4001));
// First check should use the default polling timeout
// to quickly populate the list.
expect(pollingDeviceDiscovery.lastPollingTimeout, isNull);
time.elapse(const Duration(milliseconds: 4001));
// Subsequent polling should be much longer.
expect(pollingDeviceDiscovery.lastPollingTimeout, const Duration(seconds: 30));
pollingDeviceDiscovery.stopPolling();
});
});
group('Filter devices', () {
final FakeDevice ephemeralOne = FakeDevice('ephemeralOne', 'ephemeralOne');
final FakeDevice ephemeralTwo = FakeDevice('ephemeralTwo', 'ephemeralTwo');
final FakeDevice nonEphemeralOne = FakeDevice('nonEphemeralOne', 'nonEphemeralOne', ephemeral: false);
final FakeDevice nonEphemeralTwo = FakeDevice('nonEphemeralTwo', 'nonEphemeralTwo', ephemeral: false);
final FakeDevice unsupported = FakeDevice('unsupported', 'unsupported', isSupported: false);
final FakeDevice unsupportedForProject = FakeDevice('unsupportedForProject', 'unsupportedForProject', isSupportedForProject: false);
final FakeDevice webDevice = FakeDevice('webby', 'webby')
..targetPlatform = Future<TargetPlatform>.value(TargetPlatform.web_javascript);
final FakeDevice fuchsiaDevice = FakeDevice('fuchsiay', 'fuchsiay')
..targetPlatform = Future<TargetPlatform>.value(TargetPlatform.fuchsia_x64);
testWithoutContext('chooses ephemeral device', () async {
final List<Device> devices = <Device>[
ephemeralOne,
nonEphemeralOne,
nonEphemeralTwo,
unsupported,
unsupportedForProject,
];
final DeviceManager deviceManager = TestDeviceManager(
devices,
logger: BufferLogger.test(),
);
final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
expect(filtered.single, ephemeralOne);
});
testWithoutContext('returns all devices when multiple non ephemeral devices are found', () async {
final List<Device> devices = <Device>[
ephemeralOne,
ephemeralTwo,
nonEphemeralOne,
nonEphemeralTwo,
];
final DeviceManager deviceManager = TestDeviceManager(
devices,
logger: BufferLogger.test(),
);
final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
expect(filtered, <Device>[
ephemeralOne,
ephemeralTwo,
nonEphemeralOne,
nonEphemeralTwo,
]);
});
testWithoutContext('Unsupported devices listed in all connected devices', () async {
final List<Device> devices = <Device>[
unsupported,
unsupportedForProject,
];
final DeviceManager deviceManager = TestDeviceManager(
devices,
logger: BufferLogger.test(),
);
final List<Device> filtered = await deviceManager.getAllConnectedDevices();
expect(filtered, <Device>[
unsupported,
unsupportedForProject,
]);
});
testWithoutContext('Removes a unsupported devices', () async {
final List<Device> devices = <Device>[
unsupported,
unsupportedForProject,
];
final DeviceManager deviceManager = TestDeviceManager(
devices,
logger: BufferLogger.test(),
);
final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
expect(filtered, <Device>[]);
});
testWithoutContext('Retains devices unsupported by the project if FlutterProject is null', () async {
final List<Device> devices = <Device>[
unsupported,
unsupportedForProject,
];
final DeviceManager deviceManager = TestDeviceManager(
devices,
logger: BufferLogger.test(),
);
final List<Device> filtered = await deviceManager.findTargetDevices(null);
expect(filtered, <Device>[unsupportedForProject]);
});
testWithoutContext('Removes web and fuchsia from --all', () async {
final List<Device> devices = <Device>[
webDevice,
fuchsiaDevice,
];
final DeviceManager deviceManager = TestDeviceManager(
devices,
logger: BufferLogger.test(),
);
deviceManager.specifiedDeviceId = 'all';
final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
expect(filtered, <Device>[]);
});
testWithoutContext('Removes devices unsupported by the project from --all', () async {
final List<Device> devices = <Device>[
nonEphemeralOne,
nonEphemeralTwo,
unsupported,
unsupportedForProject,
];
final DeviceManager deviceManager = TestDeviceManager(
devices,
logger: BufferLogger.test(),
);
deviceManager.specifiedDeviceId = 'all';
final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
expect(filtered, <Device>[
nonEphemeralOne,
nonEphemeralTwo,
]);
});
testWithoutContext('Returns device with the specified id', () async {
final List<Device> devices = <Device>[
nonEphemeralOne,
];
final DeviceManager deviceManager = TestDeviceManager(
devices,
logger: BufferLogger.test(),
);
deviceManager.specifiedDeviceId = nonEphemeralOne.id;
final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
expect(filtered, <Device>[
nonEphemeralOne,
]);
});
testWithoutContext('Returns multiple devices when multiple devices matches the specified id', () async {
final List<Device> devices = <Device>[
nonEphemeralOne,
nonEphemeralTwo,
];
final DeviceManager deviceManager = TestDeviceManager(
devices,
logger: BufferLogger.test(),
);
deviceManager.specifiedDeviceId = 'nonEphemeral'; // This prefix matches both devices
final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
expect(filtered, <Device>[
nonEphemeralOne,
nonEphemeralTwo,
]);
});
testWithoutContext('Returns empty when device of specified id is not found', () async {
final List<Device> devices = <Device>[
nonEphemeralOne,
];
final DeviceManager deviceManager = TestDeviceManager(
devices,
logger: BufferLogger.test(),
);
deviceManager.specifiedDeviceId = nonEphemeralTwo.id;
final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
expect(filtered, <Device>[]);
});
testWithoutContext('uses DeviceManager.isDeviceSupportedForProject instead of device.isSupportedForProject', () async {
final List<Device> devices = <Device>[
unsupported,
unsupportedForProject,
];
final TestDeviceManager deviceManager = TestDeviceManager(
devices,
logger: BufferLogger.test(),
);
deviceManager.isAlwaysSupportedForProjectOverride = true;
final List<Device> filtered = await deviceManager.findTargetDevices(FakeFlutterProject());
expect(filtered, <Device>[
unsupportedForProject,
]);
});
testWithoutContext('does not refresh device cache without a timeout', () async {
final List<Device> devices = <Device>[
ephemeralOne,
];
final MockDeviceDiscovery deviceDiscovery = MockDeviceDiscovery()
..deviceValues = devices;
final DeviceManager deviceManager = TestDeviceManager(
<Device>[],
deviceDiscoveryOverrides: <DeviceDiscovery>[
deviceDiscovery,
],
logger: BufferLogger.test(),
);
deviceManager.specifiedDeviceId = ephemeralOne.id;
final List<Device> filtered = await deviceManager.findTargetDevices(
FakeFlutterProject(),
);
expect(filtered.single, ephemeralOne);
expect(deviceDiscovery.devicesCalled, 1);
expect(deviceDiscovery.discoverDevicesCalled, 0);
});
testWithoutContext('refreshes device cache with a timeout', () async {
final List<Device> devices = <Device>[
ephemeralOne,
];
const Duration timeout = Duration(seconds: 2);
final MockDeviceDiscovery deviceDiscovery = MockDeviceDiscovery()
..deviceValues = devices;
final DeviceManager deviceManager = TestDeviceManager(
<Device>[],
deviceDiscoveryOverrides: <DeviceDiscovery>[
deviceDiscovery,
],
logger: BufferLogger.test(),
);
deviceManager.specifiedDeviceId = ephemeralOne.id;
final List<Device> filtered = await deviceManager.findTargetDevices(
FakeFlutterProject(),
timeout: timeout,
);
expect(filtered.single, ephemeralOne);
expect(deviceDiscovery.devicesCalled, 1);
expect(deviceDiscovery.discoverDevicesCalled, 1);
});
});
group('JSON encode devices', () {
testWithoutContext('Consistency of JSON representation', () async {
expect(
// This tests that fakeDevices is a list of tuples where "second" is the
// correct JSON representation of the "first". Actual values are irrelevant
await Future.wait(fakeDevices.map((FakeDeviceJsonData d) => d.dev.toJson())),
fakeDevices.map((FakeDeviceJsonData d) => d.json)
);
});
});
testWithoutContext('computeDartVmFlags handles various combinations of Dart VM flags and null_assertions', () {
expect(computeDartVmFlags(DebuggingOptions.enabled(BuildInfo.debug)), '');
expect(computeDartVmFlags(DebuggingOptions.enabled(BuildInfo.debug, dartFlags: '--foo')), '--foo');
expect(computeDartVmFlags(DebuggingOptions.enabled(BuildInfo.debug, nullAssertions: true)), '--null_assertions');
expect(computeDartVmFlags(DebuggingOptions.enabled(BuildInfo.debug, dartFlags: '--foo', nullAssertions: true)), '--foo,--null_assertions');
});
group('JSON encode DebuggingOptions', () {
testWithoutContext('can preserve the original options', () {
final DebuggingOptions original = DebuggingOptions.enabled(
BuildInfo.debug,
startPaused: true,
disableServiceAuthCodes: true,
enableDds: false,
dartEntrypointArgs: <String>['a', 'b'],
dartFlags: 'c',
deviceVmServicePort: 1234,
enableImpeller: true,
enableDartProfiling: false,
);
final String jsonString = json.encode(original.toJson());
final Map<String, dynamic> decoded = castStringKeyedMap(json.decode(jsonString))!;
final DebuggingOptions deserialized = DebuggingOptions.fromJson(decoded, BuildInfo.debug);
expect(deserialized.startPaused, original.startPaused);
expect(deserialized.disableServiceAuthCodes, original.disableServiceAuthCodes);
expect(deserialized.enableDds, original.enableDds);
expect(deserialized.dartEntrypointArgs, original.dartEntrypointArgs);
expect(deserialized.dartFlags, original.dartFlags);
expect(deserialized.deviceVmServicePort, original.deviceVmServicePort);
expect(deserialized.enableImpeller, original.enableImpeller);
expect(deserialized.enableDartProfiling, original.enableDartProfiling);
});
});
group('Get iOS launch arguments from DebuggingOptions', () {
testWithoutContext('Get launch arguments for physical device with debugging enabled with all launch arguments', () {
final DebuggingOptions original = DebuggingOptions.enabled(
BuildInfo.debug,
startPaused: true,
disableServiceAuthCodes: true,
disablePortPublication: true,
dartFlags: '--foo',
useTestFonts: true,
enableSoftwareRendering: true,
skiaDeterministicRendering: true,
traceSkia: true,
traceAllowlist: 'foo',
traceSkiaAllowlist: 'skia.a,skia.b',
traceSystrace: true,
endlessTraceBuffer: true,
dumpSkpOnShaderCompilation: true,
cacheSkSL: true,
purgePersistentCache: true,
verboseSystemLogs: true,
nullAssertions: true,
enableImpeller: true,
deviceVmServicePort: 0,
hostVmServicePort: 1,
);
final List<String> launchArguments = original.getIOSLaunchArguments(
EnvironmentType.physical,
'/test',
<String, dynamic>{
'trace-startup': true,
},
);
expect(
launchArguments.join(' '),
<String>[
'--enable-dart-profiling',
'--disable-service-auth-codes',
'--disable-observatory-publication',
'--start-paused',
'--dart-flags="--foo,--null_assertions"',
'--use-test-fonts',
'--enable-checked-mode',
'--verify-entry-points',
'--enable-software-rendering',
'--trace-systrace',
'--skia-deterministic-rendering',
'--trace-skia',
'--trace-allowlist="foo"',
'--trace-skia-allowlist="skia.a,skia.b"',
'--endless-trace-buffer',
'--dump-skp-on-shader-compilation',
'--verbose-logging',
'--cache-sksl',
'--purge-persistent-cache',
'--route=/test',
'--trace-startup',
'--enable-impeller',
'--observatory-port=0',
].join(' '),
);
});
testWithoutContext('Get launch arguments for physical device with debugging enabled with no launch arguments', () {
final DebuggingOptions original = DebuggingOptions.enabled(
BuildInfo.debug,
);
final List<String> launchArguments = original.getIOSLaunchArguments(
EnvironmentType.physical,
null,
<String, Object?>{},
);
expect(
launchArguments.join(' '),
<String>[
'--enable-dart-profiling',
'--enable-checked-mode',
'--verify-entry-points',
].join(' '),
);
});
testWithoutContext('Get launch arguments for physical device with iPv4 network connection', () {
final DebuggingOptions original = DebuggingOptions.enabled(
BuildInfo.debug,
);
final List<String> launchArguments = original.getIOSLaunchArguments(
EnvironmentType.physical,
null,
<String, Object?>{},
interfaceType: IOSDeviceConnectionInterface.network,
);
expect(
launchArguments.join(' '),
<String>[
'--enable-dart-profiling',
'--enable-checked-mode',
'--verify-entry-points',
'--observatory-host=0.0.0.0',
].join(' '),
);
});
testWithoutContext('Get launch arguments for physical device with iPv6 network connection', () {
final DebuggingOptions original = DebuggingOptions.enabled(
BuildInfo.debug,
);
final List<String> launchArguments = original.getIOSLaunchArguments(
EnvironmentType.physical,
null,
<String, Object?>{},
ipv6: true,
interfaceType: IOSDeviceConnectionInterface.network,
);
expect(
launchArguments.join(' '),
<String>[
'--enable-dart-profiling',
'--enable-checked-mode',
'--verify-entry-points',
'--observatory-host=::0',
].join(' '),
);
});
testWithoutContext('Get launch arguments for physical device with debugging disabled with available launch arguments', () {
final DebuggingOptions original = DebuggingOptions.disabled(
BuildInfo.debug,
traceAllowlist: 'foo',
cacheSkSL: true,
enableImpeller: true,
);
final List<String> launchArguments = original.getIOSLaunchArguments(
EnvironmentType.physical,
'/test',
<String, dynamic>{
'trace-startup': true,
},
);
expect(
launchArguments.join(' '),
<String>[
'--enable-dart-profiling',
'--trace-allowlist="foo"',
'--cache-sksl',
'--route=/test',
'--trace-startup',
'--enable-impeller',
].join(' '),
);
});
testWithoutContext('Get launch arguments for simulator device with debugging enabled with all launch arguments', () {
final DebuggingOptions original = DebuggingOptions.enabled(
BuildInfo.debug,
startPaused: true,
disableServiceAuthCodes: true,
disablePortPublication: true,
dartFlags: '--foo',
useTestFonts: true,
enableSoftwareRendering: true,
skiaDeterministicRendering: true,
traceSkia: true,
traceAllowlist: 'foo',
traceSkiaAllowlist: 'skia.a,skia.b',
traceSystrace: true,
endlessTraceBuffer: true,
dumpSkpOnShaderCompilation: true,
cacheSkSL: true,
purgePersistentCache: true,
verboseSystemLogs: true,
nullAssertions: true,
enableImpeller: true,
deviceVmServicePort: 0,
hostVmServicePort: 1,
);
final List<String> launchArguments = original.getIOSLaunchArguments(
EnvironmentType.simulator,
'/test',
<String, dynamic>{
'trace-startup': true,
},
);
expect(
launchArguments.join(' '),
<String>[
'--enable-dart-profiling',
'--disable-service-auth-codes',
'--disable-observatory-publication',
'--start-paused',
'--dart-flags=--foo,--null_assertions',
'--use-test-fonts',
'--enable-checked-mode',
'--verify-entry-points',
'--enable-software-rendering',
'--trace-systrace',
'--skia-deterministic-rendering',
'--trace-skia',
'--trace-allowlist="foo"',
'--trace-skia-allowlist="skia.a,skia.b"',
'--endless-trace-buffer',
'--dump-skp-on-shader-compilation',
'--verbose-logging',
'--cache-sksl',
'--purge-persistent-cache',
'--route=/test',
'--trace-startup',
'--enable-impeller',
'--observatory-port=1',
].join(' '),
);
});
testWithoutContext('Get launch arguments for simulator device with debugging enabled with no launch arguments', () {
final DebuggingOptions original = DebuggingOptions.enabled(
BuildInfo.debug,
);
final List<String> launchArguments = original.getIOSLaunchArguments(
EnvironmentType.simulator,
null,
<String, Object?>{},
);
expect(
launchArguments.join(' '),
<String>[
'--enable-dart-profiling',
'--enable-checked-mode',
'--verify-entry-points',
].join(' '),
);
});
testWithoutContext('No --enable-dart-profiling flag when option is false', () {
final DebuggingOptions original = DebuggingOptions.enabled(
BuildInfo.debug,
enableDartProfiling: false,
);
final List<String> launchArguments = original.getIOSLaunchArguments(
EnvironmentType.physical,
null,
<String, Object?>{},
);
expect(
launchArguments.join(' '),
<String>[
'--enable-checked-mode',
'--verify-entry-points',
].join(' '),
);
});
});
}
class TestDeviceManager extends DeviceManager {
TestDeviceManager(
List<Device> allDevices, {
List<DeviceDiscovery>? deviceDiscoveryOverrides,
required super.logger,
String? wellKnownId,
}) : _fakeDeviceDiscoverer = FakePollingDeviceDiscovery(),
_deviceDiscoverers = <DeviceDiscovery>[],
super() {
if (wellKnownId != null) {
_fakeDeviceDiscoverer.wellKnownIds.add(wellKnownId);
}
_deviceDiscoverers.add(_fakeDeviceDiscoverer);
if (deviceDiscoveryOverrides != null) {
_deviceDiscoverers.addAll(deviceDiscoveryOverrides);
}
resetDevices(allDevices);
}
@override
List<DeviceDiscovery> get deviceDiscoverers => _deviceDiscoverers;
final List<DeviceDiscovery> _deviceDiscoverers;
final FakePollingDeviceDiscovery _fakeDeviceDiscoverer;
void resetDevices(List<Device> allDevices) {
_fakeDeviceDiscoverer.setDevices(allDevices);
}
bool? isAlwaysSupportedForProjectOverride;
@override
bool isDeviceSupportedForProject(Device device, FlutterProject? flutterProject) {
if (isAlwaysSupportedForProjectOverride != null) {
return isAlwaysSupportedForProjectOverride!;
}
return super.isDeviceSupportedForProject(device, flutterProject);
}
}
class MockDeviceDiscovery extends Fake implements DeviceDiscovery {
int devicesCalled = 0;
int discoverDevicesCalled = 0;
@override
bool supportsPlatform = true;
List<Device> deviceValues = <Device>[];
@override
Future<List<Device>> get devices async {
devicesCalled += 1;
return deviceValues;
}
@override
Future<List<Device>> discoverDevices({Duration? timeout}) async {
discoverDevicesCalled += 1;
return deviceValues;
}
@override
List<String> get wellKnownIds => <String>[];
}
class FakeFlutterProject extends Fake implements FlutterProject { }
class LongPollingDeviceDiscovery extends PollingDeviceDiscovery {
LongPollingDeviceDiscovery() : super('forever');
final Completer<List<Device>> _completer = Completer<List<Device>>();
@override
Future<List<Device>> pollingGetDevices({ Duration? timeout }) async {
return _completer.future;
}
@override
Future<void> stopPolling() async {
_completer.complete(<Device>[]);
}
@override
Future<void> dispose() async {
_completer.complete(<Device>[]);
}
@override
bool get supportsPlatform => true;
@override
bool get canListAnything => true;
@override
final List<String> wellKnownIds = <String>[];
}
class ThrowingPollingDeviceDiscovery extends PollingDeviceDiscovery {
ThrowingPollingDeviceDiscovery() : super('throw');
@override
Future<List<Device>> pollingGetDevices({ Duration? timeout }) async {
throw const ProcessException('fake-discovery', <String>[]);
}
@override
bool get supportsPlatform => true;
@override
bool get canListAnything => true;
@override
List<String> get wellKnownIds => <String>[];
}