Fix newly enforced package:pedantic lints (#92)
- always_declare_return_types
- annotate_overrides
- curly_braces_in_flow_control_structures
- omit_local_variable_types
- prefer_collection_literals
- prefer_conditional_assignment
- prefer_single_quotes
- type_init_formals
- unnecessary_this
- use_function_type_syntax_for_parameters
Bump minimum SDK to 2.2.0 for Set literals
diff --git a/.travis.yml b/.travis.yml
index dd151e8..ccc0864 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -2,7 +2,7 @@
dart:
- dev
- - 2.0.0
+ - 2.2.0
dart_task:
- test: --platform vm
diff --git a/lib/async.dart b/lib/async.dart
index 25fc0fd..2af006b 100644
--- a/lib/async.dart
+++ b/lib/async.dart
@@ -2,33 +2,33 @@
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
-export "src/async_cache.dart";
-export "src/async_memoizer.dart";
-export "src/byte_collector.dart";
-export "src/cancelable_operation.dart";
-export "src/delegate/event_sink.dart";
-export "src/delegate/future.dart";
-export "src/delegate/sink.dart";
-export "src/delegate/stream.dart";
-export "src/delegate/stream_consumer.dart";
-export "src/delegate/stream_sink.dart";
-export "src/delegate/stream_subscription.dart";
-export "src/future_group.dart";
-export "src/lazy_stream.dart";
-export "src/null_stream_sink.dart";
-export "src/restartable_timer.dart";
-export "src/result/result.dart";
-export "src/result/error.dart";
-export "src/result/future.dart";
-export "src/result/value.dart";
-export "src/single_subscription_transformer.dart";
-export "src/stream_completer.dart";
-export "src/stream_group.dart";
-export "src/stream_queue.dart";
-export "src/stream_sink_completer.dart";
-export "src/stream_sink_transformer.dart";
-export "src/stream_splitter.dart";
-export "src/stream_subscription_transformer.dart";
-export "src/stream_zip.dart";
-export "src/subscription_stream.dart";
-export "src/typed_stream_transformer.dart";
+export 'src/async_cache.dart';
+export 'src/async_memoizer.dart';
+export 'src/byte_collector.dart';
+export 'src/cancelable_operation.dart';
+export 'src/delegate/event_sink.dart';
+export 'src/delegate/future.dart';
+export 'src/delegate/sink.dart';
+export 'src/delegate/stream.dart';
+export 'src/delegate/stream_consumer.dart';
+export 'src/delegate/stream_sink.dart';
+export 'src/delegate/stream_subscription.dart';
+export 'src/future_group.dart';
+export 'src/lazy_stream.dart';
+export 'src/null_stream_sink.dart';
+export 'src/restartable_timer.dart';
+export 'src/result/result.dart';
+export 'src/result/error.dart';
+export 'src/result/future.dart';
+export 'src/result/value.dart';
+export 'src/single_subscription_transformer.dart';
+export 'src/stream_completer.dart';
+export 'src/stream_group.dart';
+export 'src/stream_queue.dart';
+export 'src/stream_sink_completer.dart';
+export 'src/stream_sink_transformer.dart';
+export 'src/stream_splitter.dart';
+export 'src/stream_subscription_transformer.dart';
+export 'src/stream_zip.dart';
+export 'src/subscription_stream.dart';
+export 'src/typed_stream_transformer.dart';
diff --git a/lib/src/async_cache.dart b/lib/src/async_cache.dart
index 4b02304..e0a6f49 100644
--- a/lib/src/async_cache.dart
+++ b/lib/src/async_cache.dart
@@ -56,7 +56,7 @@
///
/// If [fetch] has been called recently enough, returns its previous return
/// value. Otherwise, runs [callback] and returns its new return value.
- Future<T> fetch(Future<T> callback()) async {
+ Future<T> fetch(Future<T> Function() callback) async {
if (_cachedStreamSplitter != null) {
throw StateError('Previously used to cache via `fetchStream`');
}
@@ -74,17 +74,15 @@
/// If [fetchStream] has been called recently enough, returns a copy of its
/// previous return value. Otherwise, runs [callback] and returns its new
/// return value.
- Stream<T> fetchStream(Stream<T> callback()) {
+ Stream<T> fetchStream(Stream<T> Function() callback) {
if (_cachedValueFuture != null) {
throw StateError('Previously used to cache via `fetch`');
}
- if (_cachedStreamSplitter == null) {
- _cachedStreamSplitter = StreamSplitter(callback()
- .transform(StreamTransformer.fromHandlers(handleDone: (sink) {
- _startStaleTimer();
- sink.close();
- })));
- }
+ _cachedStreamSplitter ??= StreamSplitter(
+ callback().transform(StreamTransformer.fromHandlers(handleDone: (sink) {
+ _startStaleTimer();
+ sink.close();
+ })));
return _cachedStreamSplitter.split();
}
diff --git a/lib/src/async_memoizer.dart b/lib/src/async_memoizer.dart
index 5e83400..7e545fe 100644
--- a/lib/src/async_memoizer.dart
+++ b/lib/src/async_memoizer.dart
@@ -39,7 +39,7 @@
/// Runs the function, [computation], if it hasn't been run before.
///
/// If [runOnce] has already been called, this returns the original result.
- Future<T> runOnce(FutureOr<T> computation()) {
+ Future<T> runOnce(FutureOr<T> Function() computation) {
if (!hasRun) _completer.complete(Future.sync(computation));
return future;
}
diff --git a/lib/src/byte_collector.dart b/lib/src/byte_collector.dart
index f01cc2a..0226dea 100644
--- a/lib/src/byte_collector.dart
+++ b/lib/src/byte_collector.dart
@@ -2,9 +2,9 @@
// for details. 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 "dart:typed_data";
-import "cancelable_operation.dart";
+import 'dart:async';
+import 'dart:typed_data';
+import 'cancelable_operation.dart';
/// Collects an asynchronous sequence of byte lists into a single list of bytes.
///
@@ -40,10 +40,8 @@
/// Performs all the same operations, but the final result is created
/// by the [result] function, which has access to the stream subscription
/// so it can cancel the operation.
-T _collectBytes<T>(
- Stream<List<int>> source,
- T result(
- StreamSubscription<List<int>> subscription, Future<Uint8List> result)) {
+T _collectBytes<T>(Stream<List<int>> source,
+ T Function(StreamSubscription<List<int>>, Future<Uint8List>) result) {
var byteLists = <List<int>>[];
var length = 0;
var completer = Completer<Uint8List>.sync();
@@ -63,7 +61,7 @@
// Join a lists of bytes with a known total length into a single [Uint8List].
Uint8List _collect(int length, List<List<int>> byteLists) {
var result = Uint8List(length);
- int i = 0;
+ var i = 0;
for (var byteList in byteLists) {
var end = i + byteList.length;
result.setRange(i, end, byteList);
diff --git a/lib/src/cancelable_operation.dart b/lib/src/cancelable_operation.dart
index 94601c9..bac8f9b 100644
--- a/lib/src/cancelable_operation.dart
+++ b/lib/src/cancelable_operation.dart
@@ -30,7 +30,7 @@
/// [onCancel] will be called synchronously when the operation is canceled.
/// It's guaranteed to only be called once.
factory CancelableOperation.fromFuture(Future<T> inner,
- {FutureOr onCancel()}) {
+ {FutureOr Function() onCancel}) {
var completer = CancelableCompleter<T>(onCancel: onCancel);
completer.complete(inner);
return completer.operation;
@@ -145,7 +145,7 @@
///
/// [onCancel] will be called synchronously when the operation is canceled.
/// It's guaranteed to only be called once.
- CancelableCompleter({FutureOr onCancel()})
+ CancelableCompleter({FutureOr Function() onCancel})
: _onCancel = onCancel,
_inner = Completer<T>() {
_operation = CancelableOperation<T>._(this);
@@ -171,7 +171,7 @@
/// If [value] is a [Future], this will complete to the result of that
/// [Future] once it completes.
void complete([value]) {
- if (_isCompleted) throw StateError("Operation already completed");
+ if (_isCompleted) throw StateError('Operation already completed');
_isCompleted = true;
if (value is! Future) {
@@ -197,7 +197,7 @@
/// Completes [operation] to [error].
void completeError(Object error, [StackTrace stackTrace]) {
- if (_isCompleted) throw StateError("Operation already completed");
+ if (_isCompleted) throw StateError('Operation already completed');
_isCompleted = true;
if (_isCanceled) return;
diff --git a/lib/src/delegate/event_sink.dart b/lib/src/delegate/event_sink.dart
index 95d7841..977ee64 100644
--- a/lib/src/delegate/event_sink.dart
+++ b/lib/src/delegate/event_sink.dart
@@ -25,14 +25,17 @@
static EventSink<T> typed<T>(EventSink sink) =>
sink is EventSink<T> ? sink : DelegatingEventSink._(sink);
+ @override
void add(T data) {
_sink.add(data);
}
+ @override
void addError(error, [StackTrace stackTrace]) {
_sink.addError(error, stackTrace);
}
+ @override
void close() {
_sink.close();
}
diff --git a/lib/src/delegate/future.dart b/lib/src/delegate/future.dart
index 62ff96f..8c5dd04 100644
--- a/lib/src/delegate/future.dart
+++ b/lib/src/delegate/future.dart
@@ -21,16 +21,21 @@
static Future<T> typed<T>(Future future) =>
future is Future<T> ? future : future.then((v) => v as T);
+ @override
Stream<T> asStream() => _future.asStream();
- Future<T> catchError(Function onError, {bool test(Object error)}) =>
+ @override
+ Future<T> catchError(Function onError, {bool Function(Object error) test}) =>
_future.catchError(onError, test: test);
- Future<S> then<S>(FutureOr<S> onValue(T value), {Function onError}) =>
+ @override
+ Future<S> then<S>(FutureOr<S> Function(T) onValue, {Function onError}) =>
_future.then(onValue, onError: onError);
- Future<T> whenComplete(action()) => _future.whenComplete(action);
+ @override
+ Future<T> whenComplete(FutureOr action) => _future.whenComplete(action);
- Future<T> timeout(Duration timeLimit, {onTimeout()}) =>
+ @override
+ Future<T> timeout(Duration timeLimit, {FutureOr<T> Function() onTimeout}) =>
_future.timeout(timeLimit, onTimeout: onTimeout);
}
diff --git a/lib/src/delegate/sink.dart b/lib/src/delegate/sink.dart
index b8ba76d..c1e01d7 100644
--- a/lib/src/delegate/sink.dart
+++ b/lib/src/delegate/sink.dart
@@ -23,10 +23,12 @@
static Sink<T> typed<T>(Sink sink) =>
sink is Sink<T> ? sink : DelegatingSink._(sink);
+ @override
void add(T data) {
_sink.add(data);
}
+ @override
void close() {
_sink.close();
}
diff --git a/lib/src/delegate/stream_consumer.dart b/lib/src/delegate/stream_consumer.dart
index ad53182..591f903 100644
--- a/lib/src/delegate/stream_consumer.dart
+++ b/lib/src/delegate/stream_consumer.dart
@@ -27,7 +27,9 @@
? consumer
: DelegatingStreamConsumer._(consumer);
+ @override
Future addStream(Stream<T> stream) => _consumer.addStream(stream);
+ @override
Future close() => _consumer.close();
}
diff --git a/lib/src/delegate/stream_sink.dart b/lib/src/delegate/stream_sink.dart
index 67eb33c..3971189 100644
--- a/lib/src/delegate/stream_sink.dart
+++ b/lib/src/delegate/stream_sink.dart
@@ -11,6 +11,7 @@
class DelegatingStreamSink<T> implements StreamSink<T> {
final StreamSink _sink;
+ @override
Future get done => _sink.done;
/// Create delegating sink forwarding calls to [sink].
@@ -27,15 +28,19 @@
static StreamSink<T> typed<T>(StreamSink sink) =>
sink is StreamSink<T> ? sink : DelegatingStreamSink._(sink);
+ @override
void add(T data) {
_sink.add(data);
}
+ @override
void addError(error, [StackTrace stackTrace]) {
_sink.addError(error, stackTrace);
}
+ @override
Future addStream(Stream<T> stream) => _sink.addStream(stream);
+ @override
Future close() => _sink.close();
}
diff --git a/lib/src/delegate/stream_subscription.dart b/lib/src/delegate/stream_subscription.dart
index 07af08e..7d258a8 100644
--- a/lib/src/delegate/stream_subscription.dart
+++ b/lib/src/delegate/stream_subscription.dart
@@ -28,29 +28,37 @@
? subscription
: TypeSafeStreamSubscription<T>(subscription);
- void onData(void handleData(T data)) {
+ @override
+ void onData(void Function(T) handleData) {
_source.onData(handleData);
}
+ @override
void onError(Function handleError) {
_source.onError(handleError);
}
- void onDone(void handleDone()) {
+ @override
+ void onDone(void Function() handleDone) {
_source.onDone(handleDone);
}
+ @override
void pause([Future resumeFuture]) {
_source.pause(resumeFuture);
}
+ @override
void resume() {
_source.resume();
}
+ @override
Future cancel() => _source.cancel();
+ @override
Future<E> asFuture<E>([E futureValue]) => _source.asFuture(futureValue);
+ @override
bool get isPaused => _source.isPaused;
}
diff --git a/lib/src/future_group.dart b/lib/src/future_group.dart
index 7e17494..a6abff0 100644
--- a/lib/src/future_group.dart
+++ b/lib/src/future_group.dart
@@ -41,12 +41,8 @@
///
/// Once this group isn't waiting on any futures *and* [close] has been
/// called, this stream will close.
- Stream get onIdle {
- if (_onIdleController == null) {
- _onIdleController = StreamController.broadcast(sync: true);
- }
- return _onIdleController.stream;
- }
+ Stream get onIdle =>
+ (_onIdleController ??= StreamController.broadcast(sync: true)).stream;
StreamController _onIdleController;
@@ -54,11 +50,12 @@
/// the order they were added.
///
/// The slots for futures that haven't completed yet are `null`.
- final _values = List<T>();
+ final _values = <T>[];
/// Wait for [task] to complete.
+ @override
void add(Future<T> task) {
- if (_closed) throw StateError("The FutureGroup is closed.");
+ if (_closed) throw StateError('The FutureGroup is closed.');
// Ensure that future values are put into [values] in the same order they're
// added to the group by pre-allocating a slot for them and recording its
@@ -87,6 +84,7 @@
/// Signals to the group that the caller is done adding futures, and so
/// [future] should fire once all added futures have completed.
+ @override
void close() {
_closed = true;
if (_pending != 0) return;
diff --git a/lib/src/lazy_stream.dart b/lib/src/lazy_stream.dart
index 278957a..d2ac33c 100644
--- a/lib/src/lazy_stream.dart
+++ b/lib/src/lazy_stream.dart
@@ -2,11 +2,11 @@
// for details. 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 'dart:async';
-import "delegate/stream.dart";
-import "stream_completer.dart";
-import "utils.dart";
+import 'delegate/stream.dart';
+import 'stream_completer.dart';
+import 'utils.dart';
/// A [Stream] wrapper that forwards to another [Stream] that's initialized
/// lazily.
@@ -20,15 +20,16 @@
/// Creates a single-subscription `Stream` that calls [callback] when it gets
/// a listener and forwards to the returned stream.
- LazyStream(FutureOr<Stream<T>> callback()) : _callback = callback {
+ LazyStream(FutureOr<Stream<T>> Function() callback) : _callback = callback {
// Explicitly check for null because we null out [_callback] internally.
if (_callback == null) throw ArgumentError.notNull('callback');
}
- StreamSubscription<T> listen(void onData(T event),
- {Function onError, void onDone(), bool cancelOnError}) {
+ @override
+ StreamSubscription<T> listen(void Function(T) onData,
+ {Function onError, void Function() onDone, bool cancelOnError}) {
if (_callback == null) {
- throw StateError("Stream has already been listened to.");
+ throw StateError('Stream has already been listened to.');
}
// Null out the callback before we invoke it to ensure that even while
diff --git a/lib/src/null_stream_sink.dart b/lib/src/null_stream_sink.dart
index c9d3d5d..f820328 100644
--- a/lib/src/null_stream_sink.dart
+++ b/lib/src/null_stream_sink.dart
@@ -26,6 +26,7 @@
/// }
/// ```
class NullStreamSink<T> implements StreamSink<T> {
+ @override
final Future done;
/// Whether the sink has been closed.
@@ -54,14 +55,17 @@
// experiencing an error.
..catchError((_) {});
+ @override
void add(T data) {
_checkEventAllowed();
}
+ @override
void addError(error, [StackTrace stackTrace]) {
_checkEventAllowed();
}
+ @override
Future addStream(Stream<T> stream) {
_checkEventAllowed();
@@ -75,12 +79,13 @@
/// Throws a [StateError] if [close] has been called or an [addStream] call is
/// pending.
void _checkEventAllowed() {
- if (_closed) throw StateError("Cannot add to a closed sink.");
+ if (_closed) throw StateError('Cannot add to a closed sink.');
if (_addingStream) {
- throw StateError("Cannot add to a sink while adding a stream.");
+ throw StateError('Cannot add to a sink while adding a stream.');
}
}
+ @override
Future close() {
_closed = true;
return done;
diff --git a/lib/src/restartable_timer.dart b/lib/src/restartable_timer.dart
index 4720bcd..9ecf443 100644
--- a/lib/src/restartable_timer.dart
+++ b/lib/src/restartable_timer.dart
@@ -28,6 +28,7 @@
RestartableTimer(this._duration, this._callback)
: _timer = Timer(_duration, _callback);
+ @override
bool get isActive => _timer.isActive;
/// Restarts the timer so that it counts down from its original duration
@@ -39,6 +40,7 @@
_timer = Timer(_duration, _callback);
}
+ @override
void cancel() {
_timer.cancel();
}
@@ -48,5 +50,6 @@
///
/// Calls to [reset] will also reset the tick so subsequent tick values may
/// not be strictly larger than previous values.
+ @override
int get tick => _timer.tick;
}
diff --git a/lib/src/result/capture_sink.dart b/lib/src/result/capture_sink.dart
index 0477a19..a7c3a59 100644
--- a/lib/src/result/capture_sink.dart
+++ b/lib/src/result/capture_sink.dart
@@ -12,14 +12,17 @@
CaptureSink(EventSink<Result<T>> sink) : _sink = sink;
+ @override
void add(T value) {
_sink.add(Result<T>.value(value));
}
+ @override
void addError(Object error, [StackTrace stackTrace]) {
_sink.add(Result.error(error, stackTrace));
}
+ @override
void close() {
_sink.close();
}
diff --git a/lib/src/result/capture_transformer.dart b/lib/src/result/capture_transformer.dart
index a727a8e..1f58d06 100644
--- a/lib/src/result/capture_transformer.dart
+++ b/lib/src/result/capture_transformer.dart
@@ -14,6 +14,7 @@
class CaptureStreamTransformer<T> extends StreamTransformerBase<T, Result<T>> {
const CaptureStreamTransformer();
+ @override
Stream<Result<T>> bind(Stream<T> source) =>
Stream<Result<T>>.eventTransformed(
source, (sink) => CaptureSink<T>(sink));
diff --git a/lib/src/result/error.dart b/lib/src/result/error.dart
index 8f29d13..76e0275 100644
--- a/lib/src/result/error.dart
+++ b/lib/src/result/error.dart
@@ -15,21 +15,28 @@
/// The stack trace corresponding to where [error] was thrown.
final StackTrace stackTrace;
+ @override
bool get isValue => false;
+ @override
bool get isError => true;
+ @override
ValueResult<Null> get asValue => null;
+ @override
ErrorResult get asError => this;
ErrorResult(this.error, this.stackTrace);
+ @override
void complete(Completer completer) {
completer.completeError(error, stackTrace);
}
+ @override
void addTo(EventSink sink) {
sink.addError(error, stackTrace);
}
+ @override
Future<Null> get asFuture => Future<Null>.error(error, stackTrace);
/// Calls an error handler with the error and stacktrace.
@@ -46,9 +53,11 @@
}
}
+ @override
int get hashCode => error.hashCode ^ stackTrace.hashCode ^ 0x1d61823f;
/// This is equal only to an error result with equal [error] and [stackTrace].
+ @override
bool operator ==(Object other) =>
other is ErrorResult &&
error == other.error &&
diff --git a/lib/src/result/release_sink.dart b/lib/src/result/release_sink.dart
index a0715a1..78d0f42 100644
--- a/lib/src/result/release_sink.dart
+++ b/lib/src/result/release_sink.dart
@@ -12,16 +12,19 @@
ReleaseSink(EventSink<T> sink) : _sink = sink;
+ @override
void add(Result<T> result) {
result.addTo(_sink);
}
+ @override
void addError(Object error, [StackTrace stackTrace]) {
// Errors may be added by intermediate processing, even if it is never
// added by CaptureSink.
_sink.addError(error, stackTrace);
}
+ @override
void close() {
_sink.close();
}
diff --git a/lib/src/result/release_transformer.dart b/lib/src/result/release_transformer.dart
index 1aead30..2548ac9 100644
--- a/lib/src/result/release_transformer.dart
+++ b/lib/src/result/release_transformer.dart
@@ -11,6 +11,7 @@
class ReleaseStreamTransformer<T> extends StreamTransformerBase<Result<T>, T> {
const ReleaseStreamTransformer();
+ @override
Stream<T> bind(Stream<Result<T>> source) {
return Stream<T>.eventTransformed(source, _createSink);
}
diff --git a/lib/src/result/result.dart b/lib/src/result/result.dart
index 28799fa..e04da9f 100644
--- a/lib/src/result/result.dart
+++ b/lib/src/result/result.dart
@@ -60,7 +60,7 @@
/// This generates either a [ValueResult] with the value returned by
/// calling `computation`, or an [ErrorResult] with an error thrown by
/// the call.
- factory Result(T computation()) {
+ factory Result(T Function() computation) {
try {
return ValueResult<T>(computation());
} catch (e, s) {
@@ -97,11 +97,11 @@
/// The returned future will never have an error.
static Future<List<Result<T>>> captureAll<T>(Iterable<FutureOr<T>> elements) {
var results = <Result<T>>[];
- int pending = 0;
+ var pending = 0;
Completer<List<Result<T>>> completer;
for (var element in elements) {
if (element is Future<T>) {
- int i = results.length;
+ var i = results.length;
results.add(null);
pending++;
Result.capture<T>(element).then((result) {
diff --git a/lib/src/result/value.dart b/lib/src/result/value.dart
index dddc9fe..5c1a60f 100644
--- a/lib/src/result/value.dart
+++ b/lib/src/result/value.dart
@@ -12,25 +12,34 @@
/// The result of a successful computation.
final T value;
+ @override
bool get isValue => true;
+ @override
bool get isError => false;
+ @override
ValueResult<T> get asValue => this;
+ @override
ErrorResult get asError => null;
ValueResult(this.value);
+ @override
void complete(Completer<T> completer) {
completer.complete(value);
}
+ @override
void addTo(EventSink<T> sink) {
sink.add(value);
}
+ @override
Future<T> get asFuture => Future.value(value);
+ @override
int get hashCode => value.hashCode ^ 0x323f1d61;
+ @override
bool operator ==(Object other) =>
other is ValueResult && value == other.value;
}
diff --git a/lib/src/single_subscription_transformer.dart b/lib/src/single_subscription_transformer.dart
index 8007a42..fe939fc 100644
--- a/lib/src/single_subscription_transformer.dart
+++ b/lib/src/single_subscription_transformer.dart
@@ -16,6 +16,7 @@
class SingleSubscriptionTransformer<S, T> extends StreamTransformerBase<S, T> {
const SingleSubscriptionTransformer();
+ @override
Stream<T> bind(Stream<S> stream) {
StreamSubscription<S> subscription;
var controller =
diff --git a/lib/src/stream_completer.dart b/lib/src/stream_completer.dart
index bbb2155..5128d57 100644
--- a/lib/src/stream_completer.dart
+++ b/lib/src/stream_completer.dart
@@ -2,7 +2,7 @@
// for details. 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 'dart:async';
/// A single-subscription [stream] where the contents are provided later.
///
@@ -75,7 +75,7 @@
/// most once. Trying to call any of them again will fail.
void setSourceStream(Stream<T> sourceStream) {
if (_stream._isSourceStreamSet) {
- throw StateError("Source stream already set");
+ throw StateError('Source stream already set');
}
_stream._setSourceStream(sourceStream);
}
@@ -86,7 +86,7 @@
/// most once. Trying to call any of them again will fail.
void setEmpty() {
if (_stream._isSourceStreamSet) {
- throw StateError("Source stream already set");
+ throw StateError('Source stream already set');
}
_stream._setEmpty();
}
@@ -116,8 +116,9 @@
/// or [_setEmpty].
Stream<T> _sourceStream;
- StreamSubscription<T> listen(onData(T data),
- {Function onError, void onDone(), bool cancelOnError}) {
+ @override
+ StreamSubscription<T> listen(void Function(T) onData,
+ {Function onError, void Function() onDone, bool cancelOnError}) {
if (_controller == null) {
if (_sourceStream != null && !_sourceStream.isBroadcast) {
// If the source stream is itself single subscription,
diff --git a/lib/src/stream_group.dart b/lib/src/stream_group.dart
index 1a6d15d..8ea95f3 100644
--- a/lib/src/stream_group.dart
+++ b/lib/src/stream_group.dart
@@ -47,7 +47,7 @@
/// subscriptions will be canceled and set to null again. Single-subscriber
/// stream subscriptions will be left intact, since they can't be
/// re-subscribed.
- final _subscriptions = Map<Stream<T>, StreamSubscription<T>>();
+ final _subscriptions = <Stream<T>, StreamSubscription<T>>{};
/// Merges the events from [streams] into a single single-subscription stream.
///
@@ -99,6 +99,7 @@
/// `null`.
///
/// Throws a [StateError] if this group is closed.
+ @override
Future add(Stream<T> stream) {
if (_closed) {
throw StateError("Can't add a Stream to a closed StreamGroup.");
@@ -214,6 +215,7 @@
/// Otherwise, [stream] will close once all streams in the group close.
///
/// Returns a [Future] that completes once [stream] has actually been closed.
+ @override
Future close() {
if (_closed) return _controller.done;
@@ -230,12 +232,12 @@
///
/// New streams added to the group will be listened once the group has a
/// listener.
- static const dormant = _StreamGroupState("dormant");
+ static const dormant = _StreamGroupState('dormant');
/// The group has one or more listeners and is actively firing events.
///
/// New streams added to the group will be immediately listeners.
- static const listening = _StreamGroupState("listening");
+ static const listening = _StreamGroupState('listening');
/// The group is paused and no more events will be fired until it resumes.
///
@@ -243,7 +245,7 @@
/// will be resumed once the group itself is resumed.
///
/// This state is only used by single-subscriber groups.
- static const paused = _StreamGroupState("paused");
+ static const paused = _StreamGroupState('paused');
/// The group is canceled and no more events will be fired ever.
///
@@ -251,7 +253,7 @@
/// discarded.
///
/// This state is only used by single-subscriber groups.
- static const canceled = _StreamGroupState("canceled");
+ static const canceled = _StreamGroupState('canceled');
/// The name of the state.
///
@@ -260,5 +262,6 @@
const _StreamGroupState(this.name);
+ @override
String toString() => name;
}
diff --git a/lib/src/stream_queue.dart b/lib/src/stream_queue.dart
index fd3186e..cf75a6d 100644
--- a/lib/src/stream_queue.dart
+++ b/lib/src/stream_queue.dart
@@ -7,11 +7,11 @@
import 'package:collection/collection.dart';
-import "cancelable_operation.dart";
-import "result/result.dart";
-import "subscription_stream.dart";
-import "stream_completer.dart";
-import "stream_splitter.dart";
+import 'cancelable_operation.dart';
+import 'result/result.dart';
+import 'subscription_stream.dart';
+import 'stream_completer.dart';
+import 'stream_splitter.dart';
/// An asynchronous pull-based interface for accessing stream events.
///
@@ -146,7 +146,7 @@
/// If one of the next [count] events is an error, the returned future
/// completes with this error, and the error is still left in the queue.
Future<List<T>> lookAhead(int count) {
- if (count < 0) throw RangeError.range(count, 0, null, "count");
+ if (count < 0) throw RangeError.range(count, 0, null, 'count');
if (!_isClosed) {
var request = _LookAheadRequest<T>(count);
_addRequest(request);
@@ -226,7 +226,7 @@
/// then all events were succssfully skipped. If the value
/// is greater than zero then the stream ended early.
Future<int> skip(int count) {
- if (count < 0) throw RangeError.range(count, 0, null, "count");
+ if (count < 0) throw RangeError.range(count, 0, null, 'count');
if (!_isClosed) {
var request = _SkipRequest<T>(count);
_addRequest(request);
@@ -251,7 +251,7 @@
/// of data collected so far. That is, the returned
/// list may have fewer than [count] elements.
Future<List<T>> take(int count) {
- if (count < 0) throw RangeError.range(count, 0, null, "count");
+ if (count < 0) throw RangeError.range(count, 0, null, 'count');
if (!_isClosed) {
var request = _TakeRequest<T>(count);
_addRequest(request);
@@ -324,7 +324,7 @@
/// }
/// }
/// ```
- Future<bool> withTransaction(Future<bool> callback(StreamQueue<T> queue)) {
+ Future<bool> withTransaction(Future<bool> Function(StreamQueue<T>) callback) {
var transaction = startTransaction();
/// Avoid async/await to ensure that [startTransaction] is called
@@ -363,7 +363,7 @@
/// _stdinQueue.cancelable((queue) => queue.next);
/// ```
CancelableOperation<S> cancelable<S>(
- Future<S> callback(StreamQueue<T> queue)) {
+ Future<S> Function(StreamQueue<T>) callback) {
var transaction = startTransaction();
var completer = CancelableCompleter<S>(onCancel: () {
transaction.reject();
@@ -486,7 +486,7 @@
_addResult(Result.error(error, stackTrace));
}, onDone: () {
_subscription = null;
- this._close();
+ _close();
});
} else {
_subscription.resume();
@@ -529,7 +529,7 @@
/// Returns a [StateError] with a message saying that either
/// [cancel] or [rest] have already been called.
Error _failClosed() {
- return StateError("Already cancelled");
+ return StateError('Already cancelled');
}
/// Adds a new request to the queue.
@@ -558,7 +558,7 @@
final StreamSplitter<T> _splitter;
/// Queues created using [newQueue].
- final _queues = Set<StreamQueue>();
+ final _queues = <StreamQueue>{};
/// Whether [commit] has been called.
var _committed = false;
@@ -639,9 +639,9 @@
/// Throws a [StateError] if [accept] or [reject] has already been called.
void _assertActive() {
if (_committed) {
- throw StateError("This transaction has already been accepted.");
+ throw StateError('This transaction has already been accepted.');
} else if (_rejected) {
- throw StateError("This transaction has already been rejected.");
+ throw StateError('This transaction has already been rejected.');
}
}
}
@@ -696,13 +696,14 @@
Future<T> get future => _completer.future;
+ @override
bool update(QueueList<Result<T>> events, bool isDone) {
if (events.isNotEmpty) {
events.removeFirst().complete(_completer);
return true;
}
if (isDone) {
- _completer.completeError(StateError("No elements"), StackTrace.current);
+ _completer.completeError(StateError('No elements'), StackTrace.current);
return true;
}
return false;
@@ -721,13 +722,14 @@
Future<T> get future => _completer.future;
+ @override
bool update(QueueList<Result<T>> events, bool isDone) {
if (events.isNotEmpty) {
events.first.complete(_completer);
return true;
}
if (isDone) {
- _completer.completeError(StateError("No elements"), StackTrace.current);
+ _completer.completeError(StateError('No elements'), StackTrace.current);
return true;
}
return false;
@@ -752,6 +754,7 @@
/// The future completed when the correct number of events have been skipped.
Future<int> get future => _completer.future;
+ @override
bool update(QueueList<Result<T>> events, bool isDone) {
while (_eventsToSkip > 0) {
if (events.isEmpty) {
@@ -795,6 +798,7 @@
class _TakeRequest<T> extends _ListRequest<T> {
_TakeRequest(int eventsToTake) : super(eventsToTake);
+ @override
bool update(QueueList<Result<T>> events, bool isDone) {
while (_list.length < _eventsToTake) {
if (events.isEmpty) {
@@ -818,6 +822,7 @@
class _LookAheadRequest<T> extends _ListRequest<T> {
_LookAheadRequest(int eventsToTake) : super(eventsToTake);
+ @override
bool update(QueueList<Result<T>> events, bool isDone) {
while (_list.length < _eventsToTake) {
if (events.length == _list.length) {
@@ -855,6 +860,7 @@
/// The future completed when the cancel request is completed.
Future get future => _completer.future;
+ @override
bool update(QueueList<Result<T>> events, bool isDone) {
if (_streamQueue._isDone) {
_completer.complete();
@@ -886,6 +892,7 @@
/// The stream which will contain the remaining events of [_streamQueue].
Stream<T> get stream => _completer.stream;
+ @override
bool update(QueueList<Result<T>> events, bool isDone) {
if (events.isEmpty) {
if (_streamQueue._isDone) {
@@ -920,6 +927,7 @@
Future<bool> get future => _completer.future;
+ @override
bool update(QueueList<Result<T>> events, bool isDone) {
if (events.isNotEmpty) {
_completer.complete(true);
@@ -954,6 +962,7 @@
_transaction = StreamQueueTransaction._(parent, _controller.stream);
}
+ @override
bool update(QueueList<Result<T>> events, bool isDone) {
while (_eventsSent < events.length) {
events[_eventsSent++].addTo(_controller);
diff --git a/lib/src/stream_sink_completer.dart b/lib/src/stream_sink_completer.dart
index c7fdd03..3b31576 100644
--- a/lib/src/stream_sink_completer.dart
+++ b/lib/src/stream_sink_completer.dart
@@ -59,7 +59,7 @@
/// Trying to call either of them again will fail.
void setDestinationSink(StreamSink<T> destinationSink) {
if (_sink._destinationSink != null) {
- throw StateError("Destination sink already set");
+ throw StateError('Destination sink already set');
}
_sink._setDestinationSink(destinationSink);
}
@@ -98,6 +98,7 @@
/// to going through [_controller].
bool get _canSendDirectly => _controller == null && _destinationSink != null;
+ @override
Future get done {
if (_doneCompleter != null) return _doneCompleter.future;
if (_destinationSink == null) {
@@ -107,6 +108,7 @@
return _destinationSink.done;
}
+ @override
void add(T event) {
if (_canSendDirectly) {
_destinationSink.add(event);
@@ -116,6 +118,7 @@
}
}
+ @override
void addError(error, [StackTrace stackTrace]) {
if (_canSendDirectly) {
_destinationSink.addError(error, stackTrace);
@@ -125,6 +128,7 @@
}
}
+ @override
Future addStream(Stream<T> stream) {
if (_canSendDirectly) return _destinationSink.addStream(stream);
@@ -132,6 +136,7 @@
return _controller.addStream(stream, cancelOnError: false);
}
+ @override
Future close() {
if (_canSendDirectly) {
_destinationSink.close();
@@ -144,7 +149,7 @@
/// Create [_controller] if it doesn't yet exist.
void _ensureController() {
- if (_controller == null) _controller = StreamController(sync: true);
+ _controller ??= StreamController(sync: true);
}
/// Sets the destination sink to which events from this sink will be provided.
diff --git a/lib/src/stream_sink_transformer.dart b/lib/src/stream_sink_transformer.dart
index b01132e..c50cf17 100644
--- a/lib/src/stream_sink_transformer.dart
+++ b/lib/src/stream_sink_transformer.dart
@@ -34,9 +34,9 @@
/// they're passed are forwarded to the inner sink. If a handler is omitted,
/// the event is passed through unaltered.
factory StreamSinkTransformer.fromHandlers(
- {void handleData(S data, EventSink<T> sink),
- void handleError(Object error, StackTrace stackTrace, EventSink<T> sink),
- void handleDone(EventSink<T> sink)}) {
+ {void Function(S, EventSink<T>) handleData,
+ void Function(Object, StackTrace, EventSink<T>) handleError,
+ void Function(EventSink<T>) handleDone}) {
return HandlerTransformer<S, T>(handleData, handleError, handleDone);
}
diff --git a/lib/src/stream_sink_transformer/handler_transformer.dart b/lib/src/stream_sink_transformer/handler_transformer.dart
index 3137003..8d37ce3 100644
--- a/lib/src/stream_sink_transformer/handler_transformer.dart
+++ b/lib/src/stream_sink_transformer/handler_transformer.dart
@@ -30,6 +30,7 @@
HandlerTransformer(this._handleData, this._handleError, this._handleDone);
+ @override
StreamSink<S> bind(StreamSink<T> sink) => _HandlerSink<S, T>(this, sink);
}
@@ -45,12 +46,14 @@
/// errors.
final StreamSink<T> _safeCloseInner;
+ @override
Future get done => _inner.done;
_HandlerSink(this._transformer, StreamSink<T> inner)
: _inner = inner,
_safeCloseInner = _SafeCloseSink<T>(inner);
+ @override
void add(S event) {
if (_transformer._handleData == null) {
_inner.add(event as T);
@@ -59,6 +62,7 @@
}
}
+ @override
void addError(error, [StackTrace stackTrace]) {
if (_transformer._handleError == null) {
_inner.addError(error, stackTrace);
@@ -67,6 +71,7 @@
}
}
+ @override
Future addStream(Stream<S> stream) {
return _inner.addStream(stream.transform(
StreamTransformer<S, T>.fromHandlers(
@@ -75,6 +80,7 @@
handleDone: _closeSink)));
}
+ @override
Future close() {
if (_transformer._handleDone == null) return _inner.close();
@@ -91,6 +97,7 @@
class _SafeCloseSink<T> extends DelegatingStreamSink<T> {
_SafeCloseSink(StreamSink<T> inner) : super(inner);
+ @override
Future close() => super.close().catchError((_) {});
}
diff --git a/lib/src/stream_sink_transformer/stream_transformer_wrapper.dart b/lib/src/stream_sink_transformer/stream_transformer_wrapper.dart
index 1010f9f..1df7e5a 100644
--- a/lib/src/stream_sink_transformer/stream_transformer_wrapper.dart
+++ b/lib/src/stream_sink_transformer/stream_transformer_wrapper.dart
@@ -13,6 +13,7 @@
const StreamTransformerWrapper(this._transformer);
+ @override
StreamSink<S> bind(StreamSink<T> sink) =>
_StreamTransformerWrapperSink<S, T>(_transformer, sink);
}
@@ -28,6 +29,7 @@
/// The original sink that's being transformed.
final StreamSink<T> _inner;
+ @override
Future get done => _inner.done;
_StreamTransformerWrapperSink(
@@ -42,16 +44,20 @@
});
}
+ @override
void add(S event) {
_controller.add(event);
}
+ @override
void addError(error, [StackTrace stackTrace]) {
_controller.addError(error, stackTrace);
}
+ @override
Future addStream(Stream<S> stream) => _controller.addStream(stream);
+ @override
Future close() {
_controller.close();
return _inner.done;
diff --git a/lib/src/stream_sink_transformer/typed.dart b/lib/src/stream_sink_transformer/typed.dart
index 303bc08..c27bd24 100644
--- a/lib/src/stream_sink_transformer/typed.dart
+++ b/lib/src/stream_sink_transformer/typed.dart
@@ -15,6 +15,7 @@
TypeSafeStreamSinkTransformer(this._inner);
+ @override
StreamSink<S> bind(StreamSink<T> sink) =>
DelegatingStreamSink.typed(_inner.bind(sink));
}
diff --git a/lib/src/stream_splitter.dart b/lib/src/stream_splitter.dart
index df0ff44..e9f326e 100644
--- a/lib/src/stream_splitter.dart
+++ b/lib/src/stream_splitter.dart
@@ -32,14 +32,14 @@
/// The buffer of events or errors that have already been emitted by
/// [_stream].
- final _buffer = List<Result<T>>();
+ final _buffer = <Result<T>>[];
/// The controllers for branches that are listening for future events from
/// [_stream].
///
/// Once a branch is canceled, it's removed from this list. When [_stream] is
/// done, all branches are removed.
- final _controllers = Set<StreamController<T>>();
+ final _controllers = <StreamController<T>>{};
/// A group of futures returned by [close].
///
@@ -58,7 +58,7 @@
/// [count] defaults to 2. This is the same as creating [count] branches and
/// then closing the [StreamSplitter].
static List<Stream<T>> splitFrom<T>(Stream<T> stream, [int count]) {
- if (count == null) count = 2;
+ count ??= 2;
var splitter = StreamSplitter<T>(stream);
var streams = List<Stream<T>>.generate(count, (_) => splitter.split());
splitter.close();
diff --git a/lib/src/stream_subscription_transformer.dart b/lib/src/stream_subscription_transformer.dart
index bee96a5..0e28972 100644
--- a/lib/src/stream_subscription_transformer.dart
+++ b/lib/src/stream_subscription_transformer.dart
@@ -28,9 +28,9 @@
/// [StreamSubscription]: [handleCancel] must call `cancel()`, [handlePause]
/// must call `pause()`, and [handleResume] must call `resume()`.
StreamTransformer<T, T> subscriptionTransformer<T>(
- {Future handleCancel(StreamSubscription<T> inner),
- void handlePause(StreamSubscription<T> inner),
- void handleResume(StreamSubscription<T> inner)}) {
+ {Future Function(StreamSubscription<T>) handleCancel,
+ void Function(StreamSubscription<T>) handlePause,
+ void Function(StreamSubscription<T>) handleResume}) {
return StreamTransformer((stream, cancelOnError) {
return _TransformedSubscription(
stream.listen(null, cancelOnError: cancelOnError),
@@ -61,23 +61,28 @@
/// The callback to run when [resume] is called.
final _VoidHandler<T> _handleResume;
+ @override
bool get isPaused => _inner?.isPaused ?? false;
_TransformedSubscription(
this._inner, this._handleCancel, this._handlePause, this._handleResume);
- void onData(void handleData(T data)) {
+ @override
+ void onData(void Function(T) handleData) {
_inner?.onData(handleData);
}
+ @override
void onError(Function handleError) {
_inner?.onError(handleError);
}
- void onDone(void handleDone()) {
+ @override
+ void onDone(void Function() handleDone) {
_inner?.onDone(handleDone);
}
+ @override
Future cancel() => _cancelMemoizer.runOnce(() {
var inner = _inner;
_inner.onData(null);
@@ -90,17 +95,20 @@
});
final _cancelMemoizer = AsyncMemoizer();
+ @override
void pause([Future resumeFuture]) {
if (_cancelMemoizer.hasRun) return;
if (resumeFuture != null) resumeFuture.whenComplete(resume);
_handlePause(_inner);
}
+ @override
void resume() {
if (_cancelMemoizer.hasRun) return;
_handleResume(_inner);
}
+ @override
Future<E> asFuture<E>([E futureValue]) =>
_inner?.asFuture(futureValue) ?? Completer<E>().future;
}
diff --git a/lib/src/stream_zip.dart b/lib/src/stream_zip.dart
index ef14c3e..e319746 100644
--- a/lib/src/stream_zip.dart
+++ b/lib/src/stream_zip.dart
@@ -2,7 +2,7 @@
// for details. 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 'dart:async';
/// A stream that combines the values of other streams.
///
@@ -17,13 +17,14 @@
StreamZip(Iterable<Stream<T>> streams) : _streams = streams;
- StreamSubscription<List<T>> listen(void onData(List<T> data),
- {Function onError, void onDone(), bool cancelOnError}) {
+ @override
+ StreamSubscription<List<T>> listen(void Function(List<T>) onData,
+ {Function onError, void Function() onDone, bool cancelOnError}) {
cancelOnError = identical(true, cancelOnError);
var subscriptions = <StreamSubscription<T>>[];
StreamController<List<T>> controller;
List<T> current;
- int dataCount = 0;
+ var dataCount = 0;
/// Called for each data from a subscription in [subscriptions].
void handleData(int index, T data) {
@@ -33,7 +34,7 @@
var data = current;
current = List(subscriptions.length);
dataCount = 0;
- for (int i = 0; i < subscriptions.length; i++) {
+ for (var i = 0; i < subscriptions.length; i++) {
if (i != index) subscriptions[i].resume();
}
controller.add(data);
@@ -54,14 +55,14 @@
/// Prematurely cancels all subscriptions since we know that we won't
/// be needing any more values.
void handleErrorCancel(Object error, StackTrace stackTrace) {
- for (int i = 0; i < subscriptions.length; i++) {
+ for (var i = 0; i < subscriptions.length; i++) {
subscriptions[i].cancel();
}
controller.addError(error, stackTrace);
}
void handleDone() {
- for (int i = 0; i < subscriptions.length; i++) {
+ for (var i = 0; i < subscriptions.length; i++) {
subscriptions[i].cancel();
}
controller.close();
@@ -69,7 +70,7 @@
try {
for (var stream in _streams) {
- int index = subscriptions.length;
+ var index = subscriptions.length;
subscriptions.add(stream.listen((data) {
handleData(index, data);
},
@@ -78,7 +79,7 @@
cancelOnError: cancelOnError));
}
} catch (e) {
- for (int i = subscriptions.length - 1; i >= 0; i--) {
+ for (var i = subscriptions.length - 1; i >= 0; i--) {
subscriptions[i].cancel();
}
rethrow;
@@ -87,18 +88,18 @@
current = List(subscriptions.length);
controller = StreamController<List<T>>(onPause: () {
- for (int i = 0; i < subscriptions.length; i++) {
+ for (var i = 0; i < subscriptions.length; i++) {
// This may pause some subscriptions more than once.
// These will not be resumed by onResume below, but must wait for the
// next round.
subscriptions[i].pause();
}
}, onResume: () {
- for (int i = 0; i < subscriptions.length; i++) {
+ for (var i = 0; i < subscriptions.length; i++) {
subscriptions[i].resume();
}
}, onCancel: () {
- for (int i = 0; i < subscriptions.length; i++) {
+ for (var i = 0; i < subscriptions.length; i++) {
// Canceling more than once is safe.
subscriptions[i].cancel();
}
diff --git a/lib/src/subscription_stream.dart b/lib/src/subscription_stream.dart
index 347c346..b428619 100644
--- a/lib/src/subscription_stream.dart
+++ b/lib/src/subscription_stream.dart
@@ -4,7 +4,7 @@
import 'dart:async';
-import "delegate/stream_subscription.dart";
+import 'delegate/stream_subscription.dart';
/// A [Stream] adapter for a [StreamSubscription].
///
@@ -38,10 +38,11 @@
_source.onDone(null);
}
- StreamSubscription<T> listen(void onData(T event),
- {Function onError, void onDone(), bool cancelOnError}) {
+ @override
+ StreamSubscription<T> listen(void Function(T) onData,
+ {Function onError, void Function() onDone, bool cancelOnError}) {
if (_source == null) {
- throw StateError("Stream has already been listened to.");
+ throw StateError('Stream has already been listened to.');
}
cancelOnError = (true == cancelOnError);
var subscription = _source;
@@ -69,6 +70,7 @@
_CancelOnErrorSubscriptionWrapper(StreamSubscription<T> subscription)
: super(subscription);
+ @override
void onError(Function handleError) {
// Cancel when receiving an error.
super.onError((error, StackTrace stackTrace) {
diff --git a/lib/src/typed/stream_subscription.dart b/lib/src/typed/stream_subscription.dart
index 0fab039..d85b776 100644
--- a/lib/src/typed/stream_subscription.dart
+++ b/lib/src/typed/stream_subscription.dart
@@ -7,31 +7,39 @@
class TypeSafeStreamSubscription<T> implements StreamSubscription<T> {
final StreamSubscription _subscription;
+ @override
bool get isPaused => _subscription.isPaused;
TypeSafeStreamSubscription(this._subscription);
- void onData(void handleData(T data)) {
+ @override
+ void onData(void Function(T) handleData) {
_subscription.onData((data) => handleData(data as T));
}
+ @override
void onError(Function handleError) {
_subscription.onError(handleError);
}
- void onDone(void handleDone()) {
+ @override
+ void onDone(void Function() handleDone) {
_subscription.onDone(handleDone);
}
+ @override
void pause([Future resumeFuture]) {
_subscription.pause(resumeFuture);
}
+ @override
void resume() {
_subscription.resume();
}
+ @override
Future cancel() => _subscription.cancel();
+ @override
Future<E> asFuture<E>([E futureValue]) => _subscription.asFuture(futureValue);
}
diff --git a/lib/src/typed_stream_transformer.dart b/lib/src/typed_stream_transformer.dart
index 9750eb4..2366505 100644
--- a/lib/src/typed_stream_transformer.dart
+++ b/lib/src/typed_stream_transformer.dart
@@ -25,6 +25,7 @@
_TypeSafeStreamTransformer(this._inner);
+ @override
Stream<T> bind(Stream<S> stream) =>
DelegatingStream.typed(_inner.bind(stream));
}
diff --git a/pubspec.yaml b/pubspec.yaml
index f2439a8..e472203 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -6,7 +6,7 @@
homepage: https://www.github.com/dart-lang/async
environment:
- sdk: '>=2.0.0 <3.0.0'
+ sdk: '>=2.2.0 <3.0.0'
dependencies:
collection: ^1.5.0
diff --git a/test/async_cache_test.dart b/test/async_cache_test.dart
index b7f7b8e..4efbb69 100644
--- a/test/async_cache_test.dart
+++ b/test/async_cache_test.dart
@@ -39,7 +39,7 @@
test('should fetch via a callback again when cache expires', () {
FakeAsync().run((fakeAsync) async {
var timesCalled = 0;
- call() async => 'Called ${++timesCalled}';
+ Future<String> call() async => 'Called ${++timesCalled}';
expect(await cache.fetch(call), 'Called 1');
expect(await cache.fetch(call), 'Called 1', reason: 'Cache still fresh');
@@ -57,7 +57,7 @@
test('should fetch via a callback when manually invalidated', () async {
var timesCalled = 0;
- call() async => 'Called ${++timesCalled}';
+ Future<String> call() async => 'Called ${++timesCalled}';
expect(await cache.fetch(call), 'Called 1');
cache.invalidate();
expect(await cache.fetch(call), 'Called 2');
diff --git a/test/async_memoizer_test.dart b/test/async_memoizer_test.dart
index 785f9a5..982f7c9 100644
--- a/test/async_memoizer_test.dart
+++ b/test/async_memoizer_test.dart
@@ -5,11 +5,11 @@
import 'package:async/async.dart';
import 'package:test/test.dart';
-main() {
+void main() {
AsyncMemoizer cache;
setUp(() => cache = AsyncMemoizer());
- test("runs the function only the first time runOnce() is called", () async {
+ test('runs the function only the first time runOnce() is called', () async {
var count = 0;
expect(await cache.runOnce(() => count++), equals(0));
expect(count, equals(1));
@@ -18,21 +18,21 @@
expect(count, equals(1));
});
- test("forwards the return value from the function", () async {
- expect(cache.future, completion(equals("value")));
- expect(cache.runOnce(() => "value"), completion(equals("value")));
- expect(cache.runOnce(() {}), completion(equals("value")));
+ test('forwards the return value from the function', () async {
+ expect(cache.future, completion(equals('value')));
+ expect(cache.runOnce(() => 'value'), completion(equals('value')));
+ expect(cache.runOnce(() {}), completion(equals('value')));
});
- test("forwards the return value from an async function", () async {
- expect(cache.future, completion(equals("value")));
- expect(cache.runOnce(() async => "value"), completion(equals("value")));
- expect(cache.runOnce(() {}), completion(equals("value")));
+ test('forwards the return value from an async function', () async {
+ expect(cache.future, completion(equals('value')));
+ expect(cache.runOnce(() async => 'value'), completion(equals('value')));
+ expect(cache.runOnce(() {}), completion(equals('value')));
});
- test("forwards the error from an async function", () async {
- expect(cache.future, throwsA("error"));
- expect(cache.runOnce(() async => throw "error"), throwsA("error"));
- expect(cache.runOnce(() {}), throwsA("error"));
+ test('forwards the error from an async function', () async {
+ expect(cache.future, throwsA('error'));
+ expect(cache.runOnce(() async => throw 'error'), throwsA('error'));
+ expect(cache.runOnce(() {}), throwsA('error'));
});
}
diff --git a/test/byte_collection_test.dart b/test/byte_collection_test.dart
index 24d218b..7f2ecc6 100644
--- a/test/byte_collection_test.dart
+++ b/test/byte_collection_test.dart
@@ -2,14 +2,14 @@
// for details. 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 'dart:async';
-import "package:test/test.dart";
-import "package:async/async.dart";
+import 'package:test/test.dart';
+import 'package:async/async.dart';
void main() {
- group("collectBytes", () {
- test("simple list and overflow", () {
+ group('collectBytes', () {
+ test('simple list and overflow', () {
var result = collectBytes(Stream.fromIterable([
[0],
[1],
@@ -19,25 +19,25 @@
expect(result, completion([0, 1, 2, 0]));
});
- test("no events", () {
+ test('no events', () {
var result = collectBytes(Stream.fromIterable([]));
expect(result, completion([]));
});
- test("empty events", () {
+ test('empty events', () {
var result = collectBytes(Stream.fromIterable([[], []]));
expect(result, completion([]));
});
- test("error event", () {
+ test('error event', () {
var result = collectBytes(Stream.fromIterable(
- Iterable.generate(3, (n) => n == 2 ? throw "badness" : [n])));
- expect(result, throwsA("badness"));
+ Iterable.generate(3, (n) => n == 2 ? throw 'badness' : [n])));
+ expect(result, throwsA('badness'));
});
});
- group("collectBytes", () {
- test("simple list and overflow", () {
+ group('collectBytes', () {
+ test('simple list and overflow', () {
var result = collectBytesCancelable(Stream.fromIterable([
[0],
[1],
@@ -47,23 +47,23 @@
expect(result.value, completion([0, 1, 2, 0]));
});
- test("no events", () {
+ test('no events', () {
var result = collectBytesCancelable(Stream.fromIterable([]));
expect(result.value, completion([]));
});
- test("empty events", () {
+ test('empty events', () {
var result = collectBytesCancelable(Stream.fromIterable([[], []]));
expect(result.value, completion([]));
});
- test("error event", () {
+ test('error event', () {
var result = collectBytesCancelable(Stream.fromIterable(
- Iterable.generate(3, (n) => n == 2 ? throw "badness" : [n])));
- expect(result.value, throwsA("badness"));
+ Iterable.generate(3, (n) => n == 2 ? throw 'badness' : [n])));
+ expect(result.value, throwsA('badness'));
});
- test("cancelled", () async {
+ test('cancelled', () async {
var sc = StreamController<List<int>>();
var result = collectBytesCancelable(sc.stream);
// Value never completes.
diff --git a/test/cancelable_operation_test.dart b/test/cancelable_operation_test.dart
index a47e952..b38c0b9 100644
--- a/test/cancelable_operation_test.dart
+++ b/test/cancelable_operation_test.dart
@@ -10,100 +10,100 @@
import 'utils.dart';
void main() {
- group("without being canceled", () {
+ group('without being canceled', () {
CancelableCompleter completer;
setUp(() {
completer = CancelableCompleter(onCancel: expectAsync0(() {}, count: 0));
});
- test("sends values to the future", () {
+ test('sends values to the future', () {
expect(completer.operation.value, completion(equals(1)));
expect(completer.isCompleted, isFalse);
completer.complete(1);
expect(completer.isCompleted, isTrue);
});
- test("sends errors to the future", () {
- expect(completer.operation.value, throwsA("error"));
+ test('sends errors to the future', () {
+ expect(completer.operation.value, throwsA('error'));
expect(completer.isCompleted, isFalse);
- completer.completeError("error");
+ completer.completeError('error');
expect(completer.isCompleted, isTrue);
});
- test("sends values in a future to the future", () {
+ test('sends values in a future to the future', () {
expect(completer.operation.value, completion(equals(1)));
expect(completer.isCompleted, isFalse);
completer.complete(Future.value(1));
expect(completer.isCompleted, isTrue);
});
- test("sends errors in a future to the future", () {
- expect(completer.operation.value, throwsA("error"));
+ test('sends errors in a future to the future', () {
+ expect(completer.operation.value, throwsA('error'));
expect(completer.isCompleted, isFalse);
expect(completer.operation.isCompleted, isFalse);
- completer.complete(Future.error("error"));
+ completer.complete(Future.error('error'));
expect(completer.isCompleted, isTrue);
expect(completer.operation.isCompleted, isTrue);
});
- test("sends values to valueOrCancellation", () {
+ test('sends values to valueOrCancellation', () {
expect(completer.operation.valueOrCancellation(), completion(equals(1)));
completer.complete(1);
});
- test("sends errors to valueOrCancellation", () {
- expect(completer.operation.valueOrCancellation(), throwsA("error"));
- completer.completeError("error");
+ test('sends errors to valueOrCancellation', () {
+ expect(completer.operation.valueOrCancellation(), throwsA('error'));
+ completer.completeError('error');
});
- group("throws a StateError if completed", () {
- test("successfully twice", () {
+ group('throws a StateError if completed', () {
+ test('successfully twice', () {
completer.complete(1);
expect(() => completer.complete(1), throwsStateError);
});
- test("successfully then unsuccessfully", () {
+ test('successfully then unsuccessfully', () {
completer.complete(1);
- expect(() => completer.completeError("error"), throwsStateError);
+ expect(() => completer.completeError('error'), throwsStateError);
});
- test("unsuccessfully twice", () {
- expect(completer.operation.value, throwsA("error"));
- completer.completeError("error");
- expect(() => completer.completeError("error"), throwsStateError);
+ test('unsuccessfully twice', () {
+ expect(completer.operation.value, throwsA('error'));
+ completer.completeError('error');
+ expect(() => completer.completeError('error'), throwsStateError);
});
- test("successfully then with a future", () {
+ test('successfully then with a future', () {
completer.complete(1);
expect(() => completer.complete(Completer().future), throwsStateError);
});
- test("with a future then successfully", () {
+ test('with a future then successfully', () {
completer.complete(Completer().future);
expect(() => completer.complete(1), throwsStateError);
});
- test("with a future twice", () {
+ test('with a future twice', () {
completer.complete(Completer().future);
expect(() => completer.complete(Completer().future), throwsStateError);
});
});
- group("CancelableOperation.fromFuture", () {
- test("forwards values", () {
+ group('CancelableOperation.fromFuture', () {
+ test('forwards values', () {
var operation = CancelableOperation.fromFuture(Future.value(1));
expect(operation.value, completion(equals(1)));
});
- test("forwards errors", () {
- var operation = CancelableOperation.fromFuture(Future.error("error"));
- expect(operation.value, throwsA("error"));
+ test('forwards errors', () {
+ var operation = CancelableOperation.fromFuture(Future.error('error'));
+ expect(operation.value, throwsA('error'));
});
});
});
- group("when canceled", () {
- test("causes the future never to fire", () async {
+ group('when canceled', () {
+ test('causes the future never to fire', () async {
var completer = CancelableCompleter();
completer.operation.value.whenComplete(expectAsync0(() {}, count: 0));
completer.operation.cancel();
@@ -114,7 +114,7 @@
await flushMicrotasks();
});
- test("fires onCancel", () {
+ test('fires onCancel', () {
var canceled = false;
CancelableCompleter completer;
completer = CancelableCompleter(onCancel: expectAsync0(() {
@@ -135,7 +135,7 @@
expect(completer.operation.isCompleted, isFalse);
});
- test("returns the onCancel future each time cancel is called", () {
+ test('returns the onCancel future each time cancel is called', () {
var completer = CancelableCompleter(onCancel: expectAsync0(() {
return Future.value(1);
}));
@@ -158,8 +158,8 @@
});
test(
- "does call onCancel if the completer has completed to an unfired "
- "Future", () {
+ 'does call onCancel if the completer has completed to an unfired '
+ 'Future', () {
var completer = CancelableCompleter(onCancel: expectAsync0(() {}));
completer.complete(Completer().future);
expect(completer.operation.cancel(), completes);
@@ -167,7 +167,7 @@
test(
"doesn't call onCancel if the completer has completed to a fired "
- "Future", () async {
+ 'Future', () async {
var completer =
CancelableCompleter(onCancel: expectAsync0(() {}, count: 0));
completer.complete(Future.value(1));
@@ -175,7 +175,7 @@
expect(completer.operation.cancel(), completes);
});
- test("can be completed once after being canceled", () async {
+ test('can be completed once after being canceled', () async {
var completer = CancelableCompleter();
completer.operation.value.whenComplete(expectAsync0(() {}, count: 0));
await completer.operation.cancel();
@@ -183,21 +183,21 @@
expect(() => completer.complete(1), throwsStateError);
});
- test("fires valueOrCancellation with the given value", () {
+ test('fires valueOrCancellation with the given value', () {
var completer = CancelableCompleter();
expect(completer.operation.valueOrCancellation(1), completion(equals(1)));
completer.operation.cancel();
});
- test("pipes an error through valueOrCancellation", () {
+ test('pipes an error through valueOrCancellation', () {
var completer = CancelableCompleter(onCancel: () {
- throw "error";
+ throw 'error';
});
- expect(completer.operation.valueOrCancellation(1), throwsA("error"));
+ expect(completer.operation.valueOrCancellation(1), throwsA('error'));
completer.operation.cancel();
});
- test("valueOrCancellation waits on the onCancel future", () async {
+ test('valueOrCancellation waits on the onCancel future', () async {
var innerCompleter = Completer();
var completer =
CancelableCompleter(onCancel: () => innerCompleter.future);
@@ -217,22 +217,22 @@
});
});
- group("asStream()", () {
- test("emits a value and then closes", () {
+ group('asStream()', () {
+ test('emits a value and then closes', () {
var completer = CancelableCompleter();
expect(completer.operation.asStream().toList(), completion(equals([1])));
completer.complete(1);
});
- test("emits an error and then closes", () {
+ test('emits an error and then closes', () {
var completer = CancelableCompleter();
var queue = StreamQueue(completer.operation.asStream());
- expect(queue.next, throwsA("error"));
+ expect(queue.next, throwsA('error'));
expect(queue.hasNext, completion(isFalse));
- completer.completeError("error");
+ completer.completeError('error');
});
- test("cancels the completer when the subscription is canceled", () {
+ test('cancels the completer when the subscription is canceled', () {
var completer = CancelableCompleter(onCancel: expectAsync0(() {}));
var sub =
completer.operation.asStream().listen(expectAsync1((_) {}, count: 0));
@@ -242,7 +242,7 @@
});
});
- group("then", () {
+ group('then', () {
FutureOr<String> Function(int) onValue;
FutureOr<String> Function(Object, StackTrace) onError;
FutureOr<String> Function() onCancel;
@@ -251,9 +251,9 @@
setUp(() {
// Initialize all functions to ones that expect to not be called.
- onValue = expectAsync1((_) => null, count: 0, id: "onValue");
- onError = expectAsync2((e, s) => null, count: 0, id: "onError");
- onCancel = expectAsync0(() => null, count: 0, id: "onCancel");
+ onValue = expectAsync1((_) => null, count: 0, id: 'onValue');
+ onError = expectAsync2((e, s) => null, count: 0, id: 'onError');
+ onCancel = expectAsync0(() => null, count: 0, id: 'onCancel');
propagateCancel = false;
});
@@ -265,31 +265,31 @@
propagateCancel: propagateCancel);
}
- group("original operation completes successfully", () {
- test("onValue completes successfully", () {
- onValue = expectAsync1((v) => v.toString(), count: 1, id: "onValue");
+ group('original operation completes successfully', () {
+ test('onValue completes successfully', () {
+ onValue = expectAsync1((v) => v.toString(), count: 1, id: 'onValue');
- expect(runThen().value, completion("1"));
+ expect(runThen().value, completion('1'));
originalCompleter.complete(1);
});
- test("onValue throws error", () {
+ test('onValue throws error', () {
// expectAsync1 only works with functions that do not throw.
- onValue = (_) => throw "error";
+ onValue = (_) => throw 'error';
- expect(runThen().value, throwsA("error"));
+ expect(runThen().value, throwsA('error'));
originalCompleter.complete(1);
});
- test("onValue returns Future that throws error", () {
+ test('onValue returns Future that throws error', () {
onValue =
- expectAsync1((v) => Future.error("error"), count: 1, id: "onValue");
+ expectAsync1((v) => Future.error('error'), count: 1, id: 'onValue');
- expect(runThen().value, throwsA("error"));
+ expect(runThen().value, throwsA('error'));
originalCompleter.complete(1);
});
- test("and returned operation is canceled with propagateCancel = false",
+ test('and returned operation is canceled with propagateCancel = false',
() async {
propagateCancel = false;
@@ -300,51 +300,51 @@
});
});
- group("original operation completes with error", () {
- test("onError not set", () {
+ group('original operation completes with error', () {
+ test('onError not set', () {
onError = null;
- expect(runThen().value, throwsA("error"));
- originalCompleter.completeError("error");
+ expect(runThen().value, throwsA('error'));
+ originalCompleter.completeError('error');
});
- test("onError completes successfully", () {
- onError = expectAsync2((e, s) => "onError caught $e",
- count: 1, id: "onError");
+ test('onError completes successfully', () {
+ onError = expectAsync2((e, s) => 'onError caught $e',
+ count: 1, id: 'onError');
- expect(runThen().value, completion("onError caught error"));
- originalCompleter.completeError("error");
+ expect(runThen().value, completion('onError caught error'));
+ originalCompleter.completeError('error');
});
- test("onError throws", () {
+ test('onError throws', () {
// expectAsync2 does not work with functions that throw.
- onError = (e, s) => throw "onError caught $e";
+ onError = (e, s) => throw 'onError caught $e';
- expect(runThen().value, throwsA("onError caught error"));
- originalCompleter.completeError("error");
+ expect(runThen().value, throwsA('onError caught error'));
+ originalCompleter.completeError('error');
});
- test("onError returns Future that throws", () {
- onError = expectAsync2((e, s) => Future.error("onError caught $e"),
- count: 1, id: "onError");
+ test('onError returns Future that throws', () {
+ onError = expectAsync2((e, s) => Future.error('onError caught $e'),
+ count: 1, id: 'onError');
- expect(runThen().value, throwsA("onError caught error"));
- originalCompleter.completeError("error");
+ expect(runThen().value, throwsA('onError caught error'));
+ originalCompleter.completeError('error');
});
- test("and returned operation is canceled with propagateCancel = false",
+ test('and returned operation is canceled with propagateCancel = false',
() async {
propagateCancel = false;
runThen().cancel();
// onError should not be called.
- originalCompleter.completeError("error");
+ originalCompleter.completeError('error');
});
});
- group("original operation canceled", () {
- test("onCancel not set", () {
+ group('original operation canceled', () {
+ test('onCancel not set', () {
onCancel = null;
final operation = runThen();
@@ -353,32 +353,32 @@
expect(operation.isCanceled, true);
});
- test("onCancel completes successfully", () {
- onCancel = expectAsync0(() => "canceled", count: 1, id: "onCancel");
+ test('onCancel completes successfully', () {
+ onCancel = expectAsync0(() => 'canceled', count: 1, id: 'onCancel');
- expect(runThen().value, completion("canceled"));
+ expect(runThen().value, completion('canceled'));
originalCompleter.operation.cancel();
});
- test("onCancel throws error", () {
+ test('onCancel throws error', () {
// expectAsync0 only works with functions that do not throw.
- onCancel = () => throw "error";
+ onCancel = () => throw 'error';
- expect(runThen().value, throwsA("error"));
+ expect(runThen().value, throwsA('error'));
originalCompleter.operation.cancel();
});
- test("onCancel returns Future that throws error", () {
+ test('onCancel returns Future that throws error', () {
onCancel =
- expectAsync0(() => Future.error("error"), count: 1, id: "onCancel");
+ expectAsync0(() => Future.error('error'), count: 1, id: 'onCancel');
- expect(runThen().value, throwsA("error"));
+ expect(runThen().value, throwsA('error'));
originalCompleter.operation.cancel();
});
});
- group("returned operation canceled", () {
- test("propagateCancel is true", () async {
+ group('returned operation canceled', () {
+ test('propagateCancel is true', () async {
propagateCancel = true;
await runThen().cancel();
@@ -386,7 +386,7 @@
expect(originalCompleter.isCanceled, true);
});
- test("propagateCancel is false", () async {
+ test('propagateCancel is false', () async {
propagateCancel = false;
await runThen().cancel();
diff --git a/test/future_group_test.dart b/test/future_group_test.dart
index 770a465..f99d06d 100644
--- a/test/future_group_test.dart
+++ b/test/future_group_test.dart
@@ -15,8 +15,8 @@
futureGroup = FutureGroup();
});
- group("with no futures", () {
- test("never completes if nothing happens", () async {
+ group('with no futures', () {
+ test('never completes if nothing happens', () async {
var completed = false;
futureGroup.future.then((_) => completed = true);
@@ -30,8 +30,8 @@
});
});
- group("with a future that already completed", () {
- test("never completes if nothing happens", () async {
+ group('with a future that already completed', () {
+ test('never completes if nothing happens', () async {
futureGroup.add(Future.value());
await flushMicrotasks();
@@ -57,12 +57,12 @@
});
test("completes to that future's error, even if it's not closed", () {
- futureGroup.add(Future.error("error"));
- expect(futureGroup.future, throwsA("error"));
+ futureGroup.add(Future.error('error'));
+ expect(futureGroup.future, throwsA('error'));
});
});
- test("completes once all contained futures complete", () async {
+ test('completes once all contained futures complete', () async {
var completer1 = Completer();
var completer2 = Completer();
var completer3 = Completer();
@@ -88,7 +88,7 @@
expect(completed, isTrue);
});
- test("completes to the values of the futures in order of addition", () {
+ test('completes to the values of the futures in order of addition', () {
var completer1 = Completer();
var completer2 = Completer();
var completer3 = Completer();
@@ -116,13 +116,13 @@
futureGroup.add(completer2.future);
futureGroup.add(completer3.future);
- completer2.completeError("error 2");
- completer1.completeError("error 1");
- expect(futureGroup.future, throwsA("error 2"));
+ completer2.completeError('error 2');
+ completer1.completeError('error 1');
+ expect(futureGroup.future, throwsA('error 2'));
});
- group("onIdle:", () {
- test("emits an event when the last pending future completes", () async {
+ group('onIdle:', () {
+ test('emits an event when the last pending future completes', () async {
var idle = false;
futureGroup.onIdle.listen((_) => idle = true);
@@ -154,7 +154,7 @@
expect(futureGroup.isIdle, isTrue);
});
- test("emits an event each time it becomes idle", () async {
+ test('emits an event each time it becomes idle', () async {
var idle = false;
futureGroup.onIdle.listen((_) => idle = true);
@@ -180,7 +180,7 @@
expect(futureGroup.isIdle, isTrue);
});
- test("emits an event when the group closes", () async {
+ test('emits an event when the group closes', () async {
// It's important that the order of events here stays consistent over
// time, since code may rely on it in subtle ways.
var idle = false;
diff --git a/test/lazy_stream_test.dart b/test/lazy_stream_test.dart
index db1bc94..2affe5b 100644
--- a/test/lazy_stream_test.dart
+++ b/test/lazy_stream_test.dart
@@ -2,19 +2,19 @@
// for details. 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 'dart:async';
-import "package:async/async.dart";
-import "package:test/test.dart";
+import 'package:async/async.dart';
+import 'package:test/test.dart';
-import "utils.dart";
+import 'utils.dart';
-main() {
- test("disallows a null callback", () {
+void main() {
+ test('disallows a null callback', () {
expect(() => LazyStream(null), throwsArgumentError);
});
- test("calls the callback when the stream is listened", () async {
+ test('calls the callback when the stream is listened', () async {
var callbackCalled = false;
var stream = LazyStream(expectAsync0(() {
callbackCalled = true;
@@ -28,7 +28,7 @@
expect(callbackCalled, isTrue);
});
- test("calls the callback when the stream is listened", () async {
+ test('calls the callback when the stream is listened', () async {
var callbackCalled = false;
var stream = LazyStream(expectAsync0(() {
callbackCalled = true;
@@ -42,7 +42,7 @@
expect(callbackCalled, isTrue);
});
- test("forwards to a synchronously-provided stream", () async {
+ test('forwards to a synchronously-provided stream', () async {
var controller = StreamController<int>();
var stream = LazyStream(expectAsync0(() => controller.stream));
@@ -64,7 +64,7 @@
controller.close();
});
- test("forwards to an asynchronously-provided stream", () async {
+ test('forwards to an asynchronously-provided stream', () async {
var controller = StreamController<int>();
var stream = LazyStream(expectAsync0(() async => controller.stream));
diff --git a/test/null_stream_sink_test.dart b/test/null_stream_sink_test.dart
index 33e2655..649cbad 100644
--- a/test/null_stream_sink_test.dart
+++ b/test/null_stream_sink_test.dart
@@ -2,21 +2,21 @@
// for details. 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 'dart:async';
-import "package:async/async.dart";
-import "package:test/test.dart";
+import 'package:async/async.dart';
+import 'package:test/test.dart';
-import "utils.dart";
+import 'utils.dart';
void main() {
- group("constructors", () {
- test("done defaults to a completed future", () {
+ group('constructors', () {
+ test('done defaults to a completed future', () {
var sink = NullStreamSink();
expect(sink.done, completes);
});
- test("a custom future may be passed to done", () async {
+ test('a custom future may be passed to done', () async {
var completer = Completer();
var sink = NullStreamSink(done: completer.future);
@@ -32,30 +32,30 @@
expect(doneFired, isTrue);
});
- test("NullStreamSink.error passes an error to done", () {
- var sink = NullStreamSink.error("oh no");
- expect(sink.done, throwsA("oh no"));
+ test('NullStreamSink.error passes an error to done', () {
+ var sink = NullStreamSink.error('oh no');
+ expect(sink.done, throwsA('oh no'));
});
});
- group("events", () {
- test("are silently dropped before close", () {
+ group('events', () {
+ test('are silently dropped before close', () {
var sink = NullStreamSink();
sink.add(1);
- sink.addError("oh no");
+ sink.addError('oh no');
});
- test("throw StateErrors after close", () {
+ test('throw StateErrors after close', () {
var sink = NullStreamSink();
expect(sink.close(), completes);
expect(() => sink.add(1), throwsStateError);
- expect(() => sink.addError("oh no"), throwsStateError);
+ expect(() => sink.addError('oh no'), throwsStateError);
expect(() => sink.addStream(Stream.empty()), throwsStateError);
});
- group("addStream", () {
- test("listens to the stream then cancels immediately", () async {
+ group('addStream', () {
+ test('listens to the stream then cancels immediately', () async {
var sink = NullStreamSink();
var canceled = false;
var controller = StreamController(onCancel: () {
@@ -67,7 +67,7 @@
expect(canceled, isTrue);
});
- test("returns the cancel future", () async {
+ test('returns the cancel future', () async {
var completer = Completer();
var sink = NullStreamSink();
var controller = StreamController(onCancel: () => completer.future);
@@ -84,30 +84,30 @@
expect(addStreamFired, isTrue);
});
- test("pipes errors from the cancel future through addStream", () async {
+ test('pipes errors from the cancel future through addStream', () async {
var sink = NullStreamSink();
- var controller = StreamController(onCancel: () => throw "oh no");
- expect(sink.addStream(controller.stream), throwsA("oh no"));
+ var controller = StreamController(onCancel: () => throw 'oh no');
+ expect(sink.addStream(controller.stream), throwsA('oh no'));
});
- test("causes events to throw StateErrors until the future completes",
+ test('causes events to throw StateErrors until the future completes',
() async {
var sink = NullStreamSink();
var future = sink.addStream(Stream.empty());
expect(() => sink.add(1), throwsStateError);
- expect(() => sink.addError("oh no"), throwsStateError);
+ expect(() => sink.addError('oh no'), throwsStateError);
expect(() => sink.addStream(Stream.empty()), throwsStateError);
await future;
sink.add(1);
- sink.addError("oh no");
+ sink.addError('oh no');
expect(sink.addStream(Stream.empty()), completes);
});
});
});
- test("close returns the done future", () {
- var sink = NullStreamSink.error("oh no");
- expect(sink.close(), throwsA("oh no"));
+ test('close returns the done future', () {
+ var sink = NullStreamSink.error('oh no');
+ expect(sink.close(), throwsA('oh no'));
});
}
diff --git a/test/restartable_timer_test.dart b/test/restartable_timer_test.dart
index c46c87b..41f52ab 100644
--- a/test/restartable_timer_test.dart
+++ b/test/restartable_timer_test.dart
@@ -6,8 +6,8 @@
import 'package:fake_async/fake_async.dart';
import 'package:test/test.dart';
-main() {
- test("runs the callback once the duration has elapsed", () {
+void main() {
+ test('runs the callback once the duration has elapsed', () {
FakeAsync().run((async) {
var fired = false;
RestartableTimer(Duration(seconds: 5), () {
@@ -38,7 +38,7 @@
});
});
- test("resets the duration if the timer is reset before it fires", () {
+ test('resets the duration if the timer is reset before it fires', () {
FakeAsync().run((async) {
var fired = false;
var timer = RestartableTimer(Duration(seconds: 5), () {
@@ -57,7 +57,7 @@
});
});
- test("re-runs the callback if the timer is reset after firing", () {
+ test('re-runs the callback if the timer is reset after firing', () {
FakeAsync().run((async) {
var fired = 0;
var timer = RestartableTimer(Duration(seconds: 5), () {
@@ -77,7 +77,7 @@
});
});
- test("runs the callback if the timer is reset after being canceled", () {
+ test('runs the callback if the timer is reset after being canceled', () {
FakeAsync().run((async) {
var fired = false;
var timer = RestartableTimer(Duration(seconds: 5), () {
diff --git a/test/result/result_captureAll_test.dart b/test/result/result_captureAll_test.dart
index c7b688f..ba8305a 100644
--- a/test/result/result_captureAll_test.dart
+++ b/test/result/result_captureAll_test.dart
@@ -2,62 +2,64 @@
// for details. 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 "dart:math" show Random;
-import "package:async/async.dart";
-import "package:test/test.dart";
+import 'dart:async';
+import 'dart:math' show Random;
+
+import 'package:async/async.dart';
+import 'package:test/test.dart';
final someStack = StackTrace.current;
Result<int> res(int n) => Result<int>.value(n);
-Result err(n) => ErrorResult("$n", someStack);
+Result err(n) => ErrorResult('$n', someStack);
/// Helper function creating an iterable of futures.
-Iterable<Future<int>> futures(int count, {bool throwWhen(int index)}) sync* {
- for (int i = 0; i < count; i++) {
+Iterable<Future<int>> futures(int count,
+ {bool Function(int index) throwWhen}) sync* {
+ for (var i = 0; i < count; i++) {
if (throwWhen != null && throwWhen(i)) {
- yield Future<int>.error("$i", someStack);
+ yield Future<int>.error('$i', someStack);
} else {
yield Future<int>.value(i);
}
}
}
-main() {
- test("empty", () async {
+void main() {
+ test('empty', () async {
var all = await Result.captureAll<int>(futures(0));
expect(all, []);
});
- group("futures only,", () {
- test("single", () async {
+ group('futures only,', () {
+ test('single', () async {
var all = await Result.captureAll<int>(futures(1));
expect(all, [res(0)]);
});
- test("multiple", () async {
+ test('multiple', () async {
var all = await Result.captureAll<int>(futures(3));
expect(all, [res(0), res(1), res(2)]);
});
- test("error only", () async {
+ test('error only', () async {
var all =
await Result.captureAll<int>(futures(1, throwWhen: (_) => true));
expect(all, [err(0)]);
});
- test("multiple error only", () async {
+ test('multiple error only', () async {
var all =
await Result.captureAll<int>(futures(3, throwWhen: (_) => true));
expect(all, [err(0), err(1), err(2)]);
});
- test("mixed error and value", () async {
+ test('mixed error and value', () async {
var all =
await Result.captureAll<int>(futures(4, throwWhen: (x) => x.isOdd));
expect(all, [res(0), err(1), res(2), err(3)]);
});
- test("completion permutation 1-2-3", () async {
+ test('completion permutation 1-2-3', () async {
var cs = List.generate(3, (_) => Completer<int>());
var all = Result.captureAll<int>(cs.map((c) => c.future));
expect(all, completion([res(1), res(2), err(3)]));
@@ -66,22 +68,22 @@
await 0;
cs[1].complete(2);
await 0;
- cs[2].completeError("3", someStack);
+ cs[2].completeError('3', someStack);
});
- test("completion permutation 1-3-2", () async {
+ test('completion permutation 1-3-2', () async {
var cs = List.generate(3, (_) => Completer<int>());
var all = Result.captureAll<int>(cs.map((c) => c.future));
expect(all, completion([res(1), res(2), err(3)]));
await 0;
cs[0].complete(1);
await 0;
- cs[2].completeError("3", someStack);
+ cs[2].completeError('3', someStack);
await 0;
cs[1].complete(2);
});
- test("completion permutation 2-1-3", () async {
+ test('completion permutation 2-1-3', () async {
var cs = List.generate(3, (_) => Completer<int>());
var all = Result.captureAll<int>(cs.map((c) => c.future));
expect(all, completion([res(1), res(2), err(3)]));
@@ -90,39 +92,39 @@
await 0;
cs[0].complete(1);
await 0;
- cs[2].completeError("3", someStack);
+ cs[2].completeError('3', someStack);
});
- test("completion permutation 2-3-1", () async {
+ test('completion permutation 2-3-1', () async {
var cs = List.generate(3, (_) => Completer<int>());
var all = Result.captureAll<int>(cs.map((c) => c.future));
expect(all, completion([res(1), res(2), err(3)]));
await 0;
cs[1].complete(2);
await 0;
- cs[2].completeError("3", someStack);
+ cs[2].completeError('3', someStack);
await 0;
cs[0].complete(1);
});
- test("completion permutation 3-1-2", () async {
+ test('completion permutation 3-1-2', () async {
var cs = List.generate(3, (_) => Completer<int>());
var all = Result.captureAll<int>(cs.map((c) => c.future));
expect(all, completion([res(1), res(2), err(3)]));
await 0;
- cs[2].completeError("3", someStack);
+ cs[2].completeError('3', someStack);
await 0;
cs[0].complete(1);
await 0;
cs[1].complete(2);
});
- test("completion permutation 3-2-1", () async {
+ test('completion permutation 3-2-1', () async {
var cs = List.generate(3, (_) => Completer<int>());
var all = Result.captureAll<int>(cs.map((c) => c.future));
expect(all, completion([res(1), res(2), err(3)]));
await 0;
- cs[2].completeError("3", someStack);
+ cs[2].completeError('3', someStack);
await 0;
cs[1].complete(2);
await 0;
@@ -130,8 +132,8 @@
});
var seed = Random().nextInt(0x100000000);
- int n = 25; // max 32, otherwise rnd.nextInt(1<<n) won't work.
- test("randomized #$n seed:${seed.toRadixString(16)}", () async {
+ var n = 25; // max 32, otherwise rnd.nextInt(1<<n) won't work.
+ test('randomized #$n seed:${seed.toRadixString(16)}', () async {
var cs = List.generate(n, (_) => Completer<int>());
var all = Result.captureAll<int>(cs.map((c) => c.future));
var rnd = Random(seed);
@@ -144,27 +146,27 @@
var completeFunctions = List<Function()>.generate(n, (i) {
var c = cs[i];
return () =>
- throws(i) ? c.completeError("$i", someStack) : c.complete(i);
+ throws(i) ? c.completeError('$i', someStack) : c.complete(i);
});
completeFunctions.shuffle(rnd);
- for (int i = 0; i < n; i++) {
+ for (var i = 0; i < n; i++) {
await 0;
completeFunctions[i]();
}
});
});
- group("values only,", () {
- test("single", () async {
+ group('values only,', () {
+ test('single', () async {
var all = await Result.captureAll<int>(<int>[1]);
expect(all, [res(1)]);
});
- test("multiple", () async {
+ test('multiple', () async {
var all = await Result.captureAll<int>(<int>[1, 2, 3]);
expect(all, [res(1), res(2), res(3)]);
});
});
- group("mixed futures and values,", () {
- test("no error", () async {
+ group('mixed futures and values,', () {
+ test('no error', () async {
var all = await Result.captureAll<int>(<FutureOr<int>>[
1,
Future<int>(() => 2),
@@ -173,12 +175,12 @@
]);
expect(all, [res(1), res(2), res(3), res(4)]);
});
- test("error", () async {
+ test('error', () async {
var all = await Result.captureAll<int>(<FutureOr<int>>[
1,
Future<int>(() => 2),
3,
- Future<int>(() async => await Future.error("4", someStack)),
+ Future<int>(() async => await Future.error('4', someStack)),
Future<int>.value(5)
]);
expect(all, [res(1), res(2), res(3), err(4), res(5)]);
diff --git a/test/result/result_flattenAll_test.dart b/test/result/result_flattenAll_test.dart
index 4a049eb..890b2d0 100644
--- a/test/result/result_flattenAll_test.dart
+++ b/test/result/result_flattenAll_test.dart
@@ -2,16 +2,17 @@
// for details. 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:async/async.dart";
-import "package:test/test.dart";
+import 'package:async/async.dart';
+import 'package:test/test.dart';
final someStack = StackTrace.current;
Result<T> res<T>(T n) => Result<T>.value(n);
-Result err(n) => ErrorResult("$n", someStack);
+Result err(n) => ErrorResult('$n', someStack);
/// Helper function creating an iterable of results.
-Iterable<Result<int>> results(int count, {bool throwWhen(int index)}) sync* {
- for (int i = 0; i < count; i++) {
+Iterable<Result<int>> results(int count,
+ {bool Function(int index) throwWhen}) sync* {
+ for (var i = 0; i < count; i++) {
if (throwWhen != null && throwWhen(i)) {
yield err(i);
} else {
@@ -20,8 +21,8 @@
}
}
-main() {
- expectAll(result, expectation) {
+void main() {
+ void expectAll(result, expectation) {
if (expectation.isError) {
expect(result, expectation);
} else {
@@ -30,24 +31,24 @@
}
}
- test("empty", () {
+ test('empty', () {
expectAll(Result.flattenAll<int>(results(0)), res([]));
});
- test("single value", () {
+ test('single value', () {
expectAll(Result.flattenAll<int>(results(1)), res([0]));
});
- test("single error", () {
+ test('single error', () {
expectAll(
Result.flattenAll<int>(results(1, throwWhen: (_) => true)), err(0));
});
- test("multiple values", () {
+ test('multiple values', () {
expectAll(Result.flattenAll<int>(results(5)), res([0, 1, 2, 3, 4]));
});
- test("multiple errors", () {
+ test('multiple errors', () {
expectAll(Result.flattenAll<int>(results(5, throwWhen: (x) => x.isOdd)),
err(1)); // First error is result.
});
- test("error last", () {
+ test('error last', () {
expectAll(
Result.flattenAll<int>(results(5, throwWhen: (x) => x == 4)), err(4));
});
diff --git a/test/result/result_test.dart b/test/result/result_test.dart
index a33c1ba..92fc6b0 100644
--- a/test/result/result_test.dart
+++ b/test/result/result_test.dart
@@ -2,83 +2,83 @@
// for details. 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 "dart:collection";
+import 'dart:async';
+import 'dart:collection';
-import "package:async/async.dart";
-import "package:stack_trace/stack_trace.dart";
-import "package:test/test.dart";
+import 'package:async/async.dart';
+import 'package:stack_trace/stack_trace.dart';
+import 'package:test/test.dart';
void main() {
var stack = Trace.current();
- test("create result value", () {
- Result<int> result = Result<int>.value(42);
+ test('create result value', () {
+ var result = Result<int>.value(42);
expect(result.isValue, isTrue);
expect(result.isError, isFalse);
ValueResult value = result.asValue;
expect(value.value, equals(42));
});
- test("create result value 2", () {
+ test('create result value 2', () {
Result<int> result = ValueResult<int>(42);
expect(result.isValue, isTrue);
expect(result.isError, isFalse);
- ValueResult<int> value = result.asValue;
+ var value = result.asValue;
expect(value.value, equals(42));
});
- test("create result error", () {
- Result<bool> result = Result<bool>.error("BAD", stack);
+ test('create result error', () {
+ var result = Result<bool>.error('BAD', stack);
expect(result.isValue, isFalse);
expect(result.isError, isTrue);
- ErrorResult error = result.asError;
- expect(error.error, equals("BAD"));
+ var error = result.asError;
+ expect(error.error, equals('BAD'));
expect(error.stackTrace, same(stack));
});
- test("create result error 2", () {
- Result<bool> result = ErrorResult("BAD", stack);
+ test('create result error 2', () {
+ var result = ErrorResult('BAD', stack);
expect(result.isValue, isFalse);
expect(result.isError, isTrue);
- ErrorResult error = result.asError;
- expect(error.error, equals("BAD"));
+ var error = result.asError;
+ expect(error.error, equals('BAD'));
expect(error.stackTrace, same(stack));
});
- test("create result error no stack", () {
- Result<bool> result = Result<bool>.error("BAD");
+ test('create result error no stack', () {
+ var result = Result<bool>.error('BAD');
expect(result.isValue, isFalse);
expect(result.isError, isTrue);
- ErrorResult error = result.asError;
- expect(error.error, equals("BAD"));
+ var error = result.asError;
+ expect(error.error, equals('BAD'));
expect(error.stackTrace, isNull);
});
- test("complete with value", () {
+ test('complete with value', () {
Result<int> result = ValueResult<int>(42);
var c = Completer<int>();
c.future.then(expectAsync1((int v) {
expect(v, equals(42));
}), onError: (e, s) {
- fail("Unexpected error");
+ fail('Unexpected error');
});
result.complete(c);
});
- test("complete with error", () {
- Result<bool> result = ErrorResult("BAD", stack);
+ test('complete with error', () {
+ Result<bool> result = ErrorResult('BAD', stack);
var c = Completer<bool>();
c.future.then((bool v) {
- fail("Unexpected value $v");
+ fail('Unexpected value $v');
}, onError: expectAsync2((e, s) {
- expect(e, equals("BAD"));
+ expect(e, equals('BAD'));
expect(s, same(stack));
}));
result.complete(c);
});
- test("add sink value", () {
+ test('add sink value', () {
var result = ValueResult<int>(42);
EventSink<int> sink = TestSink(onData: expectAsync1((v) {
expect(v, equals(42));
@@ -86,97 +86,95 @@
result.addTo(sink);
});
- test("add sink error", () {
- Result<bool> result = ErrorResult("BAD", stack);
+ test('add sink error', () {
+ Result<bool> result = ErrorResult('BAD', stack);
EventSink<bool> sink = TestSink(onError: expectAsync2((e, s) {
- expect(e, equals("BAD"));
+ expect(e, equals('BAD'));
expect(s, same(stack));
}));
result.addTo(sink);
});
- test("value as future", () {
+ test('value as future', () {
Result<int> result = ValueResult<int>(42);
result.asFuture.then(expectAsync1((int v) {
expect(v, equals(42));
}), onError: (e, s) {
- fail("Unexpected error");
+ fail('Unexpected error');
});
});
- test("error as future", () {
- Result<bool> result = ErrorResult("BAD", stack);
+ test('error as future', () {
+ Result<bool> result = ErrorResult('BAD', stack);
result.asFuture.then((bool v) {
- fail("Unexpected value $v");
+ fail('Unexpected value $v');
}, onError: expectAsync2((e, s) {
- expect(e, equals("BAD"));
+ expect(e, equals('BAD'));
expect(s, same(stack));
}));
});
- test("capture future value", () {
- Future<int> value = Future<int>.value(42);
+ test('capture future value', () {
+ var value = Future<int>.value(42);
Result.capture(value).then(expectAsync1((Result result) {
expect(result.isValue, isTrue);
expect(result.isError, isFalse);
- ValueResult value = result.asValue;
+ var value = result.asValue;
expect(value.value, equals(42));
}), onError: (e, s) {
- fail("Unexpected error: $e");
+ fail('Unexpected error: $e');
});
});
- test("capture future error", () {
- Future<bool> value = Future<bool>.error("BAD", stack);
+ test('capture future error', () {
+ var value = Future<bool>.error('BAD', stack);
Result.capture(value).then(expectAsync1((Result result) {
expect(result.isValue, isFalse);
expect(result.isError, isTrue);
- ErrorResult error = result.asError;
- expect(error.error, equals("BAD"));
+ var error = result.asError;
+ expect(error.error, equals('BAD'));
expect(error.stackTrace, same(stack));
}), onError: (e, s) {
- fail("Unexpected error: $e");
+ fail('Unexpected error: $e');
});
});
- test("release future value", () {
- Future<Result<int>> future =
- Future<Result<int>>.value(Result<int>.value(42));
+ test('release future value', () {
+ var future = Future<Result<int>>.value(Result<int>.value(42));
Result.release(future).then(expectAsync1((v) {
expect(v, equals(42));
}), onError: (e, s) {
- fail("Unexpected error: $e");
+ fail('Unexpected error: $e');
});
});
- test("release future error", () {
+ test('release future error', () {
// An error in the result is unwrapped and reified by release.
- Future<Result<bool>> future =
- Future<Result<bool>>.value(Result<bool>.error("BAD", stack));
+ var future = Future<Result<bool>>.value(Result<bool>.error('BAD', stack));
Result.release(future).then((v) {
- fail("Unexpected value: $v");
+ fail('Unexpected value: $v');
}, onError: expectAsync2((e, s) {
- expect(e, equals("BAD"));
+ expect(e, equals('BAD'));
expect(s, same(stack));
}));
});
- test("release future real error", () {
+ test('release future real error', () {
// An error in the error lane is passed through by release.
- Future<Result<bool>> future = Future<Result<bool>>.error("BAD", stack);
+ var future = Future<Result<bool>>.error('BAD', stack);
Result.release(future).then((v) {
- fail("Unexpected value: $v");
+ fail('Unexpected value: $v');
}, onError: expectAsync2((e, s) {
- expect(e, equals("BAD"));
+ expect(e, equals('BAD'));
expect(s, same(stack));
}));
});
- test("capture stream", () {
+ test('capture stream', () {
var c = StreamController<int>();
var stream = Result.captureStream(c.stream);
var expectedList = Queue.from(
- [Result.value(42), Result.error("BAD", stack), Result.value(37)]);
+ [Result.value(42), Result.error('BAD', stack), Result.value(37)]);
void listener(Result actual) {
expect(expectedList.isEmpty, isFalse);
expectResult(actual, expectedList.removeFirst());
@@ -185,21 +183,21 @@
stream.listen(expectAsync1(listener, count: 3),
onDone: expectAsync0(() {}), cancelOnError: true);
c.add(42);
- c.addError("BAD", stack);
+ c.addError('BAD', stack);
c.add(37);
c.close();
});
- test("release stream", () {
- StreamController<Result<int>> c = StreamController<Result<int>>();
- Stream<int> stream = Result.releaseStream(c.stream);
+ test('release stream', () {
+ var c = StreamController<Result<int>>();
+ var stream = Result.releaseStream(c.stream);
var events = [
Result<int>.value(42),
- Result<int>.error("BAD", stack),
+ Result<int>.error('BAD', stack),
Result<int>.value(37)
];
// Expect the data events, and an extra error event.
- var expectedList = Queue.from(events)..add(Result.error("BAD2", stack));
+ var expectedList = Queue.from(events)..add(Result.error('BAD2', stack));
void dataListener(int v) {
expect(expectedList.isEmpty, isFalse);
@@ -219,95 +217,93 @@
stream.listen(expectAsync1(dataListener, count: 2),
onError: expectAsync2(errorListener, count: 2),
onDone: expectAsync0(() {}));
- for (Result<int> result in events) {
+ for (var result in events) {
c.add(result); // Result value or error in data line.
}
- c.addError("BAD2", stack); // Error in error line.
+ c.addError('BAD2', stack); // Error in error line.
c.close();
});
- test("release stream cancel on error", () {
- StreamController<Result<int>> c = StreamController<Result<int>>();
- Stream<int> stream = Result.releaseStream(c.stream);
+ test('release stream cancel on error', () {
+ var c = StreamController<Result<int>>();
+ var stream = Result.releaseStream(c.stream);
stream.listen(expectAsync1((v) {
expect(v, equals(42));
}), onError: expectAsync2((e, s) {
- expect(e, equals("BAD"));
+ expect(e, equals('BAD'));
expect(s, same(stack));
}), onDone: () {
- fail("Unexpected done event");
+ fail('Unexpected done event');
}, cancelOnError: true);
c.add(Result.value(42));
- c.add(Result.error("BAD", stack));
+ c.add(Result.error('BAD', stack));
c.add(Result.value(37));
c.close();
});
- test("flatten error 1", () {
- Result<int> error = Result<int>.error("BAD", stack);
- Result<int> flattened =
- Result.flatten(Result<Result<int>>.error("BAD", stack));
+ test('flatten error 1', () {
+ var error = Result<int>.error('BAD', stack);
+ var flattened = Result.flatten(Result<Result<int>>.error('BAD', stack));
expectResult(flattened, error);
});
- test("flatten error 2", () {
- Result<int> error = Result<int>.error("BAD", stack);
- Result<Result<int>> result = Result<Result<int>>.value(error);
- Result<int> flattened = Result.flatten(result);
+ test('flatten error 2', () {
+ var error = Result<int>.error('BAD', stack);
+ var result = Result<Result<int>>.value(error);
+ var flattened = Result.flatten(result);
expectResult(flattened, error);
});
- test("flatten value", () {
- Result<Result<int>> result =
- Result<Result<int>>.value(Result<int>.value(42));
+ test('flatten value', () {
+ var result = Result<Result<int>>.value(Result<int>.value(42));
expectResult(Result.flatten(result), Result<int>.value(42));
});
- test("handle unary", () {
- ErrorResult result = Result.error("error", stack);
- bool called = false;
+ test('handle unary', () {
+ ErrorResult result = Result.error('error', stack);
+ var called = false;
result.handle((error) {
called = true;
- expect(error, "error");
+ expect(error, 'error');
});
expect(called, isTrue);
});
- test("handle binary", () {
- ErrorResult result = Result.error("error", stack);
- bool called = false;
+ test('handle binary', () {
+ ErrorResult result = Result.error('error', stack);
+ var called = false;
result.handle((error, stackTrace) {
called = true;
- expect(error, "error");
+ expect(error, 'error');
expect(stackTrace, same(stack));
});
expect(called, isTrue);
});
- test("handle unary and binary", () {
- ErrorResult result = Result.error("error", stack);
- bool called = false;
+ test('handle unary and binary', () {
+ ErrorResult result = Result.error('error', stack);
+ var called = false;
result.handle((error, [stackTrace]) {
called = true;
- expect(error, "error");
+ expect(error, 'error');
expect(stackTrace, same(stack));
});
expect(called, isTrue);
});
- test("handle neither unary nor binary", () {
- ErrorResult result = Result.error("error", stack);
- expect(() => result.handle(() => fail("unreachable")), throwsA(anything));
- expect(() => result.handle((a, b, c) => fail("unreachable")),
+ test('handle neither unary nor binary', () {
+ ErrorResult result = Result.error('error', stack);
+ expect(() => result.handle(() => fail('unreachable')), throwsA(anything));
+ expect(() => result.handle((a, b, c) => fail('unreachable')),
throwsA(anything));
- expect(() => result.handle((a, b, {c}) => fail("unreachable")),
+ expect(() => result.handle((a, b, {c}) => fail('unreachable')),
throwsA(anything));
- expect(() => result.handle((a, {b}) => fail("unreachable")),
+ expect(() => result.handle((a, {b}) => fail('unreachable')),
throwsA(anything));
- expect(() => result.handle(({a, b}) => fail("unreachable")),
+ expect(() => result.handle(({a, b}) => fail('unreachable')),
throwsA(anything));
expect(
- () => result.handle(({a}) => fail("unreachable")), throwsA(anything));
+ () => result.handle(({a}) => fail('unreachable')), throwsA(anything));
});
}
@@ -323,36 +319,39 @@
}
class TestSink<T> implements EventSink<T> {
- final Function onData;
- final Function onError;
- final Function onDone;
+ final void Function(T) onData;
+ final void Function(dynamic, StackTrace) onError;
+ final void Function() onDone;
TestSink(
- {void this.onData(T data) = _nullData,
- void this.onError(e, StackTrace s) = _nullError,
- void this.onDone() = _nullDone});
+ {this.onData = _nullData,
+ this.onError = _nullError,
+ this.onDone = _nullDone});
+ @override
void add(T value) {
onData(value);
}
+ @override
void addError(error, [StackTrace stack]) {
onError(error, stack);
}
+ @override
void close() {
onDone();
}
static void _nullData(value) {
- fail("Unexpected sink add: $value");
+ fail('Unexpected sink add: $value');
}
static void _nullError(e, StackTrace s) {
- fail("Unexpected sink addError: $e");
+ fail('Unexpected sink addError: $e');
}
static void _nullDone() {
- fail("Unepxected sink close");
+ fail('Unepxected sink close');
}
}
diff --git a/test/stream_completer_test.dart b/test/stream_completer_test.dart
index fb1f4a5..2cf6728 100644
--- a/test/stream_completer_test.dart
+++ b/test/stream_completer_test.dart
@@ -2,21 +2,21 @@
// for details. 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 'dart:async';
-import "package:async/async.dart" show StreamCompleter;
-import "package:test/test.dart";
+import 'package:async/async.dart' show StreamCompleter;
+import 'package:test/test.dart';
-import "utils.dart";
+import 'utils.dart';
-main() {
- test("a stream is linked before listening", () async {
+void main() {
+ test('a stream is linked before listening', () async {
var completer = StreamCompleter();
completer.setSourceStream(createStream());
expect(completer.stream.toList(), completion([1, 2, 3, 4]));
});
- test("listened to before a stream is linked", () async {
+ test('listened to before a stream is linked', () async {
var completer = StreamCompleter();
var done = completer.stream.toList();
await flushMicrotasks();
@@ -32,7 +32,7 @@
completer.setSourceStream(UnusableStream()); // Doesn't throw.
});
- test("listen and pause before linking stream", () async {
+ test('listen and pause before linking stream', () async {
var controller = StreamCompleter();
var events = [];
var subscription = controller.stream.listen(events.add);
@@ -55,7 +55,7 @@
expect(events, [1, 2, 3, 4]);
});
- test("pause more than once", () async {
+ test('pause more than once', () async {
var completer = StreamCompleter();
var events = [];
var subscription = completer.stream.listen(events.add);
@@ -64,7 +64,7 @@
subscription.pause();
subscription.pause();
completer.setSourceStream(createStream());
- for (int i = 0; i < 3; i++) {
+ for (var i = 0; i < 3; i++) {
await flushMicrotasks();
expect(events, []);
subscription.resume();
@@ -73,7 +73,7 @@
expect(events, [1, 2, 3, 4]);
});
- test("cancel new stream before source is done", () async {
+ test('cancel new stream before source is done', () async {
var completer = StreamCompleter();
var lastEvent = -1;
var controller = StreamController();
@@ -85,8 +85,8 @@
subscription.cancel();
}
},
- onError: unreachable("error"),
- onDone: unreachable("done"),
+ onError: unreachable('error'),
+ onDone: unreachable('done'),
cancelOnError: true);
completer.setSourceStream(controller.stream);
expect(controller.hasListener, isTrue);
@@ -105,20 +105,20 @@
expect(controller.hasListener, isFalse);
});
- test("complete with setEmpty before listening", () async {
+ test('complete with setEmpty before listening', () async {
var completer = StreamCompleter();
completer.setEmpty();
var done = Completer();
- completer.stream.listen(unreachable("data"),
- onError: unreachable("error"), onDone: done.complete);
+ completer.stream.listen(unreachable('data'),
+ onError: unreachable('error'), onDone: done.complete);
await done.future;
});
- test("complete with setEmpty after listening", () async {
+ test('complete with setEmpty after listening', () async {
var completer = StreamCompleter();
var done = Completer();
- completer.stream.listen(unreachable("data"),
- onError: unreachable("error"), onDone: done.complete);
+ completer.stream.listen(unreachable('data'),
+ onError: unreachable('error'), onDone: done.complete);
completer.setEmpty();
await done.future;
});
@@ -138,7 +138,7 @@
await subscription.asFuture();
});
- test("cancelOnError true when listening before linking stream", () async {
+ test('cancelOnError true when listening before linking stream', () async {
var completer = StreamCompleter();
Object lastEvent = -1;
var controller = StreamController();
@@ -146,9 +146,9 @@
expect(value, lessThan(3));
lastEvent = value;
}, onError: (value) {
- expect(value, "3");
+ expect(value, '3');
lastEvent = value;
- }, onDone: unreachable("done"), cancelOnError: true);
+ }, onDone: unreachable('done'), cancelOnError: true);
completer.setSourceStream(controller.stream);
expect(controller.hasListener, isTrue);
@@ -164,14 +164,14 @@
await flushMicrotasks();
expect(lastEvent, 2);
expect(controller.hasListener, isTrue);
- controller.addError("3");
+ controller.addError('3');
await flushMicrotasks();
- expect(lastEvent, "3");
+ expect(lastEvent, '3');
expect(controller.hasListener, isFalse);
});
- test("cancelOnError true when listening after linking stream", () async {
+ test('cancelOnError true when listening after linking stream', () async {
var completer = StreamCompleter();
Object lastEvent = -1;
var controller = StreamController();
@@ -183,9 +183,9 @@
expect(value, lessThan(3));
lastEvent = value;
}, onError: (value) {
- expect(value, "3");
+ expect(value, '3');
lastEvent = value;
- }, onDone: unreachable("done"), cancelOnError: true);
+ }, onDone: unreachable('done'), cancelOnError: true);
expect(controller.hasListener, isTrue);
@@ -197,13 +197,13 @@
await flushMicrotasks();
expect(lastEvent, 2);
expect(controller.hasListener, isTrue);
- controller.addError("3");
+ controller.addError('3');
await flushMicrotasks();
expect(controller.hasListener, isFalse);
});
- test("linking a stream after setSourceStream before listen", () async {
+ test('linking a stream after setSourceStream before listen', () async {
var completer = StreamCompleter();
completer.setSourceStream(createStream());
expect(() => completer.setSourceStream(createStream()), throwsStateError);
@@ -214,7 +214,7 @@
expect(() => completer.setEmpty(), throwsStateError);
});
- test("linking a stream after setSourceStream after listen", () async {
+ test('linking a stream after setSourceStream after listen', () async {
var completer = StreamCompleter();
var list = completer.stream.toList();
completer.setSourceStream(createStream());
@@ -226,7 +226,7 @@
expect(() => completer.setEmpty(), throwsStateError);
});
- test("linking a stream after setEmpty before listen", () async {
+ test('linking a stream after setEmpty before listen', () async {
var completer = StreamCompleter();
completer.setEmpty();
expect(() => completer.setSourceStream(createStream()), throwsStateError);
@@ -237,7 +237,7 @@
expect(() => completer.setEmpty(), throwsStateError);
});
- test("linking a stream after setEmpty() after listen", () async {
+ test('linking a stream after setEmpty() after listen', () async {
var completer = StreamCompleter();
var list = completer.stream.toList();
completer.setEmpty();
@@ -249,7 +249,7 @@
expect(() => completer.setEmpty(), throwsStateError);
});
- test("listening more than once after setting stream", () async {
+ test('listening more than once after setting stream', () async {
var completer = StreamCompleter();
completer.setSourceStream(createStream());
var list = completer.stream.toList();
@@ -258,19 +258,19 @@
expect(() => completer.stream.toList(), throwsStateError);
});
- test("listening more than once before setting stream", () async {
+ test('listening more than once before setting stream', () async {
var completer = StreamCompleter();
completer.stream.toList();
expect(() => completer.stream.toList(), throwsStateError);
});
- test("setting onData etc. before and after setting stream", () async {
+ test('setting onData etc. before and after setting stream', () async {
var completer = StreamCompleter();
var controller = StreamController();
var subscription = completer.stream.listen(null);
Object lastEvent = 0;
subscription.onData((value) => lastEvent = value);
- subscription.onError((value) => lastEvent = "$value");
+ subscription.onError((value) => lastEvent = '$value');
subscription.onDone(() => lastEvent = -1);
completer.setSourceStream(controller.stream);
await flushMicrotasks();
@@ -279,24 +279,24 @@
expect(lastEvent, 1);
controller.addError(2);
await flushMicrotasks();
- expect(lastEvent, "2");
+ expect(lastEvent, '2');
subscription.onData((value) => lastEvent = -value);
- subscription.onError((value) => lastEvent = "${-value}");
+ subscription.onError((value) => lastEvent = '${-value}');
controller.add(1);
await flushMicrotasks();
expect(lastEvent, -1);
controller.addError(2);
await flushMicrotasks();
- expect(lastEvent, "-2");
+ expect(lastEvent, '-2');
controller.close();
await flushMicrotasks();
expect(lastEvent, -1);
});
- test("pause w/ resume future accross setting stream", () async {
+ test('pause w/ resume future accross setting stream', () async {
var completer = StreamCompleter();
var resume = Completer();
- var subscription = completer.stream.listen(unreachable("data"));
+ var subscription = completer.stream.listen(unreachable('data'));
subscription.pause(resume.future);
await flushMicrotasks();
completer.setSourceStream(createStream());
@@ -308,43 +308,43 @@
expect(events, [1, 2, 3, 4]);
});
- test("asFuture with error accross setting stream", () async {
+ test('asFuture with error accross setting stream', () async {
var completer = StreamCompleter();
var controller = StreamController();
var subscription =
- completer.stream.listen(unreachable("data"), cancelOnError: false);
+ completer.stream.listen(unreachable('data'), cancelOnError: false);
var done = subscription.asFuture();
expect(controller.hasListener, isFalse);
completer.setSourceStream(controller.stream);
await flushMicrotasks();
expect(controller.hasListener, isTrue);
controller.addError(42);
- await done.then(unreachable("data"), onError: (error) {
+ await done.then(unreachable('data'), onError: (error) {
expect(error, 42);
});
expect(controller.hasListener, isFalse);
});
- group("setError()", () {
- test("produces a stream that emits a single error", () {
+ group('setError()', () {
+ test('produces a stream that emits a single error', () {
var completer = StreamCompleter();
- completer.stream.listen(unreachable("data"),
+ completer.stream.listen(unreachable('data'),
onError: expectAsync2((error, stackTrace) {
- expect(error, equals("oh no"));
+ expect(error, equals('oh no'));
}), onDone: expectAsync0(() {}));
- completer.setError("oh no");
+ completer.setError('oh no');
});
- test("produces a stream that emits a single error on a later listen",
+ test('produces a stream that emits a single error on a later listen',
() async {
var completer = StreamCompleter();
- completer.setError("oh no");
+ completer.setError('oh no');
await flushMicrotasks();
- completer.stream.listen(unreachable("data"),
+ completer.stream.listen(unreachable('data'),
onError: expectAsync2((error, stackTrace) {
- expect(error, equals("oh no"));
+ expect(error, equals('oh no'));
}), onDone: expectAsync0(() {}));
});
});
diff --git a/test/stream_group_test.dart b/test/stream_group_test.dart
index 799d998..690fbc1 100644
--- a/test/stream_group_test.dart
+++ b/test/stream_group_test.dart
@@ -7,22 +7,22 @@
import 'package:async/async.dart';
import 'package:test/test.dart';
-main() {
- group("single-subscription", () {
+void main() {
+ group('single-subscription', () {
StreamGroup<String> streamGroup;
setUp(() {
streamGroup = StreamGroup<String>();
});
- test("buffers events from multiple sources", () async {
+ test('buffers events from multiple sources', () async {
var controller1 = StreamController<String>();
streamGroup.add(controller1.stream);
- controller1.add("first");
+ controller1.add('first');
controller1.close();
var controller2 = StreamController<String>();
streamGroup.add(controller2.stream);
- controller2.add("second");
+ controller2.add('second');
controller2.close();
await flushMicrotasks();
@@ -30,18 +30,18 @@
expect(streamGroup.close(), completes);
expect(streamGroup.stream.toList(),
- completion(unorderedEquals(["first", "second"])));
+ completion(unorderedEquals(['first', 'second'])));
});
- test("buffers errors from multiple sources", () async {
+ test('buffers errors from multiple sources', () async {
var controller1 = StreamController<String>();
streamGroup.add(controller1.stream);
- controller1.addError("first");
+ controller1.addError('first');
controller1.close();
var controller2 = StreamController<String>();
streamGroup.add(controller2.stream);
- controller2.addError("second");
+ controller2.addError('second');
controller2.close();
await flushMicrotasks();
@@ -50,21 +50,21 @@
var transformed = streamGroup.stream.transform(
StreamTransformer<String, String>.fromHandlers(
- handleError: (error, _, sink) => sink.add("error: $error")));
+ handleError: (error, _, sink) => sink.add('error: $error')));
expect(transformed.toList(),
- completion(equals(["error: first", "error: second"])));
+ completion(equals(['error: first', 'error: second'])));
});
- test("buffers events and errors together", () async {
+ test('buffers events and errors together', () async {
var controller = StreamController<String>();
streamGroup.add(controller.stream);
- controller.add("first");
- controller.addError("second");
- controller.add("third");
- controller.addError("fourth");
- controller.addError("fifth");
- controller.add("sixth");
+ controller.add('first');
+ controller.addError('second');
+ controller.add('third');
+ controller.addError('fourth');
+ controller.addError('fifth');
+ controller.add('sixth');
controller.close();
await flushMicrotasks();
@@ -73,17 +73,17 @@
var transformed = streamGroup.stream.transform(
StreamTransformer<String, String>.fromHandlers(
- handleData: (data, sink) => sink.add("data: $data"),
- handleError: (error, _, sink) => sink.add("error: $error")));
+ handleData: (data, sink) => sink.add('data: $data'),
+ handleError: (error, _, sink) => sink.add('error: $error')));
expect(
transformed.toList(),
completion(equals([
- "data: first",
- "error: second",
- "data: third",
- "error: fourth",
- "error: fifth",
- "data: sixth"
+ 'data: first',
+ 'error: second',
+ 'data: third',
+ 'error: fourth',
+ 'error: fifth',
+ 'data: sixth'
])));
});
@@ -92,10 +92,10 @@
streamGroup.add(controller.stream);
expect(
- streamGroup.stream.toList(), completion(equals(["first", "second"])));
+ streamGroup.stream.toList(), completion(equals(['first', 'second'])));
- controller.add("first");
- controller.add("second");
+ controller.add('first');
+ controller.add('second');
controller.close();
expect(streamGroup.close(), completes);
@@ -105,8 +105,8 @@
var controller = StreamController<String>.broadcast();
streamGroup.add(controller.stream);
- controller.add("first");
- controller.add("second");
+ controller.add('first');
+ controller.add('second');
controller.close();
await flushMicrotasks();
@@ -115,7 +115,7 @@
expect(streamGroup.stream.toList(), completion(isEmpty));
});
- test("when paused, buffers events from a broadcast stream", () async {
+ test('when paused, buffers events from a broadcast stream', () async {
var controller = StreamController<String>.broadcast();
streamGroup.add(controller.stream);
@@ -123,8 +123,8 @@
var subscription = streamGroup.stream.listen(events.add);
subscription.pause();
- controller.add("first");
- controller.add("second");
+ controller.add('first');
+ controller.add('second');
controller.close();
await flushMicrotasks();
@@ -132,7 +132,7 @@
expect(streamGroup.close(), completes);
await flushMicrotasks();
- expect(events, equals(["first", "second"]));
+ expect(events, equals(['first', 'second']));
});
test("emits events from a broadcast stream once there's a listener", () {
@@ -140,26 +140,26 @@
streamGroup.add(controller.stream);
expect(
- streamGroup.stream.toList(), completion(equals(["first", "second"])));
+ streamGroup.stream.toList(), completion(equals(['first', 'second'])));
- controller.add("first");
- controller.add("second");
+ controller.add('first');
+ controller.add('second');
controller.close();
expect(streamGroup.close(), completes);
});
- test("forwards cancel errors", () async {
+ test('forwards cancel errors', () async {
var subscription = streamGroup.stream.listen(null);
- var controller = StreamController<String>(onCancel: () => throw "error");
+ var controller = StreamController<String>(onCancel: () => throw 'error');
streamGroup.add(controller.stream);
await flushMicrotasks();
- expect(subscription.cancel(), throwsA("error"));
+ expect(subscription.cancel(), throwsA('error'));
});
- test("forwards a cancel future", () async {
+ test('forwards a cancel future', () async {
var subscription = streamGroup.stream.listen(null);
var completer = Completer();
@@ -180,8 +180,8 @@
});
test(
- "add() while active pauses the stream if the group is paused, then "
- "resumes once the group resumes", () async {
+ 'add() while active pauses the stream if the group is paused, then '
+ 'resumes once the group resumes', () async {
var subscription = streamGroup.stream.listen(null);
await flushMicrotasks();
@@ -201,13 +201,13 @@
expect(paused, isFalse);
});
- group("add() while canceled", () {
+ group('add() while canceled', () {
setUp(() async {
streamGroup.stream.listen(null).cancel();
await flushMicrotasks();
});
- test("immediately listens to and cancels the stream", () async {
+ test('immediately listens to and cancels the stream', () async {
var listened = false;
var canceled = false;
var controller = StreamController<String>(onListen: () {
@@ -223,14 +223,14 @@
expect(canceled, isTrue);
});
- test("forwards cancel errors", () {
+ test('forwards cancel errors', () {
var controller =
- StreamController<String>(onCancel: () => throw "error");
+ StreamController<String>(onCancel: () => throw 'error');
- expect(streamGroup.add(controller.stream), throwsA("error"));
+ expect(streamGroup.add(controller.stream), throwsA('error'));
});
- test("forwards a cancel future", () async {
+ test('forwards a cancel future', () async {
var completer = Completer();
var controller =
StreamController<String>(onCancel: () => completer.future);
@@ -248,21 +248,21 @@
});
});
- group("broadcast", () {
+ group('broadcast', () {
StreamGroup<String> streamGroup;
setUp(() {
streamGroup = StreamGroup<String>.broadcast();
});
- test("buffers events from multiple sources", () async {
+ test('buffers events from multiple sources', () async {
var controller1 = StreamController<String>();
streamGroup.add(controller1.stream);
- controller1.add("first");
+ controller1.add('first');
controller1.close();
var controller2 = StreamController<String>();
streamGroup.add(controller2.stream);
- controller2.add("second");
+ controller2.add('second');
controller2.close();
await flushMicrotasks();
@@ -270,7 +270,7 @@
expect(streamGroup.close(), completes);
expect(
- streamGroup.stream.toList(), completion(equals(["first", "second"])));
+ streamGroup.stream.toList(), completion(equals(['first', 'second'])));
});
test("emits events from multiple sources once there's a listener", () {
@@ -281,10 +281,10 @@
streamGroup.add(controller2.stream);
expect(
- streamGroup.stream.toList(), completion(equals(["first", "second"])));
+ streamGroup.stream.toList(), completion(equals(['first', 'second'])));
- controller1.add("first");
- controller2.add("second");
+ controller1.add('first');
+ controller2.add('second');
controller1.close();
controller2.close();
@@ -299,8 +299,8 @@
streamGroup.stream.listen(null).cancel();
await flushMicrotasks();
- controller.add("first");
- controller.addError("second");
+ controller.add('first');
+ controller.addError('second');
controller.close();
await flushMicrotasks();
@@ -312,8 +312,8 @@
test("doesn't buffer events from a broadcast stream", () async {
var controller = StreamController<String>.broadcast();
streamGroup.add(controller.stream);
- controller.add("first");
- controller.addError("second");
+ controller.add('first');
+ controller.addError('second');
controller.close();
await flushMicrotasks();
@@ -327,16 +327,16 @@
streamGroup.add(controller.stream);
expect(
- streamGroup.stream.toList(), completion(equals(["first", "second"])));
+ streamGroup.stream.toList(), completion(equals(['first', 'second'])));
- controller.add("first");
- controller.add("second");
+ controller.add('first');
+ controller.add('second');
controller.close();
expect(streamGroup.close(), completes);
});
- test("cancels and re-listens broadcast streams", () async {
+ test('cancels and re-listens broadcast streams', () async {
var subscription = streamGroup.stream.listen(null);
var controller = StreamController<String>.broadcast();
@@ -354,7 +354,7 @@
expect(controller.hasListener, isTrue);
});
- test("never cancels single-subscription streams", () async {
+ test('never cancels single-subscription streams', () async {
var subscription = streamGroup.stream.listen(null);
var controller =
@@ -370,7 +370,7 @@
await flushMicrotasks();
});
- test("drops events from a single-subscription stream while dormant",
+ test('drops events from a single-subscription stream while dormant',
() async {
var events = [];
var subscription = streamGroup.stream.listen(events.add);
@@ -379,22 +379,22 @@
streamGroup.add(controller.stream);
await flushMicrotasks();
- controller.add("first");
+ controller.add('first');
await flushMicrotasks();
- expect(events, equals(["first"]));
+ expect(events, equals(['first']));
subscription.cancel();
- controller.add("second");
+ controller.add('second');
await flushMicrotasks();
- expect(events, equals(["first"]));
+ expect(events, equals(['first']));
streamGroup.stream.listen(events.add);
- controller.add("third");
+ controller.add('third');
await flushMicrotasks();
- expect(events, equals(["first", "third"]));
+ expect(events, equals(['first', 'third']));
});
- test("a single-subscription stream can be removed while dormant", () async {
+ test('a single-subscription stream can be removed while dormant', () async {
var controller = StreamController<String>();
streamGroup.add(controller.stream);
await flushMicrotasks();
@@ -407,61 +407,61 @@
await flushMicrotasks();
expect(streamGroup.stream.toList(), completion(isEmpty));
- controller.add("first");
+ controller.add('first');
expect(streamGroup.close(), completes);
});
});
- group("regardless of type", () {
- group("single-subscription", () {
+ group('regardless of type', () {
+ group('single-subscription', () {
regardlessOfType(() => StreamGroup<String>());
});
- group("broadcast", () {
+ group('broadcast', () {
regardlessOfType(() => StreamGroup<String>.broadcast());
});
});
- test("merge() emits events from all components streams", () async {
+ test('merge() emits events from all components streams', () async {
var controller1 = StreamController<String>();
var controller2 = StreamController<String>();
var merged = StreamGroup.merge([controller1.stream, controller2.stream]);
- controller1.add("first");
+ controller1.add('first');
controller1.close();
- controller2.add("second");
+ controller2.add('second');
controller2.close();
- expect(await merged.toList(), ["first", "second"]);
+ expect(await merged.toList(), ['first', 'second']);
});
- test("mergeBroadcast() emits events from all components streams", () async {
+ test('mergeBroadcast() emits events from all components streams', () async {
var controller1 = StreamController<String>();
var controller2 = StreamController<String>();
var merged =
StreamGroup.mergeBroadcast([controller1.stream, controller2.stream]);
- controller1.add("first");
+ controller1.add('first');
controller1.close();
- controller2.add("second");
+ controller2.add('second');
controller2.close();
expect(merged.isBroadcast, isTrue);
- expect(await merged.toList(), ["first", "second"]);
+ expect(await merged.toList(), ['first', 'second']);
});
}
-void regardlessOfType(StreamGroup<String> newStreamGroup()) {
+void regardlessOfType(StreamGroup<String> Function() newStreamGroup) {
StreamGroup<String> streamGroup;
setUp(() {
streamGroup = newStreamGroup();
});
- group("add()", () {
- group("while dormant", () {
+ group('add()', () {
+ group('while dormant', () {
test("doesn't listen to the stream until the group is listened to",
() async {
var controller = StreamController<String>();
@@ -475,7 +475,7 @@
expect(controller.hasListener, isTrue);
});
- test("is a no-op if the stream is already in the group", () {
+ test('is a no-op if the stream is already in the group', () {
var controller = StreamController<String>();
streamGroup.add(controller.stream);
streamGroup.add(controller.stream);
@@ -487,13 +487,13 @@
});
});
- group("while active", () {
+ group('while active', () {
setUp(() async {
streamGroup.stream.listen(null);
await flushMicrotasks();
});
- test("listens to the stream immediately", () async {
+ test('listens to the stream immediately', () async {
var controller = StreamController<String>();
expect(streamGroup.add(controller.stream), isNull);
@@ -501,7 +501,7 @@
expect(controller.hasListener, isTrue);
});
- test("is a no-op if the stream is already in the group", () async {
+ test('is a no-op if the stream is already in the group', () async {
var controller = StreamController<String>();
// If the stream were actually listened to more than once, future
@@ -513,28 +513,28 @@
});
});
- group("remove()", () {
- group("while dormant", () {
+ group('remove()', () {
+ group('while dormant', () {
test("stops emitting events for a stream that's removed", () async {
var controller = StreamController<String>();
streamGroup.add(controller.stream);
- expect(streamGroup.stream.toList(), completion(equals(["first"])));
+ expect(streamGroup.stream.toList(), completion(equals(['first'])));
- controller.add("first");
+ controller.add('first');
await flushMicrotasks();
- controller.add("second");
+ controller.add('second');
expect(streamGroup.remove(controller.stream), completion(null));
expect(streamGroup.close(), completes);
});
- test("is a no-op for an unknown stream", () {
+ test('is a no-op for an unknown stream', () {
var controller = StreamController<String>();
expect(streamGroup.remove(controller.stream), isNull);
});
- test("and closed closes the group when the last stream is removed",
+ test('and closed closes the group when the last stream is removed',
() async {
var controller1 = StreamController<String>();
var controller2 = StreamController<String>();
@@ -555,7 +555,7 @@
});
});
- group("while listening", () {
+ group('while listening', () {
test("doesn't emit events from a removed stream", () {
var controller = StreamController<String>();
streamGroup.add(controller.stream);
@@ -565,9 +565,9 @@
// removal. This is documented in [StreamGroup.remove].
expect(streamGroup.stream.toList(), completion(isEmpty));
- controller.add("first");
+ controller.add('first');
expect(streamGroup.remove(controller.stream), completion(null));
- controller.add("second");
+ controller.add('second');
expect(streamGroup.close(), completes);
});
@@ -585,18 +585,18 @@
expect(controller.hasListener, isFalse);
});
- test("forwards cancel errors", () async {
+ test('forwards cancel errors', () async {
var controller =
- StreamController<String>(onCancel: () => throw "error");
+ StreamController<String>(onCancel: () => throw 'error');
streamGroup.add(controller.stream);
streamGroup.stream.listen(null);
await flushMicrotasks();
- expect(streamGroup.remove(controller.stream), throwsA("error"));
+ expect(streamGroup.remove(controller.stream), throwsA('error'));
});
- test("forwards cancel futures", () async {
+ test('forwards cancel futures', () async {
var completer = Completer();
var controller =
StreamController<String>(onCancel: () => completer.future);
@@ -618,7 +618,7 @@
expect(fired, isTrue);
});
- test("is a no-op for an unknown stream", () async {
+ test('is a no-op for an unknown stream', () async {
var controller = StreamController<String>();
streamGroup.stream.listen(null);
await flushMicrotasks();
@@ -626,7 +626,7 @@
expect(streamGroup.remove(controller.stream), isNull);
});
- test("and closed closes the group when the last stream is removed",
+ test('and closed closes the group when the last stream is removed',
() async {
var done = false;
streamGroup.stream.listen(null, onDone: () => done = true);
@@ -652,15 +652,15 @@
});
});
- group("close()", () {
- group("while dormant", () {
- test("if there are no streams, closes the group", () {
+ group('close()', () {
+ group('while dormant', () {
+ test('if there are no streams, closes the group', () {
expect(streamGroup.close(), completes);
expect(streamGroup.stream.toList(), completion(isEmpty));
});
test(
- "if there are streams, closes the group once those streams close "
+ 'if there are streams, closes the group once those streams close '
"and there's a listener", () async {
var controller1 = StreamController<String>();
var controller2 = StreamController<String>();
@@ -677,13 +677,13 @@
});
});
- group("while active", () {
- test("if there are no streams, closes the group", () {
+ group('while active', () {
+ test('if there are no streams, closes the group', () {
expect(streamGroup.stream.toList(), completion(isEmpty));
expect(streamGroup.close(), completes);
});
- test("if there are streams, closes the group once those streams close",
+ test('if there are streams, closes the group once those streams close',
() async {
var done = false;
streamGroup.stream.listen(null, onDone: () => done = true);
@@ -710,7 +710,7 @@
});
});
- test("returns a Future that completes once all events are dispatched",
+ test('returns a Future that completes once all events are dispatched',
() async {
var events = [];
streamGroup.stream.listen(events.add);
@@ -722,16 +722,16 @@
// Add a bunch of events. Each of these will get dispatched in a
// separate microtask, so we can test that [close] only completes once
// all of them have dispatched.
- controller.add("one");
- controller.add("two");
- controller.add("three");
- controller.add("four");
- controller.add("five");
- controller.add("six");
+ controller.add('one');
+ controller.add('two');
+ controller.add('three');
+ controller.add('four');
+ controller.add('five');
+ controller.add('six');
controller.close();
await streamGroup.close();
- expect(events, equals(["one", "two", "three", "four", "five", "six"]));
+ expect(events, equals(['one', 'two', 'three', 'four', 'five', 'six']));
});
});
}
diff --git a/test/stream_queue_test.dart b/test/stream_queue_test.dart
index b2a8625..fa286a8 100644
--- a/test/stream_queue_test.dart
+++ b/test/stream_queue_test.dart
@@ -2,16 +2,16 @@
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE filevents.
-import "dart:async";
+import 'dart:async';
-import "package:async/async.dart";
-import "package:test/test.dart";
+import 'package:async/async.dart';
+import 'package:test/test.dart';
-import "utils.dart";
+import 'utils.dart';
-main() {
- group("source stream", () {
- test("is listened to on first request, paused between requests", () async {
+void main() {
+ group('source stream', () {
+ test('is listened to on first request, paused between requests', () async {
var controller = StreamController<int>();
var events = StreamQueue<int>(controller.stream);
await flushMicrotasks();
@@ -42,8 +42,8 @@
});
});
- group("eventsDispatched", () {
- test("increments after a next future completes", () async {
+ group('eventsDispatched', () {
+ test('increments after a next future completes', () async {
var events = StreamQueue<int>(createStream());
expect(events.eventsDispatched, equals(0));
@@ -60,13 +60,13 @@
expect(events.eventsDispatched, equals(2));
});
- test("increments multiple times for multi-value requests", () async {
+ test('increments multiple times for multi-value requests', () async {
var events = StreamQueue<int>(createStream());
await events.take(3);
expect(events.eventsDispatched, equals(3));
});
- test("increments multiple times for an accepted transaction", () async {
+ test('increments multiple times for an accepted transaction', () async {
var events = StreamQueue<int>(createStream());
await events.withTransaction((queue) async {
await queue.next;
@@ -83,8 +83,8 @@
});
});
- group("lookAhead operation", () {
- test("as simple list of events", () async {
+ group('lookAhead operation', () {
+ test('as simple list of events', () async {
var events = StreamQueue<int>(createStream());
expect(await events.lookAhead(4), [1, 2, 3, 4]);
expect(await events.next, 1);
@@ -94,7 +94,7 @@
await events.cancel();
});
- test("of 0 events", () async {
+ test('of 0 events', () async {
var events = StreamQueue<int>(createStream());
expect(events.lookAhead(0), completion([]));
expect(events.next, completion(1));
@@ -110,7 +110,7 @@
await events.cancel();
});
- test("with bad arguments throws", () async {
+ test('with bad arguments throws', () async {
var events = StreamQueue<int>(createStream());
expect(() => events.lookAhead(-1), throwsArgumentError);
expect(await events.next, 1); // Did not consume event.
@@ -119,13 +119,13 @@
await events.cancel();
});
- test("of too many arguments", () async {
+ test('of too many arguments', () async {
var events = StreamQueue<int>(createStream());
expect(await events.lookAhead(6), [1, 2, 3, 4]);
await events.cancel();
});
- test("too large later", () async {
+ test('too large later', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
@@ -133,25 +133,25 @@
await events.cancel();
});
- test("error", () async {
+ test('error', () async {
var events = StreamQueue<int>(createErrorStream());
- expect(events.lookAhead(4), throwsA("To err is divine!"));
- expect(events.take(4), throwsA("To err is divine!"));
+ expect(events.lookAhead(4), throwsA('To err is divine!'));
+ expect(events.take(4), throwsA('To err is divine!'));
expect(await events.next, 4);
await events.cancel();
});
});
- group("next operation", () {
- test("simple sequence of requests", () async {
+ group('next operation', () {
+ test('simple sequence of requests', () async {
var events = StreamQueue<int>(createStream());
- for (int i = 1; i <= 4; i++) {
+ for (var i = 1; i <= 4; i++) {
expect(await events.next, i);
}
expect(events.next, throwsStateError);
});
- test("multiple requests at the same time", () async {
+ test('multiple requests at the same time', () async {
var events = StreamQueue<int>(createStream());
var result = await Future.wait(
[events.next, events.next, events.next, events.next]);
@@ -159,18 +159,18 @@
await events.cancel();
});
- test("sequence of requests with error", () async {
+ test('sequence of requests with error', () async {
var events = StreamQueue<int>(createErrorStream());
expect(await events.next, 1);
expect(await events.next, 2);
- expect(events.next, throwsA("To err is divine!"));
+ expect(events.next, throwsA('To err is divine!'));
expect(await events.next, 4);
await events.cancel();
});
});
- group("skip operation", () {
- test("of two elements in the middle of sequence", () async {
+ group('skip operation', () {
+ test('of two elements in the middle of sequence', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.skip(2), 0);
@@ -178,7 +178,7 @@
await events.cancel();
});
- test("with negative/bad arguments throws", () async {
+ test('with negative/bad arguments throws', () async {
var events = StreamQueue<int>(createStream());
expect(() => events.skip(-1), throwsArgumentError);
// A non-int throws either a type error or an argument error,
@@ -189,7 +189,7 @@
await events.cancel();
});
- test("of 0 elements works", () async {
+ test('of 0 elements works', () async {
var events = StreamQueue<int>(createStream());
expect(events.skip(0), completion(0));
expect(events.next, completion(1));
@@ -205,13 +205,13 @@
await events.cancel();
});
- test("of too many events ends at stream start", () async {
+ test('of too many events ends at stream start', () async {
var events = StreamQueue<int>(createStream());
expect(await events.skip(6), 2);
await events.cancel();
});
- test("of too many events after some events", () async {
+ test('of too many events after some events', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
@@ -219,7 +219,7 @@
await events.cancel();
});
- test("of too many events ends at stream end", () async {
+ test('of too many events ends at stream end', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
@@ -229,20 +229,20 @@
await events.cancel();
});
- test("of events with error", () async {
+ test('of events with error', () async {
var events = StreamQueue<int>(createErrorStream());
- expect(events.skip(4), throwsA("To err is divine!"));
+ expect(events.skip(4), throwsA('To err is divine!'));
expect(await events.next, 4);
await events.cancel();
});
- test("of events with error, and skip again after", () async {
+ test('of events with error, and skip again after', () async {
var events = StreamQueue<int>(createErrorStream());
- expect(events.skip(4), throwsA("To err is divine!"));
+ expect(events.skip(4), throwsA('To err is divine!'));
expect(events.skip(2), completion(1));
await events.cancel();
});
- test("multiple skips at same time complete in order.", () async {
+ test('multiple skips at same time complete in order.', () async {
var events = StreamQueue<int>(createStream());
var skip1 = events.skip(1);
var skip2 = events.skip(0);
@@ -266,8 +266,8 @@
});
});
- group("take operation", () {
- test("as simple take of events", () async {
+ group('take operation', () {
+ test('as simple take of events', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.take(2), [2, 3]);
@@ -275,7 +275,7 @@
await events.cancel();
});
- test("of 0 events", () async {
+ test('of 0 events', () async {
var events = StreamQueue<int>(createStream());
expect(events.take(0), completion([]));
expect(events.next, completion(1));
@@ -291,7 +291,7 @@
await events.cancel();
});
- test("with bad arguments throws", () async {
+ test('with bad arguments throws', () async {
var events = StreamQueue<int>(createStream());
expect(() => events.take(-1), throwsArgumentError);
expect(await events.next, 1); // Did not consume event.
@@ -300,13 +300,13 @@
await events.cancel();
});
- test("of too many arguments", () async {
+ test('of too many arguments', () async {
var events = StreamQueue<int>(createStream());
expect(await events.take(6), [1, 2, 3, 4]);
await events.cancel();
});
- test("too large later", () async {
+ test('too large later', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
@@ -314,27 +314,27 @@
await events.cancel();
});
- test("error", () async {
+ test('error', () async {
var events = StreamQueue<int>(createErrorStream());
- expect(events.take(4), throwsA("To err is divine!"));
+ expect(events.take(4), throwsA('To err is divine!'));
expect(await events.next, 4);
await events.cancel();
});
});
- group("rest operation", () {
- test("after single next", () async {
+ group('rest operation', () {
+ test('after single next', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.rest.toList(), [2, 3, 4]);
});
- test("at start", () async {
+ test('at start', () async {
var events = StreamQueue<int>(createStream());
expect(await events.rest.toList(), [1, 2, 3, 4]);
});
- test("at end", () async {
+ test('at end', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
@@ -343,7 +343,7 @@
expect(await events.rest.toList(), isEmpty);
});
- test("after end", () async {
+ test('after end', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
@@ -353,13 +353,13 @@
expect(await events.rest.toList(), isEmpty);
});
- test("after receiving done requested before", () async {
+ test('after receiving done requested before', () async {
var events = StreamQueue<int>(createStream());
var next1 = events.next;
var next2 = events.next;
var next3 = events.next;
var rest = events.rest;
- for (int i = 0; i < 10; i++) {
+ for (var i = 0; i < 10; i++) {
await flushMicrotasks();
}
expect(await next1, 1);
@@ -368,17 +368,17 @@
expect(await rest.toList(), [4]);
});
- test("with an error event error", () async {
+ test('with an error event error', () async {
var events = StreamQueue<int>(createErrorStream());
expect(await events.next, 1);
var rest = events.rest;
var events2 = StreamQueue(rest);
expect(await events2.next, 2);
- expect(events2.next, throwsA("To err is divine!"));
+ expect(events2.next, throwsA('To err is divine!'));
expect(await events2.next, 4);
});
- test("closes the events, prevents other operations", () async {
+ test('closes the events, prevents other operations', () async {
var events = StreamQueue<int>(createStream());
var stream = events.rest;
expect(() => events.next, throwsStateError);
@@ -389,7 +389,7 @@
expect(stream.toList(), completion([1, 2, 3, 4]));
});
- test("forwards to underlying stream", () async {
+ test('forwards to underlying stream', () async {
var cancel = Completer();
var controller = StreamController<int>(onCancel: () => cancel.future);
var events = StreamQueue<int>(controller.stream);
@@ -436,8 +436,8 @@
});
});
- group("peek operation", () {
- test("peeks one event", () async {
+ group('peek operation', () {
+ test('peeks one event', () async {
var events = StreamQueue<int>(createStream());
expect(await events.peek, 1);
expect(await events.next, 1);
@@ -449,28 +449,28 @@
expect(events.peek, throwsA(anything));
await events.cancel();
});
- test("multiple requests at the same time", () async {
+ test('multiple requests at the same time', () async {
var events = StreamQueue<int>(createStream());
var result = await Future.wait(
[events.peek, events.peek, events.next, events.peek, events.peek]);
expect(result, [1, 1, 1, 2, 2]);
await events.cancel();
});
- test("sequence of requests with error", () async {
+ test('sequence of requests with error', () async {
var events = StreamQueue<int>(createErrorStream());
expect(await events.next, 1);
expect(await events.next, 2);
- expect(events.peek, throwsA("To err is divine!"));
+ expect(events.peek, throwsA('To err is divine!'));
// Error stays in queue.
- expect(events.peek, throwsA("To err is divine!"));
- expect(events.next, throwsA("To err is divine!"));
+ expect(events.peek, throwsA('To err is divine!'));
+ expect(events.next, throwsA('To err is divine!'));
expect(await events.next, 4);
await events.cancel();
});
});
- group("cancel operation", () {
- test("closes the events, prevents any other operation", () async {
+ group('cancel operation', () {
+ test('closes the events, prevents any other operation', () async {
var events = StreamQueue<int>(createStream());
await events.cancel();
expect(() => events.lookAhead(1), throwsStateError);
@@ -482,7 +482,7 @@
expect(() => events.cancel(), throwsStateError);
});
- test("cancels underlying subscription when called before any event",
+ test('cancels underlying subscription when called before any event',
() async {
var cancelFuture = Future.value(42);
var controller = StreamController<int>(onCancel: () => cancelFuture);
@@ -490,7 +490,7 @@
expect(await events.cancel(), 42);
});
- test("cancels underlying subscription, returns result", () async {
+ test('cancels underlying subscription, returns result', () async {
var cancelFuture = Future.value(42);
var controller = StreamController<int>(onCancel: () => cancelFuture);
var events = StreamQueue<int>(controller.stream);
@@ -499,8 +499,8 @@
expect(await events.cancel(), 42);
});
- group("with immediate: true", () {
- test("closes the events, prevents any other operation", () async {
+ group('with immediate: true', () {
+ test('closes the events, prevents any other operation', () async {
var events = StreamQueue<int>(createStream());
await events.cancel(immediate: true);
expect(() => events.next, throwsStateError);
@@ -510,7 +510,7 @@
expect(() => events.cancel(), throwsStateError);
});
- test("cancels the underlying subscription immediately", () async {
+ test('cancels the underlying subscription immediately', () async {
var controller = StreamController<int>();
controller.add(1);
@@ -522,7 +522,7 @@
expect(controller.hasListener, isFalse);
});
- test("cancels the underlying subscription when called before any event",
+ test('cancels the underlying subscription when called before any event',
() async {
var cancelFuture = Future.value(42);
var controller = StreamController<int>(onCancel: () => cancelFuture);
@@ -531,7 +531,7 @@
expect(await events.cancel(immediate: true), 42);
});
- test("closes pending requests", () async {
+ test('closes pending requests', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(events.next, throwsStateError);
@@ -540,7 +540,7 @@
await events.cancel(immediate: true);
});
- test("returns the result of closing the underlying subscription",
+ test('returns the result of closing the underlying subscription',
() async {
var controller =
StreamController<int>(onCancel: () => Future.value(42));
@@ -564,30 +564,30 @@
});
});
- group("hasNext operation", () {
- test("true at start", () async {
+ group('hasNext operation', () {
+ test('true at start', () async {
var events = StreamQueue<int>(createStream());
expect(await events.hasNext, isTrue);
});
- test("true after start", () async {
+ test('true after start', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, isTrue);
});
- test("true at end", () async {
+ test('true at end', () async {
var events = StreamQueue<int>(createStream());
- for (int i = 1; i <= 4; i++) {
+ for (var i = 1; i <= 4; i++) {
expect(await events.next, i);
}
expect(await events.hasNext, isFalse);
});
- test("true when enqueued", () async {
+ test('true when enqueued', () async {
var events = StreamQueue<int>(createStream());
var values = <int>[];
- for (int i = 1; i <= 3; i++) {
+ for (var i = 1; i <= 3; i++) {
events.next.then(values.add);
}
expect(values, isEmpty);
@@ -595,10 +595,10 @@
expect(values, [1, 2, 3]);
});
- test("false when enqueued", () async {
+ test('false when enqueued', () async {
var events = StreamQueue<int>(createStream());
var values = <int>[];
- for (int i = 1; i <= 4; i++) {
+ for (var i = 1; i <= 4; i++) {
events.next.then(values.add);
}
expect(values, isEmpty);
@@ -606,7 +606,7 @@
expect(values, [1, 2, 3, 4]);
});
- test("true when data event", () async {
+ test('true when data event', () async {
var controller = StreamController<int>();
var events = StreamQueue<int>(controller.stream);
@@ -622,7 +622,7 @@
expect(hasNext, isTrue);
});
- test("true when error event", () async {
+ test('true when error event', () async {
var controller = StreamController<int>();
var events = StreamQueue<int>(controller.stream);
@@ -632,14 +632,14 @@
});
await flushMicrotasks();
expect(hasNext, isNull);
- controller.addError("BAD");
+ controller.addError('BAD');
expect(hasNext, isNull);
await flushMicrotasks();
expect(hasNext, isTrue);
- expect(events.next, throwsA("BAD"));
+ expect(events.next, throwsA('BAD'));
});
- test("- hasNext after hasNext", () async {
+ test('- hasNext after hasNext', () async {
var events = StreamQueue<int>(createStream());
expect(await events.hasNext, true);
expect(await events.hasNext, true);
@@ -657,7 +657,7 @@
expect(await events.hasNext, false);
});
- test("- next after true", () async {
+ test('- next after true', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
@@ -665,7 +665,7 @@
expect(await events.next, 3);
});
- test("- next after true, enqueued", () async {
+ test('- next after true, enqueued', () async {
var events = StreamQueue<int>(createStream());
var responses = <Object>[];
events.next.then(responses.add);
@@ -677,7 +677,7 @@
expect(responses, [1, true, 2]);
});
- test("- skip 0 after true", () async {
+ test('- skip 0 after true', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
@@ -685,7 +685,7 @@
expect(await events.next, 2);
});
- test("- skip 1 after true", () async {
+ test('- skip 1 after true', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
@@ -693,7 +693,7 @@
expect(await events.next, 3);
});
- test("- skip 2 after true", () async {
+ test('- skip 2 after true', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
@@ -701,7 +701,7 @@
expect(await events.next, 4);
});
- test("- take 0 after true", () async {
+ test('- take 0 after true', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
@@ -709,7 +709,7 @@
expect(await events.next, 2);
});
- test("- take 1 after true", () async {
+ test('- take 1 after true', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
@@ -717,7 +717,7 @@
expect(await events.next, 3);
});
- test("- take 2 after true", () async {
+ test('- take 2 after true', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
@@ -725,7 +725,7 @@
expect(await events.next, 4);
});
- test("- rest after true", () async {
+ test('- rest after true', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
@@ -733,7 +733,7 @@
expect(await stream.toList(), [2, 3, 4]);
});
- test("- rest after true, at last", () async {
+ test('- rest after true, at last', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
@@ -743,7 +743,7 @@
expect(await stream.toList(), [4]);
});
- test("- rest after false", () async {
+ test('- rest after false', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
@@ -754,7 +754,7 @@
expect(await stream.toList(), isEmpty);
});
- test("- cancel after true on data", () async {
+ test('- cancel after true on data', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
@@ -762,7 +762,7 @@
expect(await events.cancel(), null);
});
- test("- cancel after true on error", () async {
+ test('- cancel after true on error', () async {
var events = StreamQueue<int>(createErrorStream());
expect(await events.next, 1);
expect(await events.next, 2);
@@ -771,7 +771,7 @@
});
});
- group("startTransaction operation produces a transaction that", () {
+ group('startTransaction operation produces a transaction that', () {
StreamQueue<int> events;
StreamQueueTransaction<int> transaction;
StreamQueue<int> queue1;
@@ -784,8 +784,8 @@
queue2 = transaction.newQueue();
});
- group("emits queues that", () {
- test("independently emit events", () async {
+ group('emits queues that', () {
+ test('independently emit events', () async {
expect(await queue1.next, 2);
expect(await queue2.next, 2);
expect(await queue2.next, 3);
@@ -796,7 +796,7 @@
expect(await queue2.hasNext, isFalse);
});
- test("queue requests for events", () async {
+ test('queue requests for events', () async {
expect(queue1.next, completion(2));
expect(queue2.next, completion(2));
expect(queue2.next, completion(3));
@@ -807,7 +807,7 @@
expect(queue2.hasNext, completion(isFalse));
});
- test("independently emit errors", () async {
+ test('independently emit errors', () async {
events = StreamQueue(createErrorStream());
expect(await events.next, 1);
transaction = events.startTransaction();
@@ -816,8 +816,8 @@
expect(queue1.next, completion(2));
expect(queue2.next, completion(2));
- expect(queue2.next, throwsA("To err is divine!"));
- expect(queue1.next, throwsA("To err is divine!"));
+ expect(queue2.next, throwsA('To err is divine!'));
+ expect(queue1.next, throwsA('To err is divine!'));
expect(queue1.next, completion(4));
expect(queue2.next, completion(4));
expect(queue1.hasNext, completion(isFalse));
@@ -825,8 +825,8 @@
});
});
- group("when rejected", () {
- test("further original requests use the previous state", () async {
+ group('when rejected', () {
+ test('further original requests use the previous state', () async {
expect(await queue1.next, 2);
expect(await queue2.next, 2);
expect(await queue2.next, 3);
@@ -840,7 +840,7 @@
expect(await events.hasNext, isFalse);
});
- test("pending original requests use the previous state", () async {
+ test('pending original requests use the previous state', () async {
expect(await queue1.next, 2);
expect(await queue2.next, 2);
expect(await queue2.next, 3);
@@ -853,7 +853,7 @@
transaction.reject();
});
- test("further child requests act as though the stream was closed",
+ test('further child requests act as though the stream was closed',
() async {
expect(await queue1.next, 2);
transaction.reject();
@@ -862,7 +862,7 @@
expect(queue1.next, throwsStateError);
});
- test("pending child requests act as though the stream was closed",
+ test('pending child requests act as though the stream was closed',
() async {
expect(await queue1.next, 2);
expect(queue1.hasNext, completion(isFalse));
@@ -871,7 +871,7 @@
});
// Regression test.
- test("pending child rest requests emit no more events", () async {
+ test('pending child rest requests emit no more events', () async {
var controller = StreamController();
var events = StreamQueue(controller.stream);
var transaction = events.startTransaction();
@@ -899,13 +899,13 @@
await queue1.cancel();
});
- test("calls to commit() or reject() fail", () async {
+ test('calls to commit() or reject() fail', () async {
transaction.reject();
expect(transaction.reject, throwsStateError);
expect(() => transaction.commit(queue1), throwsStateError);
});
- test("before the transaction emits any events, does nothing", () async {
+ test('before the transaction emits any events, does nothing', () async {
var controller = StreamController();
var events = StreamQueue(controller.stream);
@@ -924,22 +924,22 @@
});
});
- group("when committed", () {
- test("further original requests use the committed state", () async {
+ group('when committed', () {
+ test('further original requests use the committed state', () async {
expect(await queue1.next, 2);
await flushMicrotasks();
transaction.commit(queue1);
expect(await events.next, 3);
});
- test("pending original requests use the committed state", () async {
+ test('pending original requests use the committed state', () async {
expect(await queue1.next, 2);
expect(events.next, completion(3));
await flushMicrotasks();
transaction.commit(queue1);
});
- test("further child requests act as though the stream was closed",
+ test('further child requests act as though the stream was closed',
() async {
expect(await queue2.next, 2);
transaction.commit(queue2);
@@ -948,7 +948,7 @@
expect(queue1.next, throwsStateError);
});
- test("pending child requests act as though the stream was closed",
+ test('pending child requests act as though the stream was closed',
() async {
expect(await queue2.next, 2);
expect(queue1.hasNext, completion(isFalse));
@@ -956,7 +956,7 @@
transaction.commit(queue2);
});
- test("further requests act as though the stream was closed", () async {
+ test('further requests act as though the stream was closed', () async {
expect(await queue1.next, 2);
transaction.commit(queue1);
@@ -964,25 +964,25 @@
expect(queue1.next, throwsStateError);
});
- test("cancel() may still be called explicitly", () async {
+ test('cancel() may still be called explicitly', () async {
expect(await queue1.next, 2);
transaction.commit(queue1);
await queue1.cancel();
});
- test("throws if there are pending requests", () async {
+ test('throws if there are pending requests', () async {
expect(await queue1.next, 2);
expect(queue1.hasNext, completion(isTrue));
expect(() => transaction.commit(queue1), throwsStateError);
});
- test("calls to commit() or reject() fail", () async {
+ test('calls to commit() or reject() fail', () async {
transaction.commit(queue1);
expect(transaction.reject, throwsStateError);
expect(() => transaction.commit(queue1), throwsStateError);
});
- test("before the transaction emits any events, does nothing", () async {
+ test('before the transaction emits any events, does nothing', () async {
var controller = StreamController();
var events = StreamQueue(controller.stream);
@@ -1003,14 +1003,14 @@
});
});
- group("withTransaction operation", () {
+ group('withTransaction operation', () {
StreamQueue<int> events;
setUp(() async {
events = StreamQueue(createStream());
expect(await events.next, 1);
});
- test("passes a copy of the parent queue", () async {
+ test('passes a copy of the parent queue', () async {
await events.withTransaction(expectAsync1((queue) async {
expect(await queue.next, 2);
expect(await queue.next, 3);
@@ -1021,8 +1021,8 @@
});
test(
- "the parent queue continues from the child position if it returns "
- "true", () async {
+ 'the parent queue continues from the child position if it returns '
+ 'true', () async {
await events.withTransaction(expectAsync1((queue) async {
expect(await queue.next, 2);
return true;
@@ -1032,8 +1032,8 @@
});
test(
- "the parent queue continues from its original position if it returns "
- "false", () async {
+ 'the parent queue continues from its original position if it returns '
+ 'false', () async {
await events.withTransaction(expectAsync1((queue) async {
expect(await queue.next, 2);
return false;
@@ -1042,29 +1042,29 @@
expect(await events.next, 2);
});
- test("the parent queue continues from the child position if it throws", () {
+ test('the parent queue continues from the child position if it throws', () {
expect(events.withTransaction(expectAsync1((queue) async {
expect(await queue.next, 2);
- throw "oh no";
- })), throwsA("oh no"));
+ throw 'oh no';
+ })), throwsA('oh no'));
expect(events.next, completion(3));
});
- test("returns whether the transaction succeeded", () {
+ test('returns whether the transaction succeeded', () {
expect(events.withTransaction((_) async => true), completion(isTrue));
expect(events.withTransaction((_) async => false), completion(isFalse));
});
});
- group("cancelable operation", () {
+ group('cancelable operation', () {
StreamQueue<int> events;
setUp(() async {
events = StreamQueue(createStream());
expect(await events.next, 1);
});
- test("passes a copy of the parent queue", () async {
+ test('passes a copy of the parent queue', () async {
await events.cancelable(expectAsync1((queue) async {
expect(await queue.next, 2);
expect(await queue.next, 3);
@@ -1073,7 +1073,7 @@
})).value;
});
- test("the parent queue continues from the child position by default",
+ test('the parent queue continues from the child position by default',
() async {
await events.cancelable(expectAsync1((queue) async {
expect(await queue.next, 2);
@@ -1083,19 +1083,19 @@
});
test(
- "the parent queue continues from the child position if an error is "
- "thrown", () async {
+ 'the parent queue continues from the child position if an error is '
+ 'thrown', () async {
expect(
events.cancelable(expectAsync1((queue) async {
expect(await queue.next, 2);
- throw "oh no";
+ throw 'oh no';
})).value,
- throwsA("oh no"));
+ throwsA('oh no'));
expect(events.next, completion(3));
});
- test("the parent queue continues from the original position if canceled",
+ test('the parent queue continues from the original position if canceled',
() async {
var operation = events.cancelable(expectAsync1((queue) async {
expect(await queue.next, 2);
@@ -1105,17 +1105,17 @@
expect(await events.next, 2);
});
- test("forwards the value from the callback", () async {
+ test('forwards the value from the callback', () async {
expect(
await events.cancelable(expectAsync1((queue) async {
expect(await queue.next, 2);
- return "value";
+ return 'value';
})).value,
- "value");
+ 'value');
});
});
- test("all combinations sequential skip/next/take operations", () async {
+ test('all combinations sequential skip/next/take operations', () async {
// Takes all combinations of two of next, skip and take, then ends with
// doing rest. Each of the first rounds do 10 events of each type,
// the rest does 20 elements.
@@ -1124,30 +1124,30 @@
// Test expecting [startIndex .. startIndex + 9] as events using
// `next`.
- nextTest(startIndex) {
- for (int i = 0; i < 10; i++) {
+ void nextTest(startIndex) {
+ for (var i = 0; i < 10; i++) {
expect(events.next, completion(startIndex + i));
}
}
// Test expecting 10 events to be skipped.
- skipTest(startIndex) {
+ void skipTest(startIndex) {
expect(events.skip(10), completion(0));
}
// Test expecting [startIndex .. startIndex + 9] as events using
// `take(10)`.
- takeTest(startIndex) {
+ void takeTest(startIndex) {
expect(events.take(10),
completion(List.generate(10, (i) => startIndex + i)));
}
var tests = [nextTest, skipTest, takeTest];
- int counter = 0;
+ var counter = 0;
// Run through all pairs of two tests and run them.
- for (int i = 0; i < tests.length; i++) {
- for (int j = 0; j < tests.length; j++) {
+ for (var i = 0; i < tests.length; i++) {
+ for (var j = 0; j < tests.length; j++) {
tests[i](counter);
tests[j](counter + 10);
counter += 20;
@@ -1178,7 +1178,7 @@
await flushMicrotasks();
controller.add(2);
await flushMicrotasks();
- controller.addError("To err is divine!");
+ controller.addError('To err is divine!');
await flushMicrotasks();
controller.add(4);
await flushMicrotasks();
@@ -1188,5 +1188,7 @@
}
Stream<int> createLongStream(int eventCount) async* {
- for (int i = 0; i < eventCount; i++) yield i;
+ for (var i = 0; i < eventCount; i++) {
+ yield i;
+ }
}
diff --git a/test/stream_sink_completer_test.dart b/test/stream_sink_completer_test.dart
index 56860ce..69d1d8a 100644
--- a/test/stream_sink_completer_test.dart
+++ b/test/stream_sink_completer_test.dart
@@ -2,21 +2,21 @@
// for details. 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 'dart:async';
-import "package:async/async.dart";
-import "package:test/test.dart";
+import 'package:async/async.dart';
+import 'package:test/test.dart';
-import "utils.dart";
+import 'utils.dart';
-main() {
+void main() {
StreamSinkCompleter completer;
setUp(() {
completer = StreamSinkCompleter();
});
- group("when a stream is linked before events are added", () {
- test("data events are forwarded", () {
+ group('when a stream is linked before events are added', () {
+ test('data events are forwarded', () {
var sink = TestSink();
completer.setDestinationSink(sink);
completer.sink..add(1)..add(2)..add(3)..add(4);
@@ -27,16 +27,16 @@
expect(sink.results[3].asValue.value, equals(4));
});
- test("error events are forwarded", () {
+ test('error events are forwarded', () {
var sink = TestSink();
completer.setDestinationSink(sink);
- completer.sink..addError("oh no")..addError("that's bad");
+ completer.sink..addError('oh no')..addError("that's bad");
- expect(sink.results[0].asError.error, equals("oh no"));
+ expect(sink.results[0].asError.error, equals('oh no'));
expect(sink.results[1].asError.error, equals("that's bad"));
});
- test("addStream is forwarded", () async {
+ test('addStream is forwarded', () async {
var sink = TestSink();
completer.setDestinationSink(sink);
@@ -44,13 +44,13 @@
completer.sink.addStream(controller.stream);
controller.add(1);
- controller.addError("oh no");
+ controller.addError('oh no');
controller.add(2);
controller.addError("that's bad");
await flushMicrotasks();
expect(sink.results[0].asValue.value, equals(1));
- expect(sink.results[1].asError.error, equals("oh no"));
+ expect(sink.results[1].asError.error, equals('oh no'));
expect(sink.results[2].asValue.value, equals(2));
expect(sink.results[3].asError.error, equals("that's bad"));
expect(sink.isClosed, isFalse);
@@ -60,14 +60,14 @@
expect(sink.isClosed, isFalse);
});
- test("close() is forwarded", () {
+ test('close() is forwarded', () {
var sink = TestSink();
completer.setDestinationSink(sink);
completer.sink.close();
expect(sink.isClosed, isTrue);
});
- test("the future from the inner close() is returned", () async {
+ test('the future from the inner close() is returned', () async {
var closeCompleter = Completer();
var sink = TestSink(onDone: () => closeCompleter.future);
completer.setDestinationSink(sink);
@@ -85,35 +85,35 @@
expect(closeCompleted, isTrue);
});
- test("errors are forwarded from the inner close()", () {
- var sink = TestSink(onDone: () => throw "oh no");
+ test('errors are forwarded from the inner close()', () {
+ var sink = TestSink(onDone: () => throw 'oh no');
completer.setDestinationSink(sink);
- expect(completer.sink.done, throwsA("oh no"));
- expect(completer.sink.close(), throwsA("oh no"));
+ expect(completer.sink.done, throwsA('oh no'));
+ expect(completer.sink.close(), throwsA('oh no'));
});
test("errors aren't top-leveled if only close() is listened to", () async {
- var sink = TestSink(onDone: () => throw "oh no");
+ var sink = TestSink(onDone: () => throw 'oh no');
completer.setDestinationSink(sink);
- expect(completer.sink.close(), throwsA("oh no"));
+ expect(completer.sink.close(), throwsA('oh no'));
// Give the event loop a chance to top-level errors if it's going to.
await flushMicrotasks();
});
test("errors aren't top-leveled if only done is listened to", () async {
- var sink = TestSink(onDone: () => throw "oh no");
+ var sink = TestSink(onDone: () => throw 'oh no');
completer.setDestinationSink(sink);
completer.sink.close();
- expect(completer.sink.done, throwsA("oh no"));
+ expect(completer.sink.done, throwsA('oh no'));
// Give the event loop a chance to top-level errors if it's going to.
await flushMicrotasks();
});
});
- group("when a stream is linked after events are added", () {
- test("data events are forwarded", () async {
+ group('when a stream is linked after events are added', () {
+ test('data events are forwarded', () async {
completer.sink..add(1)..add(2)..add(3)..add(4);
await flushMicrotasks();
@@ -127,24 +127,24 @@
expect(sink.results[3].asValue.value, equals(4));
});
- test("error events are forwarded", () async {
- completer.sink..addError("oh no")..addError("that's bad");
+ test('error events are forwarded', () async {
+ completer.sink..addError('oh no')..addError("that's bad");
await flushMicrotasks();
var sink = TestSink();
completer.setDestinationSink(sink);
await flushMicrotasks();
- expect(sink.results[0].asError.error, equals("oh no"));
+ expect(sink.results[0].asError.error, equals('oh no'));
expect(sink.results[1].asError.error, equals("that's bad"));
});
- test("addStream is forwarded", () async {
+ test('addStream is forwarded', () async {
var controller = StreamController();
completer.sink.addStream(controller.stream);
controller.add(1);
- controller.addError("oh no");
+ controller.addError('oh no');
controller.add(2);
controller.addError("that's bad");
controller.close();
@@ -155,13 +155,13 @@
await flushMicrotasks();
expect(sink.results[0].asValue.value, equals(1));
- expect(sink.results[1].asError.error, equals("oh no"));
+ expect(sink.results[1].asError.error, equals('oh no'));
expect(sink.results[2].asValue.value, equals(2));
expect(sink.results[3].asError.error, equals("that's bad"));
expect(sink.isClosed, isFalse);
});
- test("close() is forwarded", () async {
+ test('close() is forwarded', () async {
completer.sink.close();
await flushMicrotasks();
@@ -172,7 +172,7 @@
expect(sink.isClosed, isTrue);
});
- test("the future from the inner close() is returned", () async {
+ test('the future from the inner close() is returned', () async {
var closeCompleted = false;
completer.sink.close().then(expectAsync1((_) {
closeCompleted = true;
@@ -190,20 +190,20 @@
expect(closeCompleted, isTrue);
});
- test("errors are forwarded from the inner close()", () async {
- expect(completer.sink.done, throwsA("oh no"));
- expect(completer.sink.close(), throwsA("oh no"));
+ test('errors are forwarded from the inner close()', () async {
+ expect(completer.sink.done, throwsA('oh no'));
+ expect(completer.sink.close(), throwsA('oh no'));
await flushMicrotasks();
- var sink = TestSink(onDone: () => throw "oh no");
+ var sink = TestSink(onDone: () => throw 'oh no');
completer.setDestinationSink(sink);
});
test("errors aren't top-leveled if only close() is listened to", () async {
- expect(completer.sink.close(), throwsA("oh no"));
+ expect(completer.sink.close(), throwsA('oh no'));
await flushMicrotasks();
- var sink = TestSink(onDone: () => throw "oh no");
+ var sink = TestSink(onDone: () => throw 'oh no');
completer.setDestinationSink(sink);
// Give the event loop a chance to top-level errors if it's going to.
@@ -212,10 +212,10 @@
test("errors aren't top-leveled if only done is listened to", () async {
completer.sink.close();
- expect(completer.sink.done, throwsA("oh no"));
+ expect(completer.sink.done, throwsA('oh no'));
await flushMicrotasks();
- var sink = TestSink(onDone: () => throw "oh no");
+ var sink = TestSink(onDone: () => throw 'oh no');
completer.setDestinationSink(sink);
// Give the event loop a chance to top-level errors if it's going to.
@@ -223,7 +223,7 @@
});
});
- test("the sink is closed, the destination is set, then done is read",
+ test('the sink is closed, the destination is set, then done is read',
() async {
expect(completer.sink.close(), completes);
await flushMicrotasks();
@@ -234,7 +234,7 @@
expect(completer.sink.done, completes);
});
- test("done is read, the destination is set, then the sink is closed",
+ test('done is read, the destination is set, then the sink is closed',
() async {
expect(completer.sink.done, completes);
await flushMicrotasks();
@@ -245,8 +245,8 @@
expect(completer.sink.close(), completes);
});
- group("fromFuture()", () {
- test("with a successful completion", () async {
+ group('fromFuture()', () {
+ test('with a successful completion', () async {
var futureCompleter = Completer<StreamSink>();
var sink = StreamSinkCompleter.fromFuture(futureCompleter.future);
sink.add(1);
@@ -263,27 +263,27 @@
expect(testSink.results[2].asValue.value, equals(3));
});
- test("with an error", () async {
+ test('with an error', () async {
var futureCompleter = Completer<StreamSink>();
var sink = StreamSinkCompleter.fromFuture(futureCompleter.future);
- expect(sink.done, throwsA("oh no"));
- futureCompleter.completeError("oh no");
+ expect(sink.done, throwsA('oh no'));
+ futureCompleter.completeError('oh no');
});
});
- group("setError()", () {
- test("produces a closed sink with the error", () {
- completer.setError("oh no");
- expect(completer.sink.done, throwsA("oh no"));
- expect(completer.sink.close(), throwsA("oh no"));
+ group('setError()', () {
+ test('produces a closed sink with the error', () {
+ completer.setError('oh no');
+ expect(completer.sink.done, throwsA('oh no'));
+ expect(completer.sink.close(), throwsA('oh no'));
});
- test("produces an error even if done was accessed earlier", () async {
- expect(completer.sink.done, throwsA("oh no"));
- expect(completer.sink.close(), throwsA("oh no"));
+ test('produces an error even if done was accessed earlier', () async {
+ expect(completer.sink.done, throwsA('oh no'));
+ expect(completer.sink.close(), throwsA('oh no'));
await flushMicrotasks();
- completer.setError("oh no");
+ completer.setError('oh no');
});
});
diff --git a/test/stream_sink_transformer_test.dart b/test/stream_sink_transformer_test.dart
index 5e981a6..8493971 100644
--- a/test/stream_sink_transformer_test.dart
+++ b/test/stream_sink_transformer_test.dart
@@ -2,12 +2,12 @@
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE filevents.
-import "dart:async";
+import 'dart:async';
-import "package:async/async.dart";
-import "package:test/test.dart";
+import 'package:async/async.dart';
+import 'package:test/test.dart';
-import "utils.dart";
+import 'utils.dart';
void main() {
StreamController controller;
@@ -15,8 +15,8 @@
controller = StreamController();
});
- group("fromStreamTransformer", () {
- test("transforms data events", () {
+ group('fromStreamTransformer', () {
+ test('transforms data events', () {
var transformer = StreamSinkTransformer.fromStreamTransformer(
StreamTransformer.fromHandlers(handleData: (i, sink) {
sink.add(i * 2);
@@ -34,7 +34,7 @@
sink.close();
});
- test("transforms error events", () {
+ test('transforms error events', () {
var transformer = StreamSinkTransformer.fromStreamTransformer(
StreamTransformer.fromHandlers(handleError: (i, stackTrace, sink) {
sink.addError((i as num) * 2, stackTrace);
@@ -55,7 +55,7 @@
sink.close();
});
- test("transforms done events", () {
+ test('transforms done events', () {
var transformer = StreamSinkTransformer.fromStreamTransformer(
StreamTransformer.fromHandlers(handleDone: (sink) {
sink.add(1);
@@ -71,7 +71,7 @@
sink.close();
});
- test("forwards the future from inner.close", () async {
+ test('forwards the future from inner.close', () async {
var transformer = StreamSinkTransformer.fromStreamTransformer(
StreamTransformer.fromHandlers());
var innerSink = CompleterStreamSink();
@@ -104,18 +104,18 @@
// This will close the inner sink, but it shouldn't top-level the error.
sink.add(1);
- innerSink.completer.completeError("oh no");
+ innerSink.completer.completeError('oh no');
await flushMicrotasks();
// The error should be piped through done and close even if they're called
// after the underlying sink is closed.
- expect(sink.done, throwsA("oh no"));
- expect(sink.close(), throwsA("oh no"));
+ expect(sink.done, throwsA('oh no'));
+ expect(sink.close(), throwsA('oh no'));
});
});
- group("fromHandlers", () {
- test("transforms data events", () {
+ group('fromHandlers', () {
+ test('transforms data events', () {
var transformer =
StreamSinkTransformer.fromHandlers(handleData: (i, sink) {
sink.add(i * 2);
@@ -133,7 +133,7 @@
sink.close();
});
- test("transforms error events", () {
+ test('transforms error events', () {
var transformer = StreamSinkTransformer.fromHandlers(
handleError: (i, stackTrace, sink) {
sink.addError((i as num) * 2, stackTrace);
@@ -154,7 +154,7 @@
sink.close();
});
- test("transforms done events", () {
+ test('transforms done events', () {
var transformer = StreamSinkTransformer.fromHandlers(handleDone: (sink) {
sink.add(1);
sink.close();
@@ -169,7 +169,7 @@
sink.close();
});
- test("forwards the future from inner.close", () async {
+ test('forwards the future from inner.close', () async {
var transformer = StreamSinkTransformer.fromHandlers();
var innerSink = CompleterStreamSink();
var sink = transformer.bind(innerSink);
@@ -201,13 +201,13 @@
// This will close the inner sink, but it shouldn't top-level the error.
sink.add(1);
- innerSink.completer.completeError("oh no");
+ innerSink.completer.completeError('oh no');
await flushMicrotasks();
// The error should be piped through done and close even if they're called
// after the underlying sink is closed.
- expect(sink.done, throwsA("oh no"));
- expect(sink.close(), throwsA("oh no"));
+ expect(sink.done, throwsA('oh no'));
+ expect(sink.close(), throwsA('oh no'));
});
});
}
diff --git a/test/stream_splitter_test.dart b/test/stream_splitter_test.dart
index 497f125..fd37f87 100644
--- a/test/stream_splitter_test.dart
+++ b/test/stream_splitter_test.dart
@@ -7,7 +7,7 @@
import 'package:async/async.dart';
import 'package:test/test.dart';
-main() {
+void main() {
StreamController<int> controller;
StreamSplitter splitter;
setUp(() {
@@ -37,12 +37,12 @@
controller.close();
});
- test("a branch replays error events as well as data events", () {
+ test('a branch replays error events as well as data events', () {
var branch = splitter.split();
splitter.close();
controller.add(1);
- controller.addError("error");
+ controller.addError('error');
controller.add(3);
controller.close();
@@ -54,7 +54,7 @@
count++;
}, count: 2), onError: expectAsync1((error) {
expect(count, equals(1));
- expect(error, equals("error"));
+ expect(error, equals('error'));
count++;
}), onDone: expectAsync0(() {
expect(count, equals(3));
@@ -89,7 +89,7 @@
splitter.close();
});
- test("creates single-subscription branches", () async {
+ test('creates single-subscription branches', () async {
var branch = splitter.split();
expect(branch.isBroadcast, isFalse);
branch.listen(null);
@@ -101,7 +101,7 @@
// 1.11 is released. In 1.10, the stream exposed by a StreamController didn't
// have a reified type.
- test("multiple branches each replay the stream", () async {
+ test('multiple branches each replay the stream', () async {
var branch1 = splitter.split();
controller.add(1);
controller.add(2);
@@ -151,7 +151,7 @@
expect(controller.hasListener, isTrue);
});
- test("the source stream is paused when all branches are paused", () async {
+ test('the source stream is paused when all branches are paused', () async {
var branch1 = splitter.split();
var branch2 = splitter.split();
var branch3 = splitter.split();
@@ -178,7 +178,7 @@
expect(controller.isPaused, isFalse);
});
- test("the source stream is paused when all branches are canceled", () async {
+ test('the source stream is paused when all branches are canceled', () async {
var branch1 = splitter.split();
var branch2 = splitter.split();
var branch3 = splitter.split();
@@ -211,7 +211,7 @@
test(
"the source stream is canceled when it's closed after all branches have "
- "been canceled", () async {
+ 'been canceled', () async {
var branch1 = splitter.split();
var branch2 = splitter.split();
var branch3 = splitter.split();
@@ -237,8 +237,8 @@
});
test(
- "the source stream is canceled when all branches are canceled after it "
- "has been closed", () async {
+ 'the source stream is canceled when all branches are canceled after it '
+ 'has been closed', () async {
var branch1 = splitter.split();
var branch2 = splitter.split();
var branch3 = splitter.split();
@@ -263,7 +263,7 @@
test(
"a splitter that's closed before any branches are added never listens "
- "to the source stream", () {
+ 'to the source stream', () {
splitter.close();
// This would throw an error if the stream had already been listened to.
@@ -271,8 +271,8 @@
});
test(
- "splitFrom splits a source stream into the designated number of "
- "branches", () {
+ 'splitFrom splits a source stream into the designated number of '
+ 'branches', () {
var branches = StreamSplitter.splitFrom(controller.stream, 5);
controller.add(1);
diff --git a/test/stream_zip_test.dart b/test/stream_zip_test.dart
index 1e5f524..f462996 100644
--- a/test/stream_zip_test.dart
+++ b/test/stream_zip_test.dart
@@ -2,10 +2,10 @@
// for details. 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 'dart:async';
-import "package:async/async.dart";
-import "package:test/test.dart";
+import 'package:async/async.dart';
+import 'package:test/test.dart';
/// Create an error with the same values as [base], except that it throwsA
/// when seeing the value [errorValue].
@@ -16,10 +16,10 @@
/// Make a [Stream] from an [Iterable] by adding events to a stream controller
/// at periodic intervals.
Stream mks(Iterable iterable) {
- Iterator iterator = iterable.iterator;
- StreamController controller = StreamController();
+ var iterator = iterable.iterator;
+ var controller = StreamController();
// Some varying time between 3 and 10 ms.
- int ms = ((++ctr) * 5) % 7 + 3;
+ var ms = ((++ctr) * 5) % 7 + 3;
Timer.periodic(Duration(milliseconds: ms), (Timer timer) {
if (iterator.moveNext()) {
controller.add(iterator.current);
@@ -34,17 +34,17 @@
/// Counter used to give varying delays for streams.
int ctr = 0;
-main() {
+void main() {
// Test that zipping [streams] gives the results iterated by [expectedData].
- testZip(Iterable<Stream> streams, Iterable expectedData) {
- List data = [];
+ void testZip(Iterable<Stream> streams, Iterable expectedData) {
+ var data = [];
Stream zip = StreamZip(streams);
zip.listen(data.add, onDone: expectAsync0(() {
expect(data, equals(expectedData));
}));
}
- test("Basic", () {
+ test('Basic', () {
testZip([
mks([1, 2, 3]),
mks([4, 5, 6]),
@@ -56,7 +56,7 @@
]);
});
- test("Uneven length 1", () {
+ test('Uneven length 1', () {
testZip([
mks([1, 2, 3, 99, 100]),
mks([4, 5, 6]),
@@ -68,7 +68,7 @@
]);
});
- test("Uneven length 2", () {
+ test('Uneven length 2', () {
testZip([
mks([1, 2, 3]),
mks([4, 5, 6, 99, 100]),
@@ -80,7 +80,7 @@
]);
});
- test("Uneven length 3", () {
+ test('Uneven length 3', () {
testZip([
mks([1, 2, 3]),
mks([4, 5, 6]),
@@ -92,7 +92,7 @@
]);
});
- test("Uneven length 4", () {
+ test('Uneven length 4', () {
testZip([
mks([1, 2, 3, 98]),
mks([4, 5, 6]),
@@ -104,7 +104,7 @@
]);
});
- test("Empty 1", () {
+ test('Empty 1', () {
testZip([
mks([]),
mks([4, 5, 6]),
@@ -112,7 +112,7 @@
], []);
});
- test("Empty 2", () {
+ test('Empty 2', () {
testZip([
mks([1, 2, 3]),
mks([]),
@@ -120,7 +120,7 @@
], []);
});
- test("Empty 3", () {
+ test('Empty 3', () {
testZip([
mks([1, 2, 3]),
mks([4, 5, 6]),
@@ -128,11 +128,11 @@
], []);
});
- test("Empty source", () {
+ test('Empty source', () {
testZip([], []);
});
- test("Single Source", () {
+ test('Single Source', () {
testZip([
mks([1, 2, 3])
], [
@@ -142,12 +142,12 @@
]);
});
- test("Other-streams", () {
- Stream st1 = mks([1, 2, 3, 4, 5, 6]).where((x) => x < 4);
+ test('Other-streams', () {
+ var st1 = mks([1, 2, 3, 4, 5, 6]).where((x) => x < 4);
Stream st2 =
Stream.periodic(const Duration(milliseconds: 5), (x) => x + 4).take(3);
- StreamController c = StreamController.broadcast();
- Stream st3 = c.stream;
+ var c = StreamController.broadcast();
+ var st3 = c.stream;
testZip([
st1,
st2,
@@ -164,67 +164,66 @@
..close();
});
- test("Error 1", () {
+ test('Error 1', () {
expect(
StreamZip([
- streamError(mks([1, 2, 3]), 2, "BAD-1"),
+ streamError(mks([1, 2, 3]), 2, 'BAD-1'),
mks([4, 5, 6]),
mks([7, 8, 9])
]).toList(),
- throwsA(equals("BAD-1")));
+ throwsA(equals('BAD-1')));
});
- test("Error 2", () {
+ test('Error 2', () {
expect(
StreamZip([
mks([1, 2, 3]),
- streamError(mks([4, 5, 6]), 5, "BAD-2"),
+ streamError(mks([4, 5, 6]), 5, 'BAD-2'),
mks([7, 8, 9])
]).toList(),
- throwsA(equals("BAD-2")));
+ throwsA(equals('BAD-2')));
});
- test("Error 3", () {
+ test('Error 3', () {
expect(
StreamZip([
mks([1, 2, 3]),
mks([4, 5, 6]),
- streamError(mks([7, 8, 9]), 8, "BAD-3")
+ streamError(mks([7, 8, 9]), 8, 'BAD-3')
]).toList(),
- throwsA(equals("BAD-3")));
+ throwsA(equals('BAD-3')));
});
- test("Error at end", () {
+ test('Error at end', () {
expect(
StreamZip([
mks([1, 2, 3]),
- streamError(mks([4, 5, 6]), 6, "BAD-4"),
+ streamError(mks([4, 5, 6]), 6, 'BAD-4'),
mks([7, 8, 9])
]).toList(),
- throwsA(equals("BAD-4")));
+ throwsA(equals('BAD-4')));
});
- test("Error before first end", () {
+ test('Error before first end', () {
// StreamControllers' streams with no "close" called will never be done,
// so the fourth event of the first stream is guaranteed to come first.
expect(
StreamZip([
- streamError(mks([1, 2, 3, 4]), 4, "BAD-5"),
+ streamError(mks([1, 2, 3, 4]), 4, 'BAD-5'),
(StreamController()..add(4)..add(5)..add(6)).stream,
(StreamController()..add(7)..add(8)..add(9)).stream
]).toList(),
- throwsA(equals("BAD-5")));
+ throwsA(equals('BAD-5')));
});
- test("Error after first end", () {
- StreamController controller = StreamController();
+ test('Error after first end', () {
+ var controller = StreamController();
controller..add(7)..add(8)..add(9);
// Transformer that puts error into controller when one of the first two
// streams have sent a done event.
- StreamTransformer trans =
- StreamTransformer.fromHandlers(handleDone: (EventSink s) {
+ var trans = StreamTransformer.fromHandlers(handleDone: (EventSink s) {
Timer.run(() {
- controller.addError("BAD-6");
+ controller.addError('BAD-6');
});
s.close();
});
@@ -239,16 +238,16 @@
]);
});
- test("Pause/Resume", () {
- int sc1p = 0;
- StreamController c1 = StreamController(onPause: () {
+ test('Pause/Resume', () {
+ var sc1p = 0;
+ var c1 = StreamController(onPause: () {
sc1p++;
}, onResume: () {
sc1p--;
});
- int sc2p = 0;
- StreamController c2 = StreamController(onPause: () {
+ var sc2p = 0;
+ var c2 = StreamController(onPause: () {
sc2p++;
}, onResume: () {
sc2p--;
@@ -264,7 +263,7 @@
const ms25 = Duration(milliseconds: 25);
// StreamIterator uses pause and resume to control flow.
- StreamIterator it = StreamIterator(zip);
+ var it = StreamIterator(zip);
it.moveNext().then((hasMore) {
expect(hasMore, isTrue);
@@ -301,11 +300,11 @@
c2..add(2)..add(4);
});
- test("pause-resume2", () {
+ test('pause-resume2', () {
var s1 = Stream.fromIterable([0, 2, 4, 6, 8]);
var s2 = Stream.fromIterable([1, 3, 5, 7]);
var sz = StreamZip([s1, s2]);
- int ctr = 0;
+ var ctr = 0;
StreamSubscription sub;
sub = sz.listen(expectAsync1((v) {
expect(v, equals([ctr * 2, ctr * 2 + 1]));
diff --git a/test/stream_zip_zone_test.dart b/test/stream_zip_zone_test.dart
index c7756e6..68cd723 100644
--- a/test/stream_zip_zone_test.dart
+++ b/test/stream_zip_zone_test.dart
@@ -2,36 +2,37 @@
// for details. 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:test/test.dart";
+import 'dart:async';
+
+import 'package:test/test.dart';
// Test that stream listener callbacks all happen in the zone where the
// listen occurred.
-main() {
+void main() {
StreamController controller;
controller = StreamController();
- testStream("singlesub-async", controller, controller.stream);
+ testStream('singlesub-async', controller, controller.stream);
controller = StreamController.broadcast();
- testStream("broadcast-async", controller, controller.stream);
+ testStream('broadcast-async', controller, controller.stream);
controller = StreamController();
testStream(
- "asbroadcast-async", controller, controller.stream.asBroadcastStream());
+ 'asbroadcast-async', controller, controller.stream.asBroadcastStream());
controller = StreamController(sync: true);
- testStream("singlesub-sync", controller, controller.stream);
+ testStream('singlesub-sync', controller, controller.stream);
controller = StreamController.broadcast(sync: true);
- testStream("broadcast-sync", controller, controller.stream);
+ testStream('broadcast-sync', controller, controller.stream);
controller = StreamController(sync: true);
testStream(
- "asbroadcast-sync", controller, controller.stream.asBroadcastStream());
+ 'asbroadcast-sync', controller, controller.stream.asBroadcastStream());
}
void testStream(String name, StreamController controller, Stream stream) {
test(name, () {
- Zone outer = Zone.current;
+ var outer = Zone.current;
runZoned(() {
- Zone newZone1 = Zone.current;
+ var newZone1 = Zone.current;
StreamSubscription sub;
sub = stream.listen(expectAsync1((v) {
expect(v, 42);
diff --git a/test/subscription_stream_test.dart b/test/subscription_stream_test.dart
index 9460dec..0b24a02 100644
--- a/test/subscription_stream_test.dart
+++ b/test/subscription_stream_test.dart
@@ -2,15 +2,15 @@
// for details. 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 'dart:async';
-import "package:async/async.dart" show SubscriptionStream;
-import "package:test/test.dart";
+import 'package:async/async.dart' show SubscriptionStream;
+import 'package:test/test.dart';
-import "utils.dart";
+import 'utils.dart';
-main() {
- test("subscription stream of an entire subscription", () async {
+void main() {
+ test('subscription stream of an entire subscription', () async {
var stream = createStream();
var subscription = stream.listen(null);
var subscriptionStream = SubscriptionStream<int>(subscription);
@@ -18,7 +18,7 @@
expect(subscriptionStream.toList(), completion([1, 2, 3, 4]));
});
- test("subscription stream after two events", () async {
+ test('subscription stream after two events', () async {
var stream = createStream();
var skips = 0;
var completer = Completer();
@@ -35,7 +35,7 @@
expect(subscriptionStream.toList(), completion([3, 4]));
});
- test("listening twice fails", () async {
+ test('listening twice fails', () async {
var stream = createStream();
var sourceSubscription = stream.listen(null);
var subscriptionStream = SubscriptionStream<int>(sourceSubscription);
@@ -44,7 +44,7 @@
await subscription.cancel();
});
- test("pause and cancel passed through to original stream", () async {
+ test('pause and cancel passed through to original stream', () async {
var controller = StreamController(onCancel: () async => 42);
var sourceSubscription = controller.stream.listen(null);
var subscriptionStream = SubscriptionStream(sourceSubscription);
@@ -69,9 +69,9 @@
expect(controller.hasListener, isFalse);
});
- group("cancelOnError source:", () {
+ group('cancelOnError source:', () {
for (var sourceCancels in [false, true]) {
- group("${sourceCancels ? "yes" : "no"}:", () {
+ group('${sourceCancels ? "yes" : "no"}:', () {
SubscriptionStream subscriptionStream;
Future onCancel; // Completes if source stream is canceled before done.
setUp(() {
@@ -83,16 +83,16 @@
subscriptionStream = SubscriptionStream<int>(sourceSubscription);
});
- test("- subscriptionStream: no", () async {
+ test('- subscriptionStream: no', () async {
var done = Completer();
var events = [];
subscriptionStream.listen(events.add,
onError: events.add, onDone: done.complete, cancelOnError: false);
- var expected = [1, 2, "To err is divine!"];
+ var expected = [1, 2, 'To err is divine!'];
if (sourceCancels) {
await onCancel;
// And [done] won't complete at all.
- bool isDone = false;
+ var isDone = false;
done.future.then((_) {
isDone = true;
});
@@ -105,7 +105,7 @@
expect(events, expected);
});
- test("- subscriptionStream: yes", () async {
+ test('- subscriptionStream: yes', () async {
var completer = Completer();
var events = [];
subscriptionStream.listen(events.add,
@@ -113,18 +113,18 @@
events.add(value);
completer.complete();
},
- onDone: () => throw "should not happen",
+ onDone: () => throw 'should not happen',
cancelOnError: true);
await completer.future;
await flushMicrotasks();
- expect(events, [1, 2, "To err is divine!"]);
+ expect(events, [1, 2, 'To err is divine!']);
});
});
}
for (var cancelOnError in [false, true]) {
- group(cancelOnError ? "yes" : "no", () {
- test("- no error, value goes to asFuture", () async {
+ group(cancelOnError ? 'yes' : 'no', () {
+ test('- no error, value goes to asFuture', () async {
var stream = createStream();
var sourceSubscription =
stream.listen(null, cancelOnError: cancelOnError);
@@ -134,7 +134,7 @@
expect(subscription.asFuture(42), completion(42));
});
- test("- error goes to asFuture", () async {
+ test('- error goes to asFuture', () async {
var stream = createErrorStream();
var sourceSubscription =
stream.listen(null, cancelOnError: cancelOnError);
@@ -160,13 +160,13 @@
}
Stream<int> createErrorStream([Completer onCancel]) async* {
- bool canceled = true;
+ var canceled = true;
try {
yield 1;
await flushMicrotasks();
yield 2;
await flushMicrotasks();
- yield* Future<int>.error("To err is divine!").asStream();
+ yield* Future<int>.error('To err is divine!').asStream();
await flushMicrotasks();
yield 4;
await flushMicrotasks();
@@ -181,5 +181,7 @@
}
Stream<int> createLongStream() async* {
- for (int i = 0; i < 200; i++) yield i;
+ for (var i = 0; i < 200; i++) {
+ yield i;
+ }
}
diff --git a/test/subscription_transformer_test.dart b/test/subscription_transformer_test.dart
index 64f45ec..f0e3a70 100644
--- a/test/subscription_transformer_test.dart
+++ b/test/subscription_transformer_test.dart
@@ -10,8 +10,8 @@
import 'utils.dart';
void main() {
- group("with no callbacks", () {
- test("forwards cancellation", () async {
+ group('with no callbacks', () {
+ test('forwards cancellation', () async {
var isCanceled = false;
var cancelCompleter = Completer();
var controller = StreamController(onCancel: expectAsync0(() {
@@ -39,7 +39,7 @@
expect(subscription.cancel(), completes);
});
- test("forwards pausing and resuming", () async {
+ test('forwards pausing and resuming', () async {
var controller = StreamController();
var subscription = controller.stream
.transform(subscriptionTransformer())
@@ -62,7 +62,7 @@
expect(controller.isPaused, isFalse);
});
- test("forwards pausing with a resume future", () async {
+ test('forwards pausing with a resume future', () async {
var controller = StreamController();
var subscription = controller.stream
.transform(subscriptionTransformer())
@@ -79,8 +79,8 @@
});
});
- group("with a cancel callback", () {
- test("invokes the callback when the subscription is canceled", () async {
+ group('with a cancel callback', () {
+ test('invokes the callback when the subscription is canceled', () async {
var isCanceled = false;
var callbackInvoked = false;
var controller = StreamController(onCancel: expectAsync0(() {
@@ -103,7 +103,7 @@
expect(isCanceled, isTrue);
});
- test("invokes the callback once and caches its result", () async {
+ test('invokes the callback once and caches its result', () async {
var completer = Completer();
var controller = StreamController();
var subscription = controller.stream
@@ -132,8 +132,8 @@
});
});
- group("with a pause callback", () {
- test("invokes the callback when pause is called", () async {
+ group('with a pause callback', () {
+ test('invokes the callback when pause is called', () async {
var pauseCount = 0;
var controller = StreamController();
var subscription = controller.stream
@@ -180,8 +180,8 @@
});
});
- group("with a resume callback", () {
- test("invokes the callback when resume is called", () async {
+ group('with a resume callback', () {
+ test('invokes the callback when resume is called', () async {
var resumeCount = 0;
var controller = StreamController();
var subscription = controller.stream
@@ -213,7 +213,7 @@
expect(resumeCount, equals(3));
});
- test("invokes the callback when a resume future completes", () async {
+ test('invokes the callback when a resume future completes', () async {
var resumed = false;
var controller = StreamController();
var subscription = controller.stream.transform(
@@ -247,7 +247,7 @@
});
});
- group("when the outer subscription is canceled but the inner is not", () {
+ group('when the outer subscription is canceled but the inner is not', () {
StreamSubscription subscription;
setUp(() {
var controller = StreamController();
@@ -258,7 +258,7 @@
onDone: expectAsync0(() {}, count: 0));
subscription.cancel();
controller.add(1);
- controller.addError("oh no!");
+ controller.addError('oh no!');
controller.close();
});
@@ -277,11 +277,11 @@
await flushMicrotasks();
});
- test("isPaused returns false", () {
+ test('isPaused returns false', () {
expect(subscription.isPaused, isFalse);
});
- test("asFuture never completes", () async {
+ test('asFuture never completes', () async {
subscription.asFuture().then(expectAsync1((_) {}, count: 0));
await flushMicrotasks();
});
diff --git a/test/typed_wrapper/stream_subscription_test.dart b/test/typed_wrapper/stream_subscription_test.dart
index bbec8f7..2a11546 100644
--- a/test/typed_wrapper/stream_subscription_test.dart
+++ b/test/typed_wrapper/stream_subscription_test.dart
@@ -4,13 +4,13 @@
import 'dart:async';
-import "package:async/src/typed/stream_subscription.dart";
-import "package:test/test.dart";
+import 'package:async/src/typed/stream_subscription.dart';
+import 'package:test/test.dart';
import '../utils.dart';
void main() {
- group("with valid types, forwards", () {
+ group('with valid types, forwards', () {
StreamController controller;
StreamSubscription wrapper;
bool isCanceled;
@@ -21,26 +21,26 @@
wrapper = TypeSafeStreamSubscription<int>(controller.stream.listen(null));
});
- test("onData()", () {
+ test('onData()', () {
wrapper.onData(expectAsync1((data) {
expect(data, equals(1));
}));
controller.add(1);
});
- test("onError()", () {
+ test('onError()', () {
wrapper.onError(expectAsync1((error) {
- expect(error, equals("oh no"));
+ expect(error, equals('oh no'));
}));
- controller.addError("oh no");
+ controller.addError('oh no');
});
- test("onDone()", () {
+ test('onDone()', () {
wrapper.onDone(expectAsync0(() {}));
controller.close();
});
- test("pause(), resume(), and isPaused", () async {
+ test('pause(), resume(), and isPaused', () async {
expect(wrapper.isPaused, isFalse);
wrapper.pause();
@@ -54,19 +54,19 @@
expect(wrapper.isPaused, isFalse);
});
- test("cancel()", () async {
+ test('cancel()', () async {
wrapper.cancel();
await flushMicrotasks();
expect(isCanceled, isTrue);
});
- test("asFuture()", () {
+ test('asFuture()', () {
expect(wrapper.asFuture(12), completion(equals(12)));
controller.close();
});
});
- group("with invalid types,", () {
+ group('with invalid types,', () {
StreamController controller;
StreamSubscription wrapper;
bool isCanceled;
@@ -77,8 +77,8 @@
wrapper = TypeSafeStreamSubscription<int>(controller.stream.listen(null));
});
- group("throws a CastError for", () {
- test("onData()", () {
+ group('throws a CastError for', () {
+ test('onData()', () {
expect(() {
// TODO(nweiz): Use the wrapper declared in setUp when sdk#26226 is
// fixed.
@@ -87,28 +87,28 @@
TypeSafeStreamSubscription<int>(controller.stream.listen(null));
wrapper.onData(expectAsync1((_) {}, count: 0));
- controller.add("foo");
+ controller.add('foo');
}, throwsZonedCastError);
});
});
group("doesn't throw a CastError for", () {
- test("onError()", () {
+ test('onError()', () {
wrapper.onError(expectAsync1((error) {
- expect(error, equals("oh no"));
+ expect(error, equals('oh no'));
}));
- controller.add("foo");
- controller.addError("oh no");
+ controller.add('foo');
+ controller.addError('oh no');
});
- test("onDone()", () {
+ test('onDone()', () {
wrapper.onDone(expectAsync0(() {}));
- controller.add("foo");
+ controller.add('foo');
controller.close();
});
- test("pause(), resume(), and isPaused", () async {
- controller.add("foo");
+ test('pause(), resume(), and isPaused', () async {
+ controller.add('foo');
expect(wrapper.isPaused, isFalse);
@@ -123,17 +123,17 @@
expect(wrapper.isPaused, isFalse);
});
- test("cancel()", () async {
- controller.add("foo");
+ test('cancel()', () async {
+ controller.add('foo');
wrapper.cancel();
await flushMicrotasks();
expect(isCanceled, isTrue);
});
- test("asFuture()", () {
+ test('asFuture()', () {
expect(wrapper.asFuture(12), completion(equals(12)));
- controller.add("foo");
+ controller.add('foo');
controller.close();
});
});
diff --git a/test/utils.dart b/test/utils.dart
index e517c78..b09d06b 100644
--- a/test/utils.dart
+++ b/test/utils.dart
@@ -3,10 +3,10 @@
// BSD-style license that can be found in the LICENSE file.
/// Helper utilities for testing.
-import "dart:async";
+import 'dart:async';
-import "package:async/async.dart";
-import "package:test/test.dart";
+import 'package:async/async.dart';
+import 'package:test/test.dart';
/// A zero-millisecond timer should wait until after all microtasks.
Future flushMicrotasks() => Future.delayed(Duration.zero);
@@ -17,7 +17,7 @@
///
/// Returns a function that fails the test if it is ever called.
OptionalArgAction unreachable(String name) =>
- ([a, b]) => fail("Unreachable: $name");
+ ([a, b]) => fail('Unreachable: $name');
// TODO(nweiz): Use the version of this in test when test#418 is fixed.
/// A matcher that runs a callback in its own zone and asserts that that zone
@@ -46,9 +46,10 @@
/// A badly behaved stream which throws if it's ever listened to.
///
/// Can be used to test cases where a stream should not be used.
-class UnusableStream extends Stream {
- listen(onData, {onError, onDone, cancelOnError}) {
- throw UnimplementedError("Gotcha!");
+class UnusableStream<T> extends Stream<T> {
+ @override
+ StreamSubscription<T> listen(onData, {onError, onDone, cancelOnError}) {
+ throw UnimplementedError('Gotcha!');
}
}
@@ -60,11 +61,16 @@
class CompleterStreamSink<T> implements StreamSink<T> {
final completer = Completer();
+ @override
Future get done => completer.future;
+ @override
void add(T event) {}
+ @override
void addError(error, [StackTrace stackTrace]) {}
+ @override
Future addStream(Stream<T> stream) async {}
+ @override
Future close() => completer.future;
}
@@ -79,6 +85,7 @@
bool get isClosed => _isClosed;
var _isClosed = false;
+ @override
Future get done => _doneCompleter.future;
final _doneCompleter = Completer();
@@ -88,22 +95,26 @@
///
/// If [onDone] is passed, it's called when the user calls [close]. Its result
/// is piped to the [done] future.
- TestSink({onDone()}) : _onDone = onDone ?? (() {});
+ TestSink({void Function() onDone}) : _onDone = onDone ?? (() {});
+ @override
void add(T event) {
results.add(Result<T>.value(event));
}
+ @override
void addError(error, [StackTrace stackTrace]) {
results.add(Result<T>.error(error, stackTrace));
}
+ @override
Future addStream(Stream<T> stream) {
var completer = Completer.sync();
stream.listen(add, onError: addError, onDone: completer.complete);
return completer.future;
}
+ @override
Future close() {
_isClosed = true;
_doneCompleter.complete(Future.microtask(_onDone));
