From b79752b9e6e988dbfe0ee9e4544f8bbe149c69e8 Mon Sep 17 00:00:00 2001 From: Michael Klimushyn Date: Wed, 13 Nov 2019 10:10:03 -0800 Subject: [PATCH 1/3] [android_alarm_manager] Testing and documentation Unit tests the plugin, and adds a lint for missing DartDocs. --- packages/android_alarm_manager/CHANGELOG.md | 4 + .../analysis_options.yaml | 10 - .../example/lib/main.dart | 2 + .../lib/android_alarm_manager.dart | 40 +++- packages/android_alarm_manager/pubspec.yaml | 6 +- .../test/android_alarm_manager_test.dart | 203 ++++++++++++++++++ 6 files changed, 249 insertions(+), 16 deletions(-) delete mode 100644 packages/android_alarm_manager/analysis_options.yaml create mode 100644 packages/android_alarm_manager/test/android_alarm_manager_test.dart diff --git a/packages/android_alarm_manager/CHANGELOG.md b/packages/android_alarm_manager/CHANGELOG.md index 1506fd304cf7..1494506fcb73 100644 --- a/packages/android_alarm_manager/CHANGELOG.md +++ b/packages/android_alarm_manager/CHANGELOG.md @@ -1,3 +1,7 @@ +## 0.4.4+3 + +* Add unit tests and DartDocs. + ## 0.4.4+2 * Remove AndroidX warning. diff --git a/packages/android_alarm_manager/analysis_options.yaml b/packages/android_alarm_manager/analysis_options.yaml deleted file mode 100644 index 8e4af76f0a30..000000000000 --- a/packages/android_alarm_manager/analysis_options.yaml +++ /dev/null @@ -1,10 +0,0 @@ -# This is a temporary file to allow us to land a new set of linter rules in a -# series of manageable patches instead of one gigantic PR. It disables some of -# the new lints that are already failing on this plugin, for this plugin. It -# should be deleted and the failing lints addressed as soon as possible. - -include: ../../analysis_options.yaml - -analyzer: - errors: - public_member_api_docs: ignore diff --git a/packages/android_alarm_manager/example/lib/main.dart b/packages/android_alarm_manager/example/lib/main.dart index e68735a75085..5e20364312bb 100644 --- a/packages/android_alarm_manager/example/lib/main.dart +++ b/packages/android_alarm_manager/example/lib/main.dart @@ -2,6 +2,8 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. +// ignore_for_file: public_member_api_docs + import 'dart:async'; import 'package:android_alarm_manager/android_alarm_manager.dart'; diff --git a/packages/android_alarm_manager/lib/android_alarm_manager.dart b/packages/android_alarm_manager/lib/android_alarm_manager.dart index 76994b9edac7..23e2997c397e 100644 --- a/packages/android_alarm_manager/lib/android_alarm_manager.dart +++ b/packages/android_alarm_manager/lib/android_alarm_manager.dart @@ -54,6 +54,31 @@ void _alarmManagerCallbackDispatcher() { _channel.invokeMethod('AlarmService.initialized'); } +/// This is a wrapper around a few static functions so that unit tests can mock +/// them out in the test environment. This is only visible for the unit tests and +/// should not be accessed directly by users of the plugin. +@visibleForTesting +class InstanceWrappers { + static Function _nowFn = () => DateTime.now(); + + /// Returns [DateTime.now] by default. + static DateTime now() => _nowFn(); + + /// Overrides the default [InstanceWrappers.now] with [nowFn]. + static void setMockNowFn(Function nowFn) => _nowFn = nowFn; + + static Function _getCallbackHandleFn = + (Function callback) => PluginUtilities.getCallbackHandle(callback); + + /// Returns [PluginUtilities.getCallbackHandle] by default. + static CallbackHandle getCallbackHandle(Function callback) => + _getCallbackHandleFn(callback); + + /// Overrides the default [InstanceWrappers.now] with [nowFn]. + static void setMockCallbackHandleFn(Function callbackHandleFn) => + _getCallbackHandleFn = callbackHandleFn; +} + /// A Flutter plugin for registering Dart callbacks with the Android /// AlarmManager service. /// @@ -63,6 +88,11 @@ class AndroidAlarmManager { static const MethodChannel _channel = MethodChannel(_channelName, JSONMethodCodec()); + /// This is exposed for the unit tests to implement the platform layer. It + /// should not be accessed by users of the plugin. + @visibleForTesting + static MethodChannel get channel => _channel; + /// Starts the [AndroidAlarmManager] service. This must be called before /// setting any alarms. /// @@ -70,7 +100,7 @@ class AndroidAlarmManager { /// failure. static Future initialize() async { final CallbackHandle handle = - PluginUtilities.getCallbackHandle(_alarmManagerCallbackDispatcher); + InstanceWrappers.getCallbackHandle(_alarmManagerCallbackDispatcher); if (handle == null) { return false; } @@ -127,7 +157,7 @@ class AndroidAlarmManager { bool rescheduleOnReboot = false, }) => oneShotAt( - DateTime.now().add(delay), + InstanceWrappers.now().add(delay), id, callback, alarmClock: alarmClock, @@ -188,7 +218,7 @@ class AndroidAlarmManager { assert(callback is Function() || callback is Function(int)); assert(id.bitLength < 32); final int startMillis = time.millisecondsSinceEpoch; - final CallbackHandle handle = PluginUtilities.getCallbackHandle(callback); + final CallbackHandle handle = InstanceWrappers.getCallbackHandle(callback); if (handle == null) { return false; } @@ -251,11 +281,11 @@ class AndroidAlarmManager { // ignore: inference_failure_on_function_return_type assert(callback is Function() || callback is Function(int)); assert(id.bitLength < 32); - final int now = DateTime.now().millisecondsSinceEpoch; + final int now = InstanceWrappers.now().millisecondsSinceEpoch; final int period = duration.inMilliseconds; final int first = startAt != null ? startAt.millisecondsSinceEpoch : now + period; - final CallbackHandle handle = PluginUtilities.getCallbackHandle(callback); + final CallbackHandle handle = InstanceWrappers.getCallbackHandle(callback); if (handle == null) { return false; } diff --git a/packages/android_alarm_manager/pubspec.yaml b/packages/android_alarm_manager/pubspec.yaml index 6fe4ed944d55..29a9961b448d 100644 --- a/packages/android_alarm_manager/pubspec.yaml +++ b/packages/android_alarm_manager/pubspec.yaml @@ -1,7 +1,7 @@ name: android_alarm_manager description: Flutter plugin for accessing the Android AlarmManager service, and running Dart code in the background when alarms fire. -version: 0.4.4+2 +version: 0.4.4+3 author: Flutter Team homepage: https://github.com/flutter/plugins/tree/master/packages/android_alarm_manager @@ -9,6 +9,10 @@ dependencies: flutter: sdk: flutter +dev_dependencies: + flutter_test: + sdk: flutter + flutter: plugin: androidPackage: io.flutter.plugins.androidalarmmanager diff --git a/packages/android_alarm_manager/test/android_alarm_manager_test.dart b/packages/android_alarm_manager/test/android_alarm_manager_test.dart new file mode 100644 index 000000000000..d41f44acb79b --- /dev/null +++ b/packages/android_alarm_manager/test/android_alarm_manager_test.dart @@ -0,0 +1,203 @@ +// Copyright 2019 The Chromium 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:ui'; + +import 'package:android_alarm_manager/android_alarm_manager.dart'; +import 'package:flutter/services.dart'; +import 'package:flutter_test/flutter_test.dart'; + +void main() { + TestWidgetsFlutterBinding.ensureInitialized(); + + setUpAll(() { + AndroidAlarmManager.channel + .setMockMethodCallHandler((MethodCall call) => null); + }); + + test('${AndroidAlarmManager.initialize}', () async { + AndroidAlarmManager.channel + .setMockMethodCallHandler((MethodCall call) async { + assert(call.method == 'AlarmService.start'); + return true; + }); + + final bool initialized = await AndroidAlarmManager.initialize(); + + expect(initialized, isTrue); + }); + + group('${AndroidAlarmManager.oneShotAt}', () { + test('validates input', () async { + final DateTime validTime = DateTime.utc(1993); + final int validId = 1; + final Function validCallback = (int id) => null; + + // Callback should take a single int param. + expect( + () => AndroidAlarmManager.oneShotAt( + validTime, validId, ((String foo) => foo)), + throwsAssertionError); + + // ID should be less than 32 bits. + expect( + () => AndroidAlarmManager.oneShotAt( + validTime, 2147483648, validCallback), + throwsAssertionError); + }); + + test('sends arguments to the platform', () async { + final DateTime alarm = DateTime(1993); + const int rawHandle = 4; + InstanceWrappers.setMockCallbackHandleFn( + (Function _) => CallbackHandle.fromRawHandle(rawHandle)); + + final int id = 1; + final bool alarmClock = true; + final bool allowWhileIdle = true; + final bool exact = true; + final bool wakeup = true; + final bool rescheduleOnReboot = true; + + AndroidAlarmManager.channel + .setMockMethodCallHandler((MethodCall call) async { + expect(call.method, 'Alarm.oneShotAt'); + expect(call.arguments[0], id); + expect(call.arguments[1], alarmClock); + expect(call.arguments[2], allowWhileIdle); + expect(call.arguments[3], exact); + expect(call.arguments[4], wakeup); + expect(call.arguments[5], alarm.millisecondsSinceEpoch); + expect(call.arguments[6], rescheduleOnReboot); + expect(call.arguments[7], rawHandle); + return true; + }); + + final bool result = await AndroidAlarmManager.oneShotAt( + alarm, id, (int id) => id, + alarmClock: alarmClock, + allowWhileIdle: allowWhileIdle, + exact: exact, + wakeup: wakeup, + rescheduleOnReboot: rescheduleOnReboot); + + expect(result, isTrue); + }); + }); + + test('${AndroidAlarmManager.oneShot} calls through to oneShotAt', () async { + final DateTime now = DateTime(1993); + InstanceWrappers.setMockNowFn(() => now); + const int rawHandle = 4; + InstanceWrappers.setMockCallbackHandleFn( + (Function _) => CallbackHandle.fromRawHandle(rawHandle)); + + const Duration alarm = Duration(seconds: 1); + final int id = 1; + final bool alarmClock = true; + final bool allowWhileIdle = true; + final bool exact = true; + final bool wakeup = true; + final bool rescheduleOnReboot = true; + + AndroidAlarmManager.channel + .setMockMethodCallHandler((MethodCall call) async { + expect(call.method, 'Alarm.oneShotAt'); + expect(call.arguments[0], id); + expect(call.arguments[1], alarmClock); + expect(call.arguments[2], allowWhileIdle); + expect(call.arguments[3], exact); + expect(call.arguments[4], wakeup); + expect( + call.arguments[5], now.millisecondsSinceEpoch + alarm.inMilliseconds); + expect(call.arguments[6], rescheduleOnReboot); + expect(call.arguments[7], rawHandle); + return true; + }); + + final bool result = await AndroidAlarmManager.oneShot( + alarm, id, (int id) => id, + alarmClock: alarmClock, + allowWhileIdle: allowWhileIdle, + exact: exact, + wakeup: wakeup, + rescheduleOnReboot: rescheduleOnReboot); + + expect(result, isTrue); + }); + + group('${AndroidAlarmManager.periodic}', () { + test('validates input', () async { + const Duration validDuration = Duration(seconds: 0); + final int validId = 1; + final Function validCallback = (int id) => null; + + // Callback should take a single int param. + expect( + () => AndroidAlarmManager.periodic( + validDuration, validId, ((String foo) => foo)), + throwsAssertionError); + + // ID should be less than 32 bits. + expect( + () => AndroidAlarmManager.periodic( + validDuration, 2147483648, validCallback), + throwsAssertionError); + }); + + test('sends arguments through to the platform', () async { + final DateTime now = DateTime(1993); + InstanceWrappers.setMockNowFn(() => now); + const int rawHandle = 4; + InstanceWrappers.setMockCallbackHandleFn( + (Function _) => CallbackHandle.fromRawHandle(rawHandle)); + + final int id = 1; + final bool exact = true; + final bool wakeup = true; + final bool rescheduleOnReboot = true; + const Duration period = Duration(seconds: 1); + + AndroidAlarmManager.channel + .setMockMethodCallHandler((MethodCall call) async { + expect(call.method, 'Alarm.periodic'); + expect(call.arguments[0], id); + expect(call.arguments[1], exact); + expect(call.arguments[2], wakeup); + expect( + call.arguments[3], + (InstanceWrappers.now().millisecondsSinceEpoch + + period.inMilliseconds)); + expect(call.arguments[4], period.inMilliseconds); + expect(call.arguments[5], rescheduleOnReboot); + expect(call.arguments[6], rawHandle); + return true; + }); + + final bool result = await AndroidAlarmManager.periodic( + period, + id, + (int id) => null, + exact: exact, + wakeup: wakeup, + rescheduleOnReboot: rescheduleOnReboot, + ); + + expect(result, isTrue); + }); + }); + + test('${AndroidAlarmManager.cancel}', () async { + final int id = 1; + AndroidAlarmManager.channel + .setMockMethodCallHandler((MethodCall call) async { + assert(call.method == 'Alarm.cancel' && call.arguments[0] == id); + return true; + }); + + final bool canceled = await AndroidAlarmManager.cancel(id); + + expect(canceled, isTrue); + }); +} From 7b90fecf99016a9325daae10b6127c1e4d886cbf Mon Sep 17 00:00:00 2001 From: Michael Klimushyn Date: Fri, 22 Nov 2019 13:02:00 -0800 Subject: [PATCH 2/3] Review feedback - Wrap InstanceWrappers into a single `setTestOverride` method. - Replace potentially garbage collected lambdas with top level functions. --- .../lib/android_alarm_manager.dart | 58 ++++++++----------- .../test/android_alarm_manager_test.dart | 54 +++++++++-------- 2 files changed, 50 insertions(+), 62 deletions(-) diff --git a/packages/android_alarm_manager/lib/android_alarm_manager.dart b/packages/android_alarm_manager/lib/android_alarm_manager.dart index 23e2997c397e..f31b4bc87525 100644 --- a/packages/android_alarm_manager/lib/android_alarm_manager.dart +++ b/packages/android_alarm_manager/lib/android_alarm_manager.dart @@ -54,30 +54,10 @@ void _alarmManagerCallbackDispatcher() { _channel.invokeMethod('AlarmService.initialized'); } -/// This is a wrapper around a few static functions so that unit tests can mock -/// them out in the test environment. This is only visible for the unit tests and -/// should not be accessed directly by users of the plugin. -@visibleForTesting -class InstanceWrappers { - static Function _nowFn = () => DateTime.now(); - - /// Returns [DateTime.now] by default. - static DateTime now() => _nowFn(); - - /// Overrides the default [InstanceWrappers.now] with [nowFn]. - static void setMockNowFn(Function nowFn) => _nowFn = nowFn; - - static Function _getCallbackHandleFn = - (Function callback) => PluginUtilities.getCallbackHandle(callback); - - /// Returns [PluginUtilities.getCallbackHandle] by default. - static CallbackHandle getCallbackHandle(Function callback) => - _getCallbackHandleFn(callback); - - /// Overrides the default [InstanceWrappers.now] with [nowFn]. - static void setMockCallbackHandleFn(Function callbackHandleFn) => - _getCallbackHandleFn = callbackHandleFn; -} +// A lambda that returns the current instant in the form of a [DateTime]. +typedef DateTime _Now(); +// A lambda that gets the handle for the given [callback]. +typedef CallbackHandle _GetCallbackHandle(Function callback); /// A Flutter plugin for registering Dart callbacks with the Android /// AlarmManager service. @@ -85,13 +65,23 @@ class InstanceWrappers { /// See the example/ directory in this package for sample usage. class AndroidAlarmManager { static const String _channelName = 'plugins.flutter.io/android_alarm_manager'; - static const MethodChannel _channel = - MethodChannel(_channelName, JSONMethodCodec()); + static MethodChannel _channel = + const MethodChannel(_channelName, JSONMethodCodec()); + // Function used to get the current time. It's [DateTime.now] by default. + static _Now _now = () => DateTime.now(); + // Callback used to get the handle for a callback. It's + // [PluginUtilities.getCallbackHandle] by default. + static _GetCallbackHandle _getCallbackHandle = + (Function callback) => PluginUtilities.getCallbackHandle(callback); - /// This is exposed for the unit tests to implement the platform layer. It - /// should not be accessed by users of the plugin. + /// This is exposed for the unit tests. It should not be accessed by users of + /// the plugin. @visibleForTesting - static MethodChannel get channel => _channel; + static void setTestOverides( + {_Now now, _GetCallbackHandle getCallbackHandle}) { + _now = (now ?? _now); + _getCallbackHandle = (getCallbackHandle ?? _getCallbackHandle); + } /// Starts the [AndroidAlarmManager] service. This must be called before /// setting any alarms. @@ -100,7 +90,7 @@ class AndroidAlarmManager { /// failure. static Future initialize() async { final CallbackHandle handle = - InstanceWrappers.getCallbackHandle(_alarmManagerCallbackDispatcher); + _getCallbackHandle(_alarmManagerCallbackDispatcher); if (handle == null) { return false; } @@ -157,7 +147,7 @@ class AndroidAlarmManager { bool rescheduleOnReboot = false, }) => oneShotAt( - InstanceWrappers.now().add(delay), + _now().add(delay), id, callback, alarmClock: alarmClock, @@ -218,7 +208,7 @@ class AndroidAlarmManager { assert(callback is Function() || callback is Function(int)); assert(id.bitLength < 32); final int startMillis = time.millisecondsSinceEpoch; - final CallbackHandle handle = InstanceWrappers.getCallbackHandle(callback); + final CallbackHandle handle = _getCallbackHandle(callback); if (handle == null) { return false; } @@ -281,11 +271,11 @@ class AndroidAlarmManager { // ignore: inference_failure_on_function_return_type assert(callback is Function() || callback is Function(int)); assert(id.bitLength < 32); - final int now = InstanceWrappers.now().millisecondsSinceEpoch; + final int now = _now().millisecondsSinceEpoch; final int period = duration.inMilliseconds; final int first = startAt != null ? startAt.millisecondsSinceEpoch : now + period; - final CallbackHandle handle = InstanceWrappers.getCallbackHandle(callback); + final CallbackHandle handle = _getCallbackHandle(callback); if (handle == null) { return false; } diff --git a/packages/android_alarm_manager/test/android_alarm_manager_test.dart b/packages/android_alarm_manager/test/android_alarm_manager_test.dart index d41f44acb79b..8266d18ae0da 100644 --- a/packages/android_alarm_manager/test/android_alarm_manager_test.dart +++ b/packages/android_alarm_manager/test/android_alarm_manager_test.dart @@ -9,16 +9,19 @@ import 'package:flutter/services.dart'; import 'package:flutter_test/flutter_test.dart'; void main() { + String invalidCallback(String foo) => foo; + void validCallback(int id) => null; + + const MethodChannel testChannel = MethodChannel( + 'plugins.flutter.io/android_alarm_manager', JSONMethodCodec()); TestWidgetsFlutterBinding.ensureInitialized(); setUpAll(() { - AndroidAlarmManager.channel - .setMockMethodCallHandler((MethodCall call) => null); + testChannel.setMockMethodCallHandler((MethodCall call) => null); }); test('${AndroidAlarmManager.initialize}', () async { - AndroidAlarmManager.channel - .setMockMethodCallHandler((MethodCall call) async { + testChannel.setMockMethodCallHandler((MethodCall call) async { assert(call.method == 'AlarmService.start'); return true; }); @@ -32,12 +35,11 @@ void main() { test('validates input', () async { final DateTime validTime = DateTime.utc(1993); final int validId = 1; - final Function validCallback = (int id) => null; // Callback should take a single int param. expect( () => AndroidAlarmManager.oneShotAt( - validTime, validId, ((String foo) => foo)), + validTime, validId, invalidCallback), throwsAssertionError); // ID should be less than 32 bits. @@ -50,8 +52,9 @@ void main() { test('sends arguments to the platform', () async { final DateTime alarm = DateTime(1993); const int rawHandle = 4; - InstanceWrappers.setMockCallbackHandleFn( - (Function _) => CallbackHandle.fromRawHandle(rawHandle)); + AndroidAlarmManager.setTestOverides( + getCallbackHandle: (Function _) => + CallbackHandle.fromRawHandle(rawHandle)); final int id = 1; final bool alarmClock = true; @@ -60,8 +63,7 @@ void main() { final bool wakeup = true; final bool rescheduleOnReboot = true; - AndroidAlarmManager.channel - .setMockMethodCallHandler((MethodCall call) async { + testChannel.setMockMethodCallHandler((MethodCall call) async { expect(call.method, 'Alarm.oneShotAt'); expect(call.arguments[0], id); expect(call.arguments[1], alarmClock); @@ -88,10 +90,11 @@ void main() { test('${AndroidAlarmManager.oneShot} calls through to oneShotAt', () async { final DateTime now = DateTime(1993); - InstanceWrappers.setMockNowFn(() => now); const int rawHandle = 4; - InstanceWrappers.setMockCallbackHandleFn( - (Function _) => CallbackHandle.fromRawHandle(rawHandle)); + AndroidAlarmManager.setTestOverides( + now: () => now, + getCallbackHandle: (Function _) => + CallbackHandle.fromRawHandle(rawHandle)); const Duration alarm = Duration(seconds: 1); final int id = 1; @@ -101,8 +104,7 @@ void main() { final bool wakeup = true; final bool rescheduleOnReboot = true; - AndroidAlarmManager.channel - .setMockMethodCallHandler((MethodCall call) async { + testChannel.setMockMethodCallHandler((MethodCall call) async { expect(call.method, 'Alarm.oneShotAt'); expect(call.arguments[0], id); expect(call.arguments[1], alarmClock); @@ -131,12 +133,11 @@ void main() { test('validates input', () async { const Duration validDuration = Duration(seconds: 0); final int validId = 1; - final Function validCallback = (int id) => null; // Callback should take a single int param. expect( () => AndroidAlarmManager.periodic( - validDuration, validId, ((String foo) => foo)), + validDuration, validId, invalidCallback), throwsAssertionError); // ID should be less than 32 bits. @@ -148,10 +149,11 @@ void main() { test('sends arguments through to the platform', () async { final DateTime now = DateTime(1993); - InstanceWrappers.setMockNowFn(() => now); const int rawHandle = 4; - InstanceWrappers.setMockCallbackHandleFn( - (Function _) => CallbackHandle.fromRawHandle(rawHandle)); + AndroidAlarmManager.setTestOverides( + now: () => now, + getCallbackHandle: (Function _) => + CallbackHandle.fromRawHandle(rawHandle)); final int id = 1; final bool exact = true; @@ -159,16 +161,13 @@ void main() { final bool rescheduleOnReboot = true; const Duration period = Duration(seconds: 1); - AndroidAlarmManager.channel - .setMockMethodCallHandler((MethodCall call) async { + testChannel.setMockMethodCallHandler((MethodCall call) async { expect(call.method, 'Alarm.periodic'); expect(call.arguments[0], id); expect(call.arguments[1], exact); expect(call.arguments[2], wakeup); - expect( - call.arguments[3], - (InstanceWrappers.now().millisecondsSinceEpoch + - period.inMilliseconds)); + expect(call.arguments[3], + (now.millisecondsSinceEpoch + period.inMilliseconds)); expect(call.arguments[4], period.inMilliseconds); expect(call.arguments[5], rescheduleOnReboot); expect(call.arguments[6], rawHandle); @@ -190,8 +189,7 @@ void main() { test('${AndroidAlarmManager.cancel}', () async { final int id = 1; - AndroidAlarmManager.channel - .setMockMethodCallHandler((MethodCall call) async { + testChannel.setMockMethodCallHandler((MethodCall call) async { assert(call.method == 'Alarm.cancel' && call.arguments[0] == id); return true; }); From 0ed08116d4892947accfee4d4286cdbac9bd1cc5 Mon Sep 17 00:00:00 2001 From: Michael Klimushyn Date: Mon, 25 Nov 2019 15:41:04 -0800 Subject: [PATCH 3/3] Review feedback --- .../test/android_alarm_manager_test.dart | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/packages/android_alarm_manager/test/android_alarm_manager_test.dart b/packages/android_alarm_manager/test/android_alarm_manager_test.dart index 8266d18ae0da..1f9d2856838e 100644 --- a/packages/android_alarm_manager/test/android_alarm_manager_test.dart +++ b/packages/android_alarm_manager/test/android_alarm_manager_test.dart @@ -37,13 +37,13 @@ void main() { final int validId = 1; // Callback should take a single int param. - expect( + await expectLater( () => AndroidAlarmManager.oneShotAt( validTime, validId, invalidCallback), throwsAssertionError); // ID should be less than 32 bits. - expect( + await expectLater( () => AndroidAlarmManager.oneShotAt( validTime, 2147483648, validCallback), throwsAssertionError); @@ -77,7 +77,7 @@ void main() { }); final bool result = await AndroidAlarmManager.oneShotAt( - alarm, id, (int id) => id, + alarm, id, validCallback, alarmClock: alarmClock, allowWhileIdle: allowWhileIdle, exact: exact, @@ -119,7 +119,7 @@ void main() { }); final bool result = await AndroidAlarmManager.oneShot( - alarm, id, (int id) => id, + alarm, id, validCallback, alarmClock: alarmClock, allowWhileIdle: allowWhileIdle, exact: exact, @@ -135,13 +135,13 @@ void main() { final int validId = 1; // Callback should take a single int param. - expect( + await expectLater( () => AndroidAlarmManager.periodic( validDuration, validId, invalidCallback), throwsAssertionError); // ID should be less than 32 bits. - expect( + await expectLater( () => AndroidAlarmManager.periodic( validDuration, 2147483648, validCallback), throwsAssertionError);