Run dartfmt --fix to drop unnecessary new/const (#74)
Bump minimum SDK version in pubspec to 2.0.0
diff --git a/analysis_options.yaml b/analysis_options.yaml
index 24a615c..82ef545 100644
--- a/analysis_options.yaml
+++ b/analysis_options.yaml
@@ -4,3 +4,5 @@
linter:
rules:
- prefer_typing_uninitialized_variables
+ - unnecessary_new
+ - unnecessary_const
diff --git a/lib/src/async_cache.dart b/lib/src/async_cache.dart
index 53084ca..6bd34bd 100644
--- a/lib/src/async_cache.dart
+++ b/lib/src/async_cache.dart
@@ -49,7 +49,7 @@
/// An ephemeral cache guarantees that a callback function will only be
/// executed at most once concurrently. This is useful for requests for which
/// data is updated frequently but stale data is acceptable.
- factory AsyncCache.ephemeral() => new AsyncCache(Duration.zero);
+ factory AsyncCache.ephemeral() => AsyncCache(Duration.zero);
/// Returns a cached value from a previous call to [fetch], or runs [callback]
/// to compute a new one.
@@ -58,7 +58,7 @@
/// value. Otherwise, runs [callback] and returns its new return value.
Future<T> fetch(Future<T> callback()) async {
if (_cachedStreamSplitter != null) {
- throw new StateError('Previously used to cache via `fetchStream`');
+ throw StateError('Previously used to cache via `fetchStream`');
}
if (_cachedValueFuture == null) {
_cachedValueFuture = callback();
@@ -76,11 +76,11 @@
/// return value.
Stream<T> fetchStream(Stream<T> callback()) {
if (_cachedValueFuture != null) {
- throw new StateError('Previously used to cache via `fetch`');
+ throw StateError('Previously used to cache via `fetch`');
}
if (_cachedStreamSplitter == null) {
- _cachedStreamSplitter = new StreamSplitter(callback()
- .transform(new StreamTransformer.fromHandlers(handleDone: (sink) {
+ _cachedStreamSplitter = StreamSplitter(callback()
+ .transform(StreamTransformer.fromHandlers(handleDone: (sink) {
_startStaleTimer();
sink.close();
})));
@@ -100,6 +100,6 @@
}
void _startStaleTimer() {
- _stale = new Timer(_duration, invalidate);
+ _stale = Timer(_duration, invalidate);
}
}
diff --git a/lib/src/async_memoizer.dart b/lib/src/async_memoizer.dart
index d1c0f32..5e83400 100644
--- a/lib/src/async_memoizer.dart
+++ b/lib/src/async_memoizer.dart
@@ -31,7 +31,7 @@
///
/// This can be accessed at any time, and will fire once [runOnce] is called.
Future<T> get future => _completer.future;
- final _completer = new Completer<T>();
+ final _completer = Completer<T>();
/// Whether [runOnce] has been called yet.
bool get hasRun => _completer.isCompleted;
@@ -40,7 +40,7 @@
///
/// If [runOnce] has already been called, this returns the original result.
Future<T> runOnce(FutureOr<T> computation()) {
- if (!hasRun) _completer.complete(new Future.sync(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 3c1d49d..f01cc2a 100644
--- a/lib/src/byte_collector.dart
+++ b/lib/src/byte_collector.dart
@@ -31,7 +31,7 @@
Stream<List<int>> source) {
return _collectBytes(
source,
- (subscription, result) => new CancelableOperation.fromFuture(result,
+ (subscription, result) => CancelableOperation.fromFuture(result,
onCancel: subscription.cancel));
}
@@ -46,7 +46,7 @@
StreamSubscription<List<int>> subscription, Future<Uint8List> result)) {
var byteLists = <List<int>>[];
var length = 0;
- var completer = new Completer<Uint8List>.sync();
+ var completer = Completer<Uint8List>.sync();
var subscription = source.listen(
(bytes) {
byteLists.add(bytes);
@@ -62,7 +62,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 = new Uint8List(length);
+ var result = Uint8List(length);
int i = 0;
for (var byteList in byteLists) {
var end = i + byteList.length;
diff --git a/lib/src/cancelable_operation.dart b/lib/src/cancelable_operation.dart
index 0e010da..e6115cb 100644
--- a/lib/src/cancelable_operation.dart
+++ b/lib/src/cancelable_operation.dart
@@ -31,7 +31,7 @@
/// It's guaranteed to only be called once.
factory CancelableOperation.fromFuture(Future<T> inner,
{FutureOr onCancel()}) {
- var completer = new CancelableCompleter<T>(onCancel: onCancel);
+ var completer = CancelableCompleter<T>(onCancel: onCancel);
completer.complete(inner);
return completer.operation;
}
@@ -45,7 +45,7 @@
/// canceled, this is as well.
Stream<T> asStream() {
var controller =
- new StreamController<T>(sync: true, onCancel: _completer._cancel);
+ StreamController<T>(sync: true, onCancel: _completer._cancel);
value.then((value) {
controller.add(value);
@@ -64,7 +64,7 @@
/// If this operation is cancelled, the returned future waits for the future
/// returned by [cancel], then completes to [cancellationValue].
Future<T> valueOrCancellation([T cancellationValue]) {
- var completer = new Completer<T>.sync();
+ var completer = Completer<T>.sync();
value.then((result) => completer.complete(result),
onError: completer.completeError);
@@ -100,8 +100,8 @@
/// It's guaranteed to only be called once.
CancelableCompleter({FutureOr onCancel()})
: _onCancel = onCancel,
- _inner = new Completer<T>() {
- _operation = new CancelableOperation<T>._(this);
+ _inner = Completer<T>() {
+ _operation = CancelableOperation<T>._(this);
}
/// The operation controlled by this completer.
@@ -117,14 +117,14 @@
bool _isCanceled = false;
/// The memoizer for [_cancel].
- final _cancelMemo = new AsyncMemoizer();
+ final _cancelMemo = AsyncMemoizer();
/// Completes [operation] to [value].
///
/// If [value] is a [Future], this will complete to the result of that
/// [Future] once it completes.
void complete([value]) {
- if (_isCompleted) throw new StateError("Operation already completed");
+ if (_isCompleted) throw StateError("Operation already completed");
_isCompleted = true;
if (value is! Future) {
@@ -150,7 +150,7 @@
/// Completes [operation] to [error].
void completeError(Object error, [StackTrace stackTrace]) {
- if (_isCompleted) throw new StateError("Operation already completed");
+ if (_isCompleted) throw StateError("Operation already completed");
_isCompleted = true;
if (_isCanceled) return;
@@ -159,7 +159,7 @@
/// Cancel the completer.
Future _cancel() {
- if (_inner.isCompleted) return new Future.value();
+ if (_inner.isCompleted) return Future.value();
return _cancelMemo.runOnce(() {
_isCanceled = true;
diff --git a/lib/src/delegate/event_sink.dart b/lib/src/delegate/event_sink.dart
index 54c3e52..95d7841 100644
--- a/lib/src/delegate/event_sink.dart
+++ b/lib/src/delegate/event_sink.dart
@@ -23,7 +23,7 @@
/// [add] may throw a [CastError] if the argument type doesn't match the
/// reified type of [sink].
static EventSink<T> typed<T>(EventSink sink) =>
- sink is EventSink<T> ? sink : new DelegatingEventSink._(sink);
+ sink is EventSink<T> ? sink : DelegatingEventSink._(sink);
void add(T data) {
_sink.add(data);
diff --git a/lib/src/delegate/sink.dart b/lib/src/delegate/sink.dart
index 7c68a0f..b8ba76d 100644
--- a/lib/src/delegate/sink.dart
+++ b/lib/src/delegate/sink.dart
@@ -21,7 +21,7 @@
/// throw a [CastError] if the argument type doesn't match the reified type of
/// [sink].
static Sink<T> typed<T>(Sink sink) =>
- sink is Sink<T> ? sink : new DelegatingSink._(sink);
+ sink is Sink<T> ? sink : DelegatingSink._(sink);
void add(T data) {
_sink.add(data);
diff --git a/lib/src/delegate/stream_consumer.dart b/lib/src/delegate/stream_consumer.dart
index ba83040..ad53182 100644
--- a/lib/src/delegate/stream_consumer.dart
+++ b/lib/src/delegate/stream_consumer.dart
@@ -25,7 +25,7 @@
static StreamConsumer<T> typed<T>(StreamConsumer consumer) =>
consumer is StreamConsumer<T>
? consumer
- : new DelegatingStreamConsumer._(consumer);
+ : DelegatingStreamConsumer._(consumer);
Future addStream(Stream<T> stream) => _consumer.addStream(stream);
diff --git a/lib/src/delegate/stream_sink.dart b/lib/src/delegate/stream_sink.dart
index 198df8a..67eb33c 100644
--- a/lib/src/delegate/stream_sink.dart
+++ b/lib/src/delegate/stream_sink.dart
@@ -25,7 +25,7 @@
/// throw a [CastError] if the argument type doesn't match the reified type of
/// [sink].
static StreamSink<T> typed<T>(StreamSink sink) =>
- sink is StreamSink<T> ? sink : new DelegatingStreamSink._(sink);
+ sink is StreamSink<T> ? sink : DelegatingStreamSink._(sink);
void add(T data) {
_sink.add(data);
diff --git a/lib/src/delegate/stream_subscription.dart b/lib/src/delegate/stream_subscription.dart
index 6bef924..07af08e 100644
--- a/lib/src/delegate/stream_subscription.dart
+++ b/lib/src/delegate/stream_subscription.dart
@@ -26,7 +26,7 @@
static StreamSubscription<T> typed<T>(StreamSubscription subscription) =>
subscription is StreamSubscription<T>
? subscription
- : new TypeSafeStreamSubscription<T>(subscription);
+ : TypeSafeStreamSubscription<T>(subscription);
void onData(void handleData(T data)) {
_source.onData(handleData);
diff --git a/lib/src/future_group.dart b/lib/src/future_group.dart
index 0bf3158..7e17494 100644
--- a/lib/src/future_group.dart
+++ b/lib/src/future_group.dart
@@ -31,7 +31,7 @@
/// This will also complete with an error if any of the futures in the group
/// fails, regardless of whether [close] was called.
Future<List<T>> get future => _completer.future;
- final _completer = new Completer<List<T>>();
+ final _completer = Completer<List<T>>();
/// Whether this group has no pending futures.
bool get isIdle => _pending == 0;
@@ -43,7 +43,7 @@
/// called, this stream will close.
Stream get onIdle {
if (_onIdleController == null) {
- _onIdleController = new StreamController.broadcast(sync: true);
+ _onIdleController = StreamController.broadcast(sync: true);
}
return _onIdleController.stream;
}
@@ -54,11 +54,11 @@
/// the order they were added.
///
/// The slots for futures that haven't completed yet are `null`.
- final _values = new List<T>();
+ final _values = List<T>();
/// Wait for [task] to complete.
void add(Future<T> task) {
- if (_closed) throw new 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
diff --git a/lib/src/lazy_stream.dart b/lib/src/lazy_stream.dart
index f07c387..278957a 100644
--- a/lib/src/lazy_stream.dart
+++ b/lib/src/lazy_stream.dart
@@ -22,13 +22,13 @@
/// a listener and forwards to the returned stream.
LazyStream(FutureOr<Stream<T>> callback()) : _callback = callback {
// Explicitly check for null because we null out [_callback] internally.
- if (_callback == null) throw new ArgumentError.notNull('callback');
+ if (_callback == null) throw ArgumentError.notNull('callback');
}
StreamSubscription<T> listen(void onData(T event),
{Function onError, void onDone(), bool cancelOnError}) {
if (_callback == null) {
- throw new 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 c83790c..c9d3d5d 100644
--- a/lib/src/null_stream_sink.dart
+++ b/lib/src/null_stream_sink.dart
@@ -42,13 +42,13 @@
///
/// If [done] is passed, it's used as the [Sink.done] future. Otherwise, a
/// completed future is used.
- NullStreamSink({Future done}) : done = done ?? new Future.value();
+ NullStreamSink({Future done}) : done = done ?? Future.value();
/// Creates a null sink whose [done] future emits [error].
///
/// Note that this error will not be considered uncaught.
NullStreamSink.error(error, [StackTrace stackTrace])
- : done = new Future.error(error, stackTrace)
+ : done = Future.error(error, stackTrace)
// Don't top-level the error. This gives the user a change to call
// [close] or [done], and matches the behavior of a remote endpoint
// experiencing an error.
@@ -66,7 +66,7 @@
_checkEventAllowed();
_addingStream = true;
- var future = stream.listen(null).cancel() ?? new Future.value();
+ var future = stream.listen(null).cancel() ?? Future.value();
return future.whenComplete(() {
_addingStream = false;
});
@@ -75,9 +75,9 @@
/// Throws a [StateError] if [close] has been called or an [addStream] call is
/// pending.
void _checkEventAllowed() {
- if (_closed) throw new StateError("Cannot add to a closed sink.");
+ if (_closed) throw StateError("Cannot add to a closed sink.");
if (_addingStream) {
- throw new StateError("Cannot add to a sink while adding a stream.");
+ throw StateError("Cannot add to a sink while adding a stream.");
}
}
diff --git a/lib/src/restartable_timer.dart b/lib/src/restartable_timer.dart
index 7b05821..b8e414a 100644
--- a/lib/src/restartable_timer.dart
+++ b/lib/src/restartable_timer.dart
@@ -26,7 +26,7 @@
/// The [callback] function is invoked after the given [duration]. Unlike a
/// normal non-periodic [Timer], [callback] may be called more than once.
RestartableTimer(this._duration, this._callback) {
- _timer = new Timer(_duration, _callback);
+ _timer = Timer(_duration, _callback);
}
bool get isActive => _timer.isActive;
@@ -37,7 +37,7 @@
/// This restarts the timer even if it has already fired or has been canceled.
void reset() {
_timer.cancel();
- _timer = new Timer(_duration, _callback);
+ _timer = Timer(_duration, _callback);
}
void cancel() {
@@ -49,6 +49,6 @@
// See https://github.com/dart-lang/sdk/issues/31664
// ignore: override_on_non_overriding_getter
int get tick {
- throw new UnimplementedError("tick");
+ throw UnimplementedError("tick");
}
}
diff --git a/lib/src/result/capture_sink.dart b/lib/src/result/capture_sink.dart
index 742c160..0477a19 100644
--- a/lib/src/result/capture_sink.dart
+++ b/lib/src/result/capture_sink.dart
@@ -13,11 +13,11 @@
CaptureSink(EventSink<Result<T>> sink) : _sink = sink;
void add(T value) {
- _sink.add(new Result<T>.value(value));
+ _sink.add(Result<T>.value(value));
}
void addError(Object error, [StackTrace stackTrace]) {
- _sink.add(new Result.error(error, stackTrace));
+ _sink.add(Result.error(error, stackTrace));
}
void close() {
diff --git a/lib/src/result/capture_transformer.dart b/lib/src/result/capture_transformer.dart
index b9a538a..a727a8e 100644
--- a/lib/src/result/capture_transformer.dart
+++ b/lib/src/result/capture_transformer.dart
@@ -15,6 +15,6 @@
const CaptureStreamTransformer();
Stream<Result<T>> bind(Stream<T> source) =>
- new Stream<Result<T>>.eventTransformed(
- source, (sink) => new CaptureSink<T>(sink));
+ Stream<Result<T>>.eventTransformed(
+ source, (sink) => CaptureSink<T>(sink));
}
diff --git a/lib/src/result/error.dart b/lib/src/result/error.dart
index 2feb2c2..8f29d13 100644
--- a/lib/src/result/error.dart
+++ b/lib/src/result/error.dart
@@ -30,7 +30,7 @@
sink.addError(error, stackTrace);
}
- Future<Null> get asFuture => new Future<Null>.error(error, stackTrace);
+ Future<Null> get asFuture => Future<Null>.error(error, stackTrace);
/// Calls an error handler with the error and stacktrace.
///
diff --git a/lib/src/result/release_transformer.dart b/lib/src/result/release_transformer.dart
index 01865cc..1aead30 100644
--- a/lib/src/result/release_transformer.dart
+++ b/lib/src/result/release_transformer.dart
@@ -12,9 +12,9 @@
const ReleaseStreamTransformer();
Stream<T> bind(Stream<Result<T>> source) {
- return new Stream<T>.eventTransformed(source, _createSink);
+ return Stream<T>.eventTransformed(source, _createSink);
}
// Since Stream.eventTransformed is not generic, this method can be static.
- static EventSink<Result> _createSink(EventSink sink) => new ReleaseSink(sink);
+ static EventSink<Result> _createSink(EventSink sink) => ReleaseSink(sink);
}
diff --git a/lib/src/result/result.dart b/lib/src/result/result.dart
index 25503b5..28799fa 100644
--- a/lib/src/result/result.dart
+++ b/lib/src/result/result.dart
@@ -28,14 +28,14 @@
/// The result of the transformation is a stream of [Result] values and no
/// error events. This is the transformer used by [captureStream].
static const StreamTransformer<Object, Result<Object>>
- captureStreamTransformer = const CaptureStreamTransformer<Object>();
+ captureStreamTransformer = CaptureStreamTransformer<Object>();
/// A stream transformer that releases a stream of result events.
///
/// The result of the transformation is a stream of values and error events.
/// This is the transformer used by [releaseStream].
static const StreamTransformer<Result<Object>, Object>
- releaseStreamTransformer = const ReleaseStreamTransformer<Object>();
+ releaseStreamTransformer = ReleaseStreamTransformer<Object>();
/// A sink transformer that captures events into [Result]s.
///
@@ -43,8 +43,8 @@
/// values and no error events.
static const StreamSinkTransformer<Object, Result<Object>>
captureSinkTransformer =
- const StreamSinkTransformer<Object, Result<Object>>.fromStreamTransformer(
- const CaptureStreamTransformer<Object>());
+ StreamSinkTransformer<Object, Result<Object>>.fromStreamTransformer(
+ CaptureStreamTransformer<Object>());
/// A sink transformer that releases result events.
///
@@ -52,8 +52,8 @@
/// error events.
static const StreamSinkTransformer<Result<Object>, Object>
releaseSinkTransformer =
- const StreamSinkTransformer<Result<Object>, Object>.fromStreamTransformer(
- const ReleaseStreamTransformer<Object>());
+ StreamSinkTransformer<Result<Object>, Object>.fromStreamTransformer(
+ ReleaseStreamTransformer<Object>());
/// Creates a `Result` with the result of calling [computation].
///
@@ -62,9 +62,9 @@
/// the call.
factory Result(T computation()) {
try {
- return new ValueResult<T>(computation());
+ return ValueResult<T>(computation());
} catch (e, s) {
- return new ErrorResult(e, s);
+ return ErrorResult(e, s);
}
}
@@ -77,15 +77,15 @@
///
/// Alias for [ErrorResult.ErrorResult].
factory Result.error(Object error, [StackTrace stackTrace]) =>
- new ErrorResult(error, stackTrace);
+ ErrorResult(error, stackTrace);
/// Captures the result of a future into a `Result` future.
///
/// The resulting future will never have an error.
/// Errors have been converted to an [ErrorResult] value.
static Future<Result<T>> capture<T>(Future<T> future) {
- return future.then((value) => new ValueResult(value),
- onError: (error, stackTrace) => new ErrorResult(error, stackTrace));
+ return future.then((value) => ValueResult(value),
+ onError: (error, stackTrace) => ErrorResult(error, stackTrace));
}
/// Captures each future in [elements],
@@ -111,13 +111,13 @@
}
});
} else {
- results.add(new Result<T>.value(element));
+ results.add(Result<T>.value(element));
}
}
if (pending == 0) {
- return new Future<List<Result<T>>>.value(results);
+ return Future<List<Result<T>>>.value(results);
}
- completer = new Completer<List<Result<T>>>();
+ completer = Completer<List<Result<T>>>();
return completer.future;
}
@@ -136,7 +136,7 @@
/// The returned stream will not have any error events.
/// Errors from the source stream have been converted to [ErrorResult]s.
static Stream<Result<T>> captureStream<T>(Stream<T> source) =>
- source.transform(new CaptureStreamTransformer<T>());
+ source.transform(CaptureStreamTransformer<T>());
/// Releases a stream of [result] values into a stream of the results.
///
@@ -144,7 +144,7 @@
/// the returned stream as appropriate.
/// Errors from the source stream become errors in the returned stream.
static Stream<T> releaseStream<T>(Stream<Result<T>> source) =>
- source.transform(new ReleaseStreamTransformer<T>());
+ source.transform(ReleaseStreamTransformer<T>());
/// Releases results added to the returned sink as data and errors on [sink].
///
@@ -152,7 +152,7 @@
/// on [sink]. Errors added to the returned sink are forwarded directly to
/// [sink] and so is the [EventSink.close] calls.
static EventSink<Result<T>> releaseSink<T>(EventSink<T> sink) =>
- new ReleaseSink<T>(sink);
+ ReleaseSink<T>(sink);
/// Captures the events of the returned sink into results on [sink].
///
@@ -162,7 +162,7 @@
///
/// When the returned sink is closed, so is [sink].
static EventSink<T> captureSink<T>(EventSink<Result<T>> sink) =>
- new CaptureSink<T>(sink);
+ CaptureSink<T>(sink);
/// Converts a result of a result to a single result.
///
@@ -188,7 +188,7 @@
return result.asError;
}
}
- return new Result<List<T>>.value(values);
+ return Result<List<T>>.value(values);
}
/// Whether this result is a value result.
diff --git a/lib/src/result/value.dart b/lib/src/result/value.dart
index edc41fb..dddc9fe 100644
--- a/lib/src/result/value.dart
+++ b/lib/src/result/value.dart
@@ -27,7 +27,7 @@
sink.add(value);
}
- Future<T> get asFuture => new Future.value(value);
+ Future<T> get asFuture => Future.value(value);
int get hashCode => value.hashCode ^ 0x323f1d61;
diff --git a/lib/src/single_subscription_transformer.dart b/lib/src/single_subscription_transformer.dart
index ff17189..8007a42 100644
--- a/lib/src/single_subscription_transformer.dart
+++ b/lib/src/single_subscription_transformer.dart
@@ -18,8 +18,8 @@
Stream<T> bind(Stream<S> stream) {
StreamSubscription<S> subscription;
- var controller = new StreamController<T>(
- sync: true, onCancel: () => subscription.cancel());
+ var controller =
+ StreamController<T>(sync: true, onCancel: () => subscription.cancel());
subscription = stream.listen((value) {
// TODO(nweiz): When we release a new major version, get rid of the second
// type parameter and avoid this conversion.
diff --git a/lib/src/stream_completer.dart b/lib/src/stream_completer.dart
index 4311de5..bbb2155 100644
--- a/lib/src/stream_completer.dart
+++ b/lib/src/stream_completer.dart
@@ -24,7 +24,7 @@
/// the listen is performed directly on the source stream.
class StreamCompleter<T> {
/// The stream doing the actual work, is returned by [stream].
- final _stream = new _CompleterStream<T>();
+ final _stream = _CompleterStream<T>();
/// Convert a `Future<Stream>` to a `Stream`.
///
@@ -35,7 +35,7 @@
/// If the future completes with an error, the returned stream will
/// instead contain just that error.
static Stream<T> fromFuture<T>(Future<Stream<T>> streamFuture) {
- var completer = new StreamCompleter<T>();
+ var completer = StreamCompleter<T>();
streamFuture.then(completer.setSourceStream, onError: completer.setError);
return completer.stream;
}
@@ -75,7 +75,7 @@
/// most once. Trying to call any of them again will fail.
void setSourceStream(Stream<T> sourceStream) {
if (_stream._isSourceStreamSet) {
- throw new 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 new StateError("Source stream already set");
+ throw StateError("Source stream already set");
}
_stream._setEmpty();
}
@@ -98,7 +98,7 @@
/// Any one of [setSourceStream], [setEmpty], and [setError] may be called at
/// most once. Trying to call any of them again will fail.
void setError(error, [StackTrace stackTrace]) {
- setSourceStream(new Stream.fromFuture(new Future.error(error, stackTrace)));
+ setSourceStream(Stream.fromFuture(Future.error(error, stackTrace)));
}
}
@@ -179,6 +179,6 @@
// Creates the [_controller].
void _createController() {
assert(_controller == null);
- _controller = new StreamController<T>(sync: true);
+ _controller = StreamController<T>(sync: true);
}
}
diff --git a/lib/src/stream_group.dart b/lib/src/stream_group.dart
index 6361a5c..d647ce3 100644
--- a/lib/src/stream_group.dart
+++ b/lib/src/stream_group.dart
@@ -47,14 +47,14 @@
/// 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 = new Map<Stream<T>, StreamSubscription<T>>();
+ final _subscriptions = Map<Stream<T>, StreamSubscription<T>>();
/// Merges the events from [streams] into a single (single-subscriber) stream.
///
/// This is equivalent to adding [streams] to a group, closing that group, and
/// returning its stream.
static Stream<T> merge<T>(Iterable<Stream<T>> streams) {
- var group = new StreamGroup<T>();
+ var group = StreamGroup<T>();
streams.forEach(group.add);
group.close();
return group.stream;
@@ -62,7 +62,7 @@
/// Creates a new stream group where [stream] is single-subscriber.
StreamGroup() {
- _controller = new StreamController<T>(
+ _controller = StreamController<T>(
onListen: _onListen,
onPause: _onPause,
onResume: _onResume,
@@ -72,7 +72,7 @@
/// Creates a new stream group where [stream] is a broadcast stream.
StreamGroup.broadcast() {
- _controller = new StreamController<T>.broadcast(
+ _controller = StreamController<T>.broadcast(
onListen: _onListen, onCancel: _onCancelBroadcast, sync: true);
}
@@ -90,7 +90,7 @@
/// Throws a [StateError] if this group is closed.
Future add(Stream<T> stream) {
if (_closed) {
- throw new StateError("Can't add a Stream to a closed StreamGroup.");
+ throw StateError("Can't add a Stream to a closed StreamGroup.");
}
if (_state == _StreamGroupState.dormant) {
@@ -219,12 +219,12 @@
///
/// New streams added to the group will be listened once the group has a
/// listener.
- static const dormant = const _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 = const _StreamGroupState("listening");
+ static const listening = _StreamGroupState("listening");
/// The group is paused and no more events will be fired until it resumes.
///
@@ -232,7 +232,7 @@
/// will be resumed once the group itself is resumed.
///
/// This state is only used by single-subscriber groups.
- static const paused = const _StreamGroupState("paused");
+ static const paused = _StreamGroupState("paused");
/// The group is canceled and no more events will be fired ever.
///
@@ -240,7 +240,7 @@
/// discarded.
///
/// This state is only used by single-subscriber groups.
- static const canceled = const _StreamGroupState("canceled");
+ static const canceled = _StreamGroupState("canceled");
/// The name of the state.
///
diff --git a/lib/src/stream_queue.dart b/lib/src/stream_queue.dart
index 61a1654..fd3186e 100644
--- a/lib/src/stream_queue.dart
+++ b/lib/src/stream_queue.dart
@@ -44,7 +44,7 @@
///
/// Example:
///
-/// var events = new StreamQueue<String>(someStreamOfLines);
+/// var events = StreamQueue<String>(someStreamOfLines);
/// var first = await events.next;
/// while (first.startsWith('#')) {
/// // Skip comments.
@@ -107,12 +107,12 @@
var _eventsReceived = 0;
/// Queue of events not used by a request yet.
- final QueueList<Result<T>> _eventQueue = new QueueList();
+ final QueueList<Result<T>> _eventQueue = QueueList();
/// Queue of pending requests.
///
/// Access through methods below to ensure consistency.
- final Queue<_EventRequest> _requestQueue = new Queue();
+ final Queue<_EventRequest> _requestQueue = Queue();
/// Create a `StreamQueue` of the events of [source].
factory StreamQueue(Stream<T> source) => StreamQueue._(source);
@@ -133,7 +133,7 @@
/// one events.
Future<bool> get hasNext {
if (!_isClosed) {
- var hasNextRequest = new _HasNextRequest<T>();
+ var hasNextRequest = _HasNextRequest<T>();
_addRequest(hasNextRequest);
return hasNextRequest.future;
}
@@ -146,9 +146,9 @@
/// 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 new RangeError.range(count, 0, null, "count");
+ if (count < 0) throw RangeError.range(count, 0, null, "count");
if (!_isClosed) {
- var request = new _LookAheadRequest<T>(count);
+ var request = _LookAheadRequest<T>(count);
_addRequest(request);
return request.future;
}
@@ -171,7 +171,7 @@
/// first events that were not consumed by previous requeusts.
Future<T> get next {
if (!_isClosed) {
- var nextRequest = new _NextRequest<T>();
+ var nextRequest = _NextRequest<T>();
_addRequest(nextRequest);
return nextRequest.future;
}
@@ -184,7 +184,7 @@
/// If the next event is an error event, it stays in the queue.
Future<T> get peek {
if (!_isClosed) {
- var nextRequest = new _PeekRequest<T>();
+ var nextRequest = _PeekRequest<T>();
_addRequest(nextRequest);
return nextRequest.future;
}
@@ -204,7 +204,7 @@
if (_isClosed) {
throw _failClosed();
}
- var request = new _RestRequest<T>(this);
+ var request = _RestRequest<T>(this);
_isClosed = true;
_addRequest(request);
return request.stream;
@@ -226,9 +226,9 @@
/// 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 new RangeError.range(count, 0, null, "count");
+ if (count < 0) throw RangeError.range(count, 0, null, "count");
if (!_isClosed) {
- var request = new _SkipRequest<T>(count);
+ var request = _SkipRequest<T>(count);
_addRequest(request);
return request.future;
}
@@ -251,9 +251,9 @@
/// 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 new RangeError.range(count, 0, null, "count");
+ if (count < 0) throw RangeError.range(count, 0, null, "count");
if (!_isClosed) {
- var request = new _TakeRequest<T>(count);
+ var request = _TakeRequest<T>(count);
_addRequest(request);
return request.future;
}
@@ -295,7 +295,7 @@
StreamQueueTransaction<T> startTransaction() {
if (_isClosed) throw _failClosed();
- var request = new _TransactionRequest(this);
+ var request = _TransactionRequest(this);
_addRequest(request);
return request.transaction;
}
@@ -353,7 +353,7 @@
/// See also [startTransaction] and [withTransaction].
///
/// ```dart
- /// final _stdinQueue = new StreamQueue(stdin);
+ /// final _stdinQueue = StreamQueue(stdin);
///
/// /// Returns an operation that completes when the user sends a line to
/// /// standard input.
@@ -365,7 +365,7 @@
CancelableOperation<S> cancelable<S>(
Future<S> callback(StreamQueue<T> queue)) {
var transaction = startTransaction();
- var completer = new CancelableCompleter<S>(onCancel: () {
+ var completer = CancelableCompleter<S>(onCancel: () {
transaction.reject();
});
@@ -393,17 +393,17 @@
/// After calling `cancel`, no further events can be requested.
/// None of [lookAhead], [next], [peek], [rest], [skip], [take] or [cancel]
/// may be called again.
- Future cancel({bool immediate: false}) {
+ Future cancel({bool immediate = false}) {
if (_isClosed) throw _failClosed();
_isClosed = true;
if (!immediate) {
- var request = new _CancelRequest<T>(this);
+ var request = _CancelRequest<T>(this);
_addRequest(request);
return request.future;
}
- if (_isDone && _eventQueue.isEmpty) return new Future.value();
+ if (_isDone && _eventQueue.isEmpty) return Future.value();
return _cancel();
}
@@ -444,7 +444,7 @@
Stream<T> _extractStream() {
assert(_isClosed);
if (_isDone) {
- return new Stream<T>.empty();
+ return Stream<T>.empty();
}
_isDone = true;
@@ -456,7 +456,7 @@
_subscription = null;
var wasPaused = subscription.isPaused;
- var result = new SubscriptionStream<T>(subscription);
+ var result = SubscriptionStream<T>(subscription);
// Resume after creating stream because that pauses the subscription too.
// This way there won't be a short resumption in the middle.
if (wasPaused) subscription.resume();
@@ -481,9 +481,9 @@
if (_isDone) return;
if (_subscription == null) {
_subscription = _source.listen((data) {
- _addResult(new Result.value(data));
+ _addResult(Result.value(data));
}, onError: (error, StackTrace stackTrace) {
- _addResult(new Result.error(error, stackTrace));
+ _addResult(Result.error(error, stackTrace));
}, onDone: () {
_subscription = null;
this._close();
@@ -529,7 +529,7 @@
/// Returns a [StateError] with a message saying that either
/// [cancel] or [rest] have already been called.
Error _failClosed() {
- return new 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 = new Set<StreamQueue>();
+ final _queues = Set<StreamQueue>();
/// Whether [commit] has been called.
var _committed = false;
@@ -567,7 +567,7 @@
var _rejected = false;
StreamQueueTransaction._(this._parent, Stream<T> source)
- : _splitter = new StreamSplitter(source);
+ : _splitter = StreamSplitter(source);
/// Creates a new copy of the parent queue.
///
@@ -575,7 +575,7 @@
/// [StreamQueue.startTransaction] was called. Its position can be committed
/// to the parent queue using [commit].
StreamQueue<T> newQueue() {
- var queue = new StreamQueue(_splitter.split());
+ var queue = StreamQueue(_splitter.split());
_queues.add(queue);
return queue;
}
@@ -592,9 +592,9 @@
void commit(StreamQueue<T> queue) {
_assertActive();
if (!_queues.contains(queue)) {
- throw new ArgumentError("Queue doesn't belong to this transaction.");
+ throw ArgumentError("Queue doesn't belong to this transaction.");
} else if (queue._requestQueue.isNotEmpty) {
- throw new StateError("A queue with pending requests can't be committed.");
+ throw StateError("A queue with pending requests can't be committed.");
}
_committed = true;
@@ -639,9 +639,9 @@
/// Throws a [StateError] if [accept] or [reject] has already been called.
void _assertActive() {
if (_committed) {
- throw new StateError("This transaction has already been accepted.");
+ throw StateError("This transaction has already been accepted.");
} else if (_rejected) {
- throw new StateError("This transaction has already been rejected.");
+ throw StateError("This transaction has already been rejected.");
}
}
}
@@ -690,7 +690,7 @@
/// and is then complete.
class _NextRequest<T> implements _EventRequest<T> {
/// Completer for the future returned by [StreamQueue.next].
- final _completer = new Completer<T>();
+ final _completer = Completer<T>();
_NextRequest();
@@ -702,8 +702,7 @@
return true;
}
if (isDone) {
- _completer.completeError(
- new StateError("No elements"), StackTrace.current);
+ _completer.completeError(StateError("No elements"), StackTrace.current);
return true;
}
return false;
@@ -716,7 +715,7 @@
/// and is then complete, but doesn't consume the event.
class _PeekRequest<T> implements _EventRequest<T> {
/// Completer for the future returned by [StreamQueue.next].
- final _completer = new Completer<T>();
+ final _completer = Completer<T>();
_PeekRequest();
@@ -728,8 +727,7 @@
return true;
}
if (isDone) {
- _completer.completeError(
- new StateError("No elements"), StackTrace.current);
+ _completer.completeError(StateError("No elements"), StackTrace.current);
return true;
}
return false;
@@ -739,7 +737,7 @@
/// Request for a [StreamQueue.skip] call.
class _SkipRequest<T> implements _EventRequest<T> {
/// Completer for the future returned by the skip call.
- final _completer = new Completer<int>();
+ final _completer = Completer<int>();
/// Number of remaining events to skip.
///
@@ -776,7 +774,7 @@
/// Common superclass for [_TakeRequest] and [_LookAheadRequest].
abstract class _ListRequest<T> implements _EventRequest<T> {
/// Completer for the future returned by the take call.
- final _completer = new Completer<List<T>>();
+ final _completer = Completer<List<T>>();
/// List collecting events until enough have been seen.
final _list = <T>[];
@@ -846,7 +844,7 @@
class _CancelRequest<T> implements _EventRequest<T> {
/// Completer for the future returned by the `cancel` call.
/// TODO(lrn); make this Completer<void> when that is implemented.
- final _completer = new Completer();
+ final _completer = Completer();
/// When the event is completed, it needs to cancel the active subscription
/// of the `StreamQueue` object, if any.
@@ -875,7 +873,7 @@
/// stream events subscription and creates a stream from it.
class _RestRequest<T> implements _EventRequest<T> {
/// Completer for the stream returned by the `rest` call.
- final _completer = new StreamCompleter<T>();
+ final _completer = StreamCompleter<T>();
/// The [StreamQueue] object that has this request queued.
///
@@ -898,7 +896,7 @@
} else {
// There are prefetched events which needs to be added before the
// remaining stream.
- var controller = new StreamController<T>();
+ var controller = StreamController<T>();
for (var event in events) {
event.addTo(controller);
}
@@ -918,7 +916,7 @@
/// If the request is closed without seeing an event, then
/// the [future] is completed with `false`.
class _HasNextRequest<T> implements _EventRequest<T> {
- final _completer = new Completer<bool>();
+ final _completer = Completer<bool>();
Future<bool> get future => _completer.future;
@@ -947,13 +945,13 @@
StreamQueueTransaction<T> _transaction;
/// The controller that passes events to [transaction].
- final _controller = new StreamController<T>(sync: true);
+ final _controller = StreamController<T>(sync: true);
/// The number of events passed to [_controller] so far.
var _eventsSent = 0;
_TransactionRequest(StreamQueue<T> parent) {
- _transaction = new StreamQueueTransaction._(parent, _controller.stream);
+ _transaction = StreamQueueTransaction._(parent, _controller.stream);
}
bool update(QueueList<Result<T>> events, bool isDone) {
diff --git a/lib/src/stream_sink_completer.dart b/lib/src/stream_sink_completer.dart
index 4219126..c7fdd03 100644
--- a/lib/src/stream_sink_completer.dart
+++ b/lib/src/stream_sink_completer.dart
@@ -24,7 +24,7 @@
///
/// Events can be added to the sink either before or after a destination sink
/// is set.
- final StreamSink<T> sink = new _CompleterSink<T>();
+ final StreamSink<T> sink = _CompleterSink<T>();
/// Returns [sink] typed as a [_CompleterSink].
_CompleterSink<T> get _sink => sink;
@@ -37,7 +37,7 @@
/// If the future completes with an error, the returned sink will instead
/// be closed. Its [Sink.done] future will contain the error.
static StreamSink<T> fromFuture<T>(Future<StreamSink<T>> sinkFuture) {
- var completer = new StreamSinkCompleter<T>();
+ var completer = StreamSinkCompleter<T>();
sinkFuture.then(completer.setDestinationSink, onError: completer.setError);
return completer.sink;
}
@@ -59,7 +59,7 @@
/// Trying to call either of them again will fail.
void setDestinationSink(StreamSink<T> destinationSink) {
if (_sink._destinationSink != null) {
- throw new StateError("Destination sink already set");
+ throw StateError("Destination sink already set");
}
_sink._setDestinationSink(destinationSink);
}
@@ -71,7 +71,7 @@
/// Either of [setDestinationSink] or [setError] may be called at most once.
/// Trying to call either of them again will fail.
void setError(error, [StackTrace stackTrace]) {
- setDestinationSink(new NullStreamSink.error(error, stackTrace));
+ setDestinationSink(NullStreamSink.error(error, stackTrace));
}
}
@@ -101,7 +101,7 @@
Future get done {
if (_doneCompleter != null) return _doneCompleter.future;
if (_destinationSink == null) {
- _doneCompleter = new Completer.sync();
+ _doneCompleter = Completer.sync();
return _doneCompleter.future;
}
return _destinationSink.done;
@@ -144,7 +144,7 @@
/// Create [_controller] if it doesn't yet exist.
void _ensureController() {
- if (_controller == null) _controller = new StreamController(sync: true);
+ if (_controller == null) _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 503d28a..b01132e 100644
--- a/lib/src/stream_sink_transformer.dart
+++ b/lib/src/stream_sink_transformer.dart
@@ -37,7 +37,7 @@
{void handleData(S data, EventSink<T> sink),
void handleError(Object error, StackTrace stackTrace, EventSink<T> sink),
void handleDone(EventSink<T> sink)}) {
- return new HandlerTransformer<S, T>(handleData, handleError, handleDone);
+ return HandlerTransformer<S, T>(handleData, handleError, handleDone);
}
/// Transforms the events passed to [sink].
@@ -57,5 +57,5 @@
StreamSinkTransformer transformer) =>
transformer is StreamSinkTransformer<S, T>
? transformer
- : new TypeSafeStreamSinkTransformer(transformer);
+ : TypeSafeStreamSinkTransformer(transformer);
}
diff --git a/lib/src/stream_sink_transformer/handler_transformer.dart b/lib/src/stream_sink_transformer/handler_transformer.dart
index dba8240..3137003 100644
--- a/lib/src/stream_sink_transformer/handler_transformer.dart
+++ b/lib/src/stream_sink_transformer/handler_transformer.dart
@@ -8,14 +8,14 @@
import '../delegate/stream_sink.dart';
/// The type of the callback for handling data events.
-typedef void HandleData<S, T>(S data, EventSink<T> sink);
+typedef HandleData<S, T> = void Function(S data, EventSink<T> sink);
/// The type of the callback for handling error events.
-typedef void HandleError<T>(
+typedef HandleError<T> = void Function(
Object error, StackTrace stackTrace, EventSink<T> sink);
/// The type of the callback for handling done events.
-typedef void HandleDone<T>(EventSink<T> sink);
+typedef HandleDone<T> = void Function(EventSink<T> sink);
/// A [StreamSinkTransformer] that delegates events to the given handlers.
class HandlerTransformer<S, T> implements StreamSinkTransformer<S, T> {
@@ -30,7 +30,7 @@
HandlerTransformer(this._handleData, this._handleError, this._handleDone);
- StreamSink<S> bind(StreamSink<T> sink) => new _HandlerSink<S, T>(this, sink);
+ StreamSink<S> bind(StreamSink<T> sink) => _HandlerSink<S, T>(this, sink);
}
/// A sink created by [HandlerTransformer].
@@ -49,7 +49,7 @@
_HandlerSink(this._transformer, StreamSink<T> inner)
: _inner = inner,
- _safeCloseInner = new _SafeCloseSink<T>(inner);
+ _safeCloseInner = _SafeCloseSink<T>(inner);
void add(S event) {
if (_transformer._handleData == null) {
@@ -69,7 +69,7 @@
Future addStream(Stream<S> stream) {
return _inner.addStream(stream.transform(
- new StreamTransformer<S, T>.fromHandlers(
+ StreamTransformer<S, T>.fromHandlers(
handleData: _transformer._handleData,
handleError: _transformer._handleError,
handleDone: _closeSink)));
diff --git a/lib/src/stream_sink_transformer/stream_transformer_wrapper.dart b/lib/src/stream_sink_transformer/stream_transformer_wrapper.dart
index 32ac648..1010f9f 100644
--- a/lib/src/stream_sink_transformer/stream_transformer_wrapper.dart
+++ b/lib/src/stream_sink_transformer/stream_transformer_wrapper.dart
@@ -14,7 +14,7 @@
const StreamTransformerWrapper(this._transformer);
StreamSink<S> bind(StreamSink<T> sink) =>
- new _StreamTransformerWrapperSink<S, T>(_transformer, sink);
+ _StreamTransformerWrapperSink<S, T>(_transformer, sink);
}
/// A sink created by [StreamTransformerWrapper].
@@ -23,7 +23,7 @@
///
/// This is used to create a stream that can be transformed by the wrapped
/// transformer.
- final _controller = new StreamController<S>(sync: true);
+ final _controller = StreamController<S>(sync: true);
/// The original sink that's being transformed.
final StreamSink<T> _inner;
diff --git a/lib/src/stream_splitter.dart b/lib/src/stream_splitter.dart
index 3616501..9ddb63a 100644
--- a/lib/src/stream_splitter.dart
+++ b/lib/src/stream_splitter.dart
@@ -32,20 +32,20 @@
/// The buffer of events or errors that have already been emitted by
/// [_stream].
- final _buffer = new List<Result<T>>();
+ final _buffer = List<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 = new Set<StreamController<T>>();
+ final _controllers = Set<StreamController<T>>();
/// A group of futures returned by [close].
///
/// This is used to ensure that [close] doesn't complete until all
/// [StreamController.close] and [StreamSubscription.cancel] calls complete.
- final _closeGroup = new FutureGroup();
+ final _closeGroup = FutureGroup();
/// Whether [_stream] is done emitting events.
var _isDone = false;
@@ -59,8 +59,8 @@
/// then closing the [StreamSplitter].
static List<Stream<T>> splitFrom<T>(Stream<T> stream, [int count]) {
if (count == null) count = 2;
- var splitter = new StreamSplitter<T>(stream);
- var streams = new List<Stream<T>>.generate(count, (_) => splitter.split());
+ var splitter = StreamSplitter<T>(stream);
+ var streams = List<Stream<T>>.generate(count, (_) => splitter.split());
splitter.close();
return streams;
}
@@ -72,10 +72,10 @@
/// This will throw a [StateError] if [close] has been called.
Stream<T> split() {
if (_isClosed) {
- throw new StateError("Can't call split() on a closed StreamSplitter.");
+ throw StateError("Can't call split() on a closed StreamSplitter.");
}
- var controller = new StreamController<T>(
+ var controller = StreamController<T>(
onListen: _onListen, onPause: _onPause, onResume: _onResume);
controller.onCancel = () => _onCancel(controller);
@@ -183,7 +183,7 @@
/// Buffers [data] and passes it to [_controllers].
void _onData(T data) {
- if (!_isClosed) _buffer.add(new Result.value(data));
+ if (!_isClosed) _buffer.add(Result.value(data));
for (var controller in _controllers) {
controller.add(data);
}
@@ -191,7 +191,7 @@
/// Buffers [error] and passes it to [_controllers].
void _onError(Object error, StackTrace stackTrace) {
- if (!_isClosed) _buffer.add(new Result.error(error, stackTrace));
+ if (!_isClosed) _buffer.add(Result.error(error, stackTrace));
for (var controller in _controllers) {
controller.addError(error, stackTrace);
}
diff --git a/lib/src/stream_subscription_transformer.dart b/lib/src/stream_subscription_transformer.dart
index 1443b18..bee96a5 100644
--- a/lib/src/stream_subscription_transformer.dart
+++ b/lib/src/stream_subscription_transformer.dart
@@ -6,9 +6,9 @@
import 'async_memoizer.dart';
-typedef Future _AsyncHandler<T>(StreamSubscription<T> inner);
+typedef _AsyncHandler<T> = Future Function(StreamSubscription<T> inner);
-typedef void _VoidHandler<T>(StreamSubscription<T> inner);
+typedef _VoidHandler<T> = void Function(StreamSubscription<T> inner);
/// Creates a [StreamTransformer] that modifies the behavior of subscriptions to
/// a stream.
@@ -31,8 +31,8 @@
{Future handleCancel(StreamSubscription<T> inner),
void handlePause(StreamSubscription<T> inner),
void handleResume(StreamSubscription<T> inner)}) {
- return new StreamTransformer((stream, cancelOnError) {
- return new _TransformedSubscription(
+ return StreamTransformer((stream, cancelOnError) {
+ return _TransformedSubscription(
stream.listen(null, cancelOnError: cancelOnError),
handleCancel ?? (inner) => inner.cancel(),
handlePause ??
@@ -88,7 +88,7 @@
_inner = null;
return _handleCancel(inner);
});
- final _cancelMemoizer = new AsyncMemoizer();
+ final _cancelMemoizer = AsyncMemoizer();
void pause([Future resumeFuture]) {
if (_cancelMemoizer.hasRun) return;
@@ -102,5 +102,5 @@
}
Future<E> asFuture<E>([E futureValue]) =>
- _inner?.asFuture(futureValue) ?? new Completer<E>().future;
+ _inner?.asFuture(futureValue) ?? Completer<E>().future;
}
diff --git a/lib/src/stream_zip.dart b/lib/src/stream_zip.dart
index 3d5a811..ef14c3e 100644
--- a/lib/src/stream_zip.dart
+++ b/lib/src/stream_zip.dart
@@ -31,7 +31,7 @@
dataCount++;
if (dataCount == subscriptions.length) {
var data = current;
- current = new List(subscriptions.length);
+ current = List(subscriptions.length);
dataCount = 0;
for (int i = 0; i < subscriptions.length; i++) {
if (i != index) subscriptions[i].resume();
@@ -84,9 +84,9 @@
rethrow;
}
- current = new List(subscriptions.length);
+ current = List(subscriptions.length);
- controller = new StreamController<List<T>>(onPause: () {
+ controller = StreamController<List<T>>(onPause: () {
for (int 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
diff --git a/lib/src/subscription_stream.dart b/lib/src/subscription_stream.dart
index a235663..347c346 100644
--- a/lib/src/subscription_stream.dart
+++ b/lib/src/subscription_stream.dart
@@ -41,14 +41,14 @@
StreamSubscription<T> listen(void onData(T event),
{Function onError, void onDone(), bool cancelOnError}) {
if (_source == null) {
- throw new StateError("Stream has already been listened to.");
+ throw StateError("Stream has already been listened to.");
}
cancelOnError = (true == cancelOnError);
var subscription = _source;
_source = null;
var result = cancelOnError
- ? new _CancelOnErrorSubscriptionWrapper<T>(subscription)
+ ? _CancelOnErrorSubscriptionWrapper<T>(subscription)
: subscription;
result.onData(onData);
result.onError(onError);
diff --git a/lib/src/typed_stream_transformer.dart b/lib/src/typed_stream_transformer.dart
index cb63311..9750eb4 100644
--- a/lib/src/typed_stream_transformer.dart
+++ b/lib/src/typed_stream_transformer.dart
@@ -16,7 +16,7 @@
StreamTransformer transformer) =>
transformer is StreamTransformer<S, T>
? transformer
- : new _TypeSafeStreamTransformer(transformer);
+ : _TypeSafeStreamTransformer(transformer);
/// A wrapper that coerces the type of the stream returned by an inner
/// transformer.
diff --git a/lib/src/utils.dart b/lib/src/utils.dart
index 2aab40e..39e5a8a 100644
--- a/lib/src/utils.dart
+++ b/lib/src/utils.dart
@@ -5,8 +5,8 @@
import 'dart:async';
/// A generic typedef for a function that takes one type and returns another.
-typedef F UnaryFunction<E, F>(E argument);
+typedef UnaryFunction<E, F> = F Function(E argument);
/// A typedef for a function that takes no arguments and returns a Future or a
/// value.
-typedef FutureOr<T> FutureOrCallback<T>();
+typedef FutureOrCallback<T> = FutureOr<T> Function();
diff --git a/pubspec.yaml b/pubspec.yaml
index 37db660..0b79178 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -6,7 +6,7 @@
homepage: https://www.github.com/dart-lang/async
environment:
- sdk: '>=2.0.0-dev.23.0 <3.0.0'
+ sdk: '>=2.0.0 <3.0.0'
dependencies:
collection: ^1.5.0
diff --git a/test/async_cache_test.dart b/test/async_cache_test.dart
index a4f452f..92e34bf 100644
--- a/test/async_cache_test.dart
+++ b/test/async_cache_test.dart
@@ -13,7 +13,7 @@
setUp(() {
// Create a cache that is fresh for an hour.
- cache = new AsyncCache(const Duration(hours: 1));
+ cache = AsyncCache(const Duration(hours: 1));
});
test('should fetch via a callback when no cache exists', () async {
@@ -27,16 +27,16 @@
test('should not fetch via callback when a future is in-flight', () async {
// No actual caching is done, just avoid duplicate requests.
- cache = new AsyncCache.ephemeral();
+ cache = AsyncCache.ephemeral();
- var completer = new Completer<String>();
+ var completer = Completer<String>();
expect(cache.fetch(() => completer.future), completion('Expensive'));
expect(cache.fetch(expectAsync0(() {}, count: 0)), completion('Expensive'));
completer.complete('Expensive');
});
test('should fetch via a callback again when cache expires', () {
- new FakeAsync().run((fakeAsync) async {
+ FakeAsync().run((fakeAsync) async {
var timesCalled = 0;
call() async => 'Called ${++timesCalled}';
expect(await cache.fetch(call), 'Called 1');
@@ -67,7 +67,7 @@
test('should fetch a stream via a callback', () async {
expect(
await cache.fetchStream(expectAsync0(() {
- return new Stream.fromIterable(['1', '2', '3']);
+ return Stream.fromIterable(['1', '2', '3']);
})).toList(),
['1', '2', '3']);
});
@@ -86,22 +86,22 @@
// Unlike the above test, we want to verify that we don't make multiple
// calls if a cache is being filled currently, and instead wait for that
// cache to be completed.
- var controller = new StreamController<String>();
+ var controller = StreamController<String>();
Stream<String> call() => controller.stream;
expect(cache.fetchStream(call).toList(), completion(['1', '2', '3']));
controller.add('1');
controller.add('2');
- await new Future.value();
+ await Future.value();
expect(cache.fetchStream(call).toList(), completion(['1', '2', '3']));
controller.add('3');
await controller.close();
});
test('should fetch stream via a callback again when cache expires', () {
- new FakeAsync().run((fakeAsync) async {
+ FakeAsync().run((fakeAsync) async {
var timesCalled = 0;
Stream<String> call() {
- return new Stream.fromIterable(['Called ${++timesCalled}']);
+ return Stream.fromIterable(['Called ${++timesCalled}']);
}
expect(await cache.fetchStream(call).toList(), ['Called 1']);
@@ -125,7 +125,7 @@
test('should fetch via a callback when manually invalidated', () async {
var timesCalled = 0;
Stream<String> call() {
- return new Stream.fromIterable(['Called ${++timesCalled}']);
+ return Stream.fromIterable(['Called ${++timesCalled}']);
}
expect(await cache.fetchStream(call).toList(), ['Called 1']);
@@ -136,7 +136,7 @@
});
test('should cancel a cached stream without affecting others', () async {
- Stream<String> call() => new Stream.fromIterable(['1', '2', '3']);
+ Stream<String> call() => Stream.fromIterable(['1', '2', '3']);
expect(cache.fetchStream(call).toList(), completion(['1', '2', '3']));
@@ -145,7 +145,7 @@
});
test('should pause a cached stream without affecting others', () async {
- Stream<String> call() => new Stream.fromIterable(['1', '2', '3']);
+ Stream<String> call() => Stream.fromIterable(['1', '2', '3']);
StreamSubscription sub;
sub = cache.fetchStream(call).listen(expectAsync1((event) {
diff --git a/test/async_memoizer_test.dart b/test/async_memoizer_test.dart
index 380f58d..785f9a5 100644
--- a/test/async_memoizer_test.dart
+++ b/test/async_memoizer_test.dart
@@ -7,7 +7,7 @@
main() {
AsyncMemoizer cache;
- setUp(() => cache = new AsyncMemoizer());
+ setUp(() => cache = AsyncMemoizer());
test("runs the function only the first time runOnce() is called", () async {
var count = 0;
diff --git a/test/byte_collection_test.dart b/test/byte_collection_test.dart
index b87b074..24d218b 100644
--- a/test/byte_collection_test.dart
+++ b/test/byte_collection_test.dart
@@ -10,7 +10,7 @@
void main() {
group("collectBytes", () {
test("simple list and overflow", () {
- var result = collectBytes(new Stream.fromIterable([
+ var result = collectBytes(Stream.fromIterable([
[0],
[1],
[2],
@@ -20,25 +20,25 @@
});
test("no events", () {
- var result = collectBytes(new Stream.fromIterable([]));
+ var result = collectBytes(Stream.fromIterable([]));
expect(result, completion([]));
});
test("empty events", () {
- var result = collectBytes(new Stream.fromIterable([[], []]));
+ var result = collectBytes(Stream.fromIterable([[], []]));
expect(result, completion([]));
});
test("error event", () {
- var result = collectBytes(new Stream.fromIterable(
- new Iterable.generate(3, (n) => n == 2 ? throw "badness" : [n])));
+ var result = collectBytes(Stream.fromIterable(
+ Iterable.generate(3, (n) => n == 2 ? throw "badness" : [n])));
expect(result, throwsA("badness"));
});
});
group("collectBytes", () {
test("simple list and overflow", () {
- var result = collectBytesCancelable(new Stream.fromIterable([
+ var result = collectBytesCancelable(Stream.fromIterable([
[0],
[1],
[2],
@@ -48,23 +48,23 @@
});
test("no events", () {
- var result = collectBytesCancelable(new Stream.fromIterable([]));
+ var result = collectBytesCancelable(Stream.fromIterable([]));
expect(result.value, completion([]));
});
test("empty events", () {
- var result = collectBytesCancelable(new Stream.fromIterable([[], []]));
+ var result = collectBytesCancelable(Stream.fromIterable([[], []]));
expect(result.value, completion([]));
});
test("error event", () {
- var result = collectBytesCancelable(new Stream.fromIterable(
- new Iterable.generate(3, (n) => n == 2 ? throw "badness" : [n])));
+ var result = collectBytesCancelable(Stream.fromIterable(
+ Iterable.generate(3, (n) => n == 2 ? throw "badness" : [n])));
expect(result.value, throwsA("badness"));
});
test("cancelled", () async {
- var sc = new StreamController<List<int>>();
+ var sc = StreamController<List<int>>();
var result = collectBytesCancelable(sc.stream);
// Value never completes.
result.value.whenComplete(expectAsync0(() {}, count: 0));
@@ -87,4 +87,4 @@
});
}
-Future nextTimerTick() => new Future(() {});
+Future nextTimerTick() => Future(() {});
diff --git a/test/cancelable_operation_test.dart b/test/cancelable_operation_test.dart
index 8c92e2a..4a23856 100644
--- a/test/cancelable_operation_test.dart
+++ b/test/cancelable_operation_test.dart
@@ -13,8 +13,7 @@
group("without being canceled", () {
CancelableCompleter completer;
setUp(() {
- completer =
- new CancelableCompleter(onCancel: expectAsync0(() {}, count: 0));
+ completer = CancelableCompleter(onCancel: expectAsync0(() {}, count: 0));
});
test("sends values to the future", () {
@@ -34,14 +33,14 @@
test("sends values in a future to the future", () {
expect(completer.operation.value, completion(equals(1)));
expect(completer.isCompleted, isFalse);
- completer.complete(new Future.value(1));
+ completer.complete(Future.value(1));
expect(completer.isCompleted, isTrue);
});
test("sends errors in a future to the future", () {
expect(completer.operation.value, throwsA("error"));
expect(completer.isCompleted, isFalse);
- completer.complete(new Future.error("error"));
+ completer.complete(Future.error("error"));
expect(completer.isCompleted, isTrue);
});
@@ -74,31 +73,28 @@
test("successfully then with a future", () {
completer.complete(1);
- expect(
- () => completer.complete(new Completer().future), throwsStateError);
+ expect(() => completer.complete(Completer().future), throwsStateError);
});
test("with a future then successfully", () {
- completer.complete(new Completer().future);
+ completer.complete(Completer().future);
expect(() => completer.complete(1), throwsStateError);
});
test("with a future twice", () {
- completer.complete(new Completer().future);
- expect(
- () => completer.complete(new Completer().future), throwsStateError);
+ completer.complete(Completer().future);
+ expect(() => completer.complete(Completer().future), throwsStateError);
});
});
group("CancelableOperation.fromFuture", () {
test("forwards values", () {
- var operation = new CancelableOperation.fromFuture(new Future.value(1));
+ var operation = CancelableOperation.fromFuture(Future.value(1));
expect(operation.value, completion(equals(1)));
});
test("forwards errors", () {
- var operation =
- new CancelableOperation.fromFuture(new Future.error("error"));
+ var operation = CancelableOperation.fromFuture(Future.error("error"));
expect(operation.value, throwsA("error"));
});
});
@@ -106,7 +102,7 @@
group("when canceled", () {
test("causes the future never to fire", () async {
- var completer = new CancelableCompleter();
+ var completer = CancelableCompleter();
completer.operation.value.whenComplete(expectAsync0(() {}, count: 0));
completer.operation.cancel();
@@ -119,7 +115,7 @@
test("fires onCancel", () {
var canceled = false;
CancelableCompleter completer;
- completer = new CancelableCompleter(onCancel: expectAsync0(() {
+ completer = CancelableCompleter(onCancel: expectAsync0(() {
expect(completer.isCanceled, isTrue);
canceled = true;
}));
@@ -134,8 +130,8 @@
});
test("returns the onCancel future each time cancel is called", () {
- var completer = new CancelableCompleter(onCancel: expectAsync0(() {
- return new Future.value(1);
+ var completer = CancelableCompleter(onCancel: expectAsync0(() {
+ return Future.value(1);
}));
expect(completer.operation.cancel(), completion(equals(1)));
expect(completer.operation.cancel(), completion(equals(1)));
@@ -143,13 +139,13 @@
});
test("returns a future even if onCancel doesn't", () {
- var completer = new CancelableCompleter(onCancel: expectAsync0(() {}));
+ var completer = CancelableCompleter(onCancel: expectAsync0(() {}));
expect(completer.operation.cancel(), completes);
});
test("doesn't call onCancel if the completer has completed", () {
var completer =
- new CancelableCompleter(onCancel: expectAsync0(() {}, count: 0));
+ CancelableCompleter(onCancel: expectAsync0(() {}, count: 0));
completer.complete(1);
expect(completer.operation.value, completion(equals(1)));
expect(completer.operation.cancel(), completes);
@@ -158,8 +154,8 @@
test(
"does call onCancel if the completer has completed to an unfired "
"Future", () {
- var completer = new CancelableCompleter(onCancel: expectAsync0(() {}));
- completer.complete(new Completer().future);
+ var completer = CancelableCompleter(onCancel: expectAsync0(() {}));
+ completer.complete(Completer().future);
expect(completer.operation.cancel(), completes);
});
@@ -167,14 +163,14 @@
"doesn't call onCancel if the completer has completed to a fired "
"Future", () async {
var completer =
- new CancelableCompleter(onCancel: expectAsync0(() {}, count: 0));
- completer.complete(new Future.value(1));
+ CancelableCompleter(onCancel: expectAsync0(() {}, count: 0));
+ completer.complete(Future.value(1));
await completer.operation.value;
expect(completer.operation.cancel(), completes);
});
test("can be completed once after being canceled", () async {
- var completer = new CancelableCompleter();
+ var completer = CancelableCompleter();
completer.operation.value.whenComplete(expectAsync0(() {}, count: 0));
await completer.operation.cancel();
completer.complete(1);
@@ -182,13 +178,13 @@
});
test("fires valueOrCancellation with the given value", () {
- var completer = new CancelableCompleter();
+ var completer = CancelableCompleter();
expect(completer.operation.valueOrCancellation(1), completion(equals(1)));
completer.operation.cancel();
});
test("pipes an error through valueOrCancellation", () {
- var completer = new CancelableCompleter(onCancel: () {
+ var completer = CancelableCompleter(onCancel: () {
throw "error";
});
expect(completer.operation.valueOrCancellation(1), throwsA("error"));
@@ -196,9 +192,9 @@
});
test("valueOrCancellation waits on the onCancel future", () async {
- var innerCompleter = new Completer();
+ var innerCompleter = Completer();
var completer =
- new CancelableCompleter(onCancel: () => innerCompleter.future);
+ CancelableCompleter(onCancel: () => innerCompleter.future);
var fired = false;
completer.operation.valueOrCancellation().then((_) {
@@ -217,21 +213,21 @@
group("asStream()", () {
test("emits a value and then closes", () {
- var completer = new CancelableCompleter();
+ var completer = CancelableCompleter();
expect(completer.operation.asStream().toList(), completion(equals([1])));
completer.complete(1);
});
test("emits an error and then closes", () {
- var completer = new CancelableCompleter();
- var queue = new StreamQueue(completer.operation.asStream());
+ var completer = CancelableCompleter();
+ var queue = StreamQueue(completer.operation.asStream());
expect(queue.next, throwsA("error"));
expect(queue.hasNext, completion(isFalse));
completer.completeError("error");
});
test("cancels the completer when the subscription is canceled", () {
- var completer = new CancelableCompleter(onCancel: expectAsync0(() {}));
+ var completer = CancelableCompleter(onCancel: expectAsync0(() {}));
var sub =
completer.operation.asStream().listen(expectAsync1((_) {}, count: 0));
completer.operation.value.whenComplete(expectAsync0(() {}, count: 0));
diff --git a/test/future_group_test.dart b/test/future_group_test.dart
index b6f75ba..770a465 100644
--- a/test/future_group_test.dart
+++ b/test/future_group_test.dart
@@ -12,7 +12,7 @@
void main() {
FutureGroup futureGroup;
setUp(() {
- futureGroup = new FutureGroup();
+ futureGroup = FutureGroup();
});
group("with no futures", () {
@@ -32,7 +32,7 @@
group("with a future that already completed", () {
test("never completes if nothing happens", () async {
- futureGroup.add(new Future.value());
+ futureGroup.add(Future.value());
await flushMicrotasks();
var completed = false;
@@ -43,7 +43,7 @@
});
test("completes once it's closed", () async {
- futureGroup.add(new Future.value());
+ futureGroup.add(Future.value());
await flushMicrotasks();
expect(futureGroup.future, completes);
@@ -51,21 +51,21 @@
});
test("completes to that future's value", () {
- futureGroup.add(new Future.value(1));
+ futureGroup.add(Future.value(1));
futureGroup.close();
expect(futureGroup.future, completion(equals([1])));
});
test("completes to that future's error, even if it's not closed", () {
- futureGroup.add(new Future.error("error"));
+ futureGroup.add(Future.error("error"));
expect(futureGroup.future, throwsA("error"));
});
});
test("completes once all contained futures complete", () async {
- var completer1 = new Completer();
- var completer2 = new Completer();
- var completer3 = new Completer();
+ var completer1 = Completer();
+ var completer2 = Completer();
+ var completer3 = Completer();
futureGroup.add(completer1.future);
futureGroup.add(completer2.future);
@@ -89,9 +89,9 @@
});
test("completes to the values of the futures in order of addition", () {
- var completer1 = new Completer();
- var completer2 = new Completer();
- var completer3 = new Completer();
+ var completer1 = Completer();
+ var completer2 = Completer();
+ var completer3 = Completer();
futureGroup.add(completer1.future);
futureGroup.add(completer2.future);
@@ -108,9 +108,9 @@
test("completes to the first error to be emitted, even if it's not closed",
() {
- var completer1 = new Completer();
- var completer2 = new Completer();
- var completer3 = new Completer();
+ var completer1 = Completer();
+ var completer2 = Completer();
+ var completer3 = Completer();
futureGroup.add(completer1.future);
futureGroup.add(completer2.future);
@@ -126,9 +126,9 @@
var idle = false;
futureGroup.onIdle.listen((_) => idle = true);
- var completer1 = new Completer();
- var completer2 = new Completer();
- var completer3 = new Completer();
+ var completer1 = Completer();
+ var completer2 = Completer();
+ var completer3 = Completer();
futureGroup.add(completer1.future);
futureGroup.add(completer2.future);
@@ -158,7 +158,7 @@
var idle = false;
futureGroup.onIdle.listen((_) => idle = true);
- var completer = new Completer();
+ var completer = Completer();
futureGroup.add(completer.future);
completer.complete();
@@ -167,7 +167,7 @@
expect(futureGroup.isIdle, isTrue);
idle = false;
- completer = new Completer();
+ completer = Completer();
futureGroup.add(completer.future);
await flushMicrotasks();
@@ -202,7 +202,7 @@
futureFired = true;
}));
- var completer = new Completer();
+ var completer = Completer();
futureGroup.add(completer.future);
futureGroup.close();
diff --git a/test/lazy_stream_test.dart b/test/lazy_stream_test.dart
index 0c2e344..db1bc94 100644
--- a/test/lazy_stream_test.dart
+++ b/test/lazy_stream_test.dart
@@ -11,14 +11,14 @@
main() {
test("disallows a null callback", () {
- expect(() => new LazyStream(null), throwsArgumentError);
+ expect(() => LazyStream(null), throwsArgumentError);
});
test("calls the callback when the stream is listened", () async {
var callbackCalled = false;
- var stream = new LazyStream(expectAsync0(() {
+ var stream = LazyStream(expectAsync0(() {
callbackCalled = true;
- return new Stream.empty();
+ return Stream.empty();
}));
await flushMicrotasks();
@@ -30,9 +30,9 @@
test("calls the callback when the stream is listened", () async {
var callbackCalled = false;
- var stream = new LazyStream(expectAsync0(() {
+ var stream = LazyStream(expectAsync0(() {
callbackCalled = true;
- return new Stream.empty();
+ return Stream.empty();
}));
await flushMicrotasks();
@@ -43,8 +43,8 @@
});
test("forwards to a synchronously-provided stream", () async {
- var controller = new StreamController<int>();
- var stream = new LazyStream(expectAsync0(() => controller.stream));
+ var controller = StreamController<int>();
+ var stream = LazyStream(expectAsync0(() => controller.stream));
var events = [];
stream.listen(events.add);
@@ -65,8 +65,8 @@
});
test("forwards to an asynchronously-provided stream", () async {
- var controller = new StreamController<int>();
- var stream = new LazyStream(expectAsync0(() async => controller.stream));
+ var controller = StreamController<int>();
+ var stream = LazyStream(expectAsync0(() async => controller.stream));
var events = [];
stream.listen(events.add);
@@ -87,7 +87,7 @@
});
test("a lazy stream can't be listened to multiple times", () {
- var stream = new LazyStream(expectAsync0(() => new Stream.empty()));
+ var stream = LazyStream(expectAsync0(() => Stream.empty()));
expect(stream.isBroadcast, isFalse);
stream.listen(null);
@@ -97,9 +97,9 @@
test("a lazy stream can't be listened to from within its callback", () {
LazyStream stream;
- stream = new LazyStream(expectAsync0(() {
+ stream = LazyStream(expectAsync0(() {
expect(() => stream.listen(null), throwsStateError);
- return new Stream.empty();
+ return Stream.empty();
}));
stream.listen(null);
});
diff --git a/test/null_stream_sink_test.dart b/test/null_stream_sink_test.dart
index 244f99c..33e2655 100644
--- a/test/null_stream_sink_test.dart
+++ b/test/null_stream_sink_test.dart
@@ -12,13 +12,13 @@
void main() {
group("constructors", () {
test("done defaults to a completed future", () {
- var sink = new NullStreamSink();
+ var sink = NullStreamSink();
expect(sink.done, completes);
});
test("a custom future may be passed to done", () async {
- var completer = new Completer();
- var sink = new NullStreamSink(done: completer.future);
+ var completer = Completer();
+ var sink = NullStreamSink(done: completer.future);
var doneFired = false;
sink.done.then((_) {
@@ -33,32 +33,32 @@
});
test("NullStreamSink.error passes an error to done", () {
- var sink = new NullStreamSink.error("oh no");
+ var sink = NullStreamSink.error("oh no");
expect(sink.done, throwsA("oh no"));
});
});
group("events", () {
test("are silently dropped before close", () {
- var sink = new NullStreamSink();
+ var sink = NullStreamSink();
sink.add(1);
sink.addError("oh no");
});
test("throw StateErrors after close", () {
- var sink = new NullStreamSink();
+ var sink = NullStreamSink();
expect(sink.close(), completes);
expect(() => sink.add(1), throwsStateError);
expect(() => sink.addError("oh no"), throwsStateError);
- expect(() => sink.addStream(new Stream.empty()), throwsStateError);
+ expect(() => sink.addStream(Stream.empty()), throwsStateError);
});
group("addStream", () {
test("listens to the stream then cancels immediately", () async {
- var sink = new NullStreamSink();
+ var sink = NullStreamSink();
var canceled = false;
- var controller = new StreamController(onCancel: () {
+ var controller = StreamController(onCancel: () {
canceled = true;
});
@@ -68,9 +68,9 @@
});
test("returns the cancel future", () async {
- var completer = new Completer();
- var sink = new NullStreamSink();
- var controller = new StreamController(onCancel: () => completer.future);
+ var completer = Completer();
+ var sink = NullStreamSink();
+ var controller = StreamController(onCancel: () => completer.future);
var addStreamFired = false;
sink.addStream(controller.stream).then((_) {
@@ -85,29 +85,29 @@
});
test("pipes errors from the cancel future through addStream", () async {
- var sink = new NullStreamSink();
- var controller = new StreamController(onCancel: () => throw "oh no");
+ var sink = NullStreamSink();
+ 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",
() async {
- var sink = new NullStreamSink();
- var future = sink.addStream(new Stream.empty());
+ var sink = NullStreamSink();
+ var future = sink.addStream(Stream.empty());
expect(() => sink.add(1), throwsStateError);
expect(() => sink.addError("oh no"), throwsStateError);
- expect(() => sink.addStream(new Stream.empty()), throwsStateError);
+ expect(() => sink.addStream(Stream.empty()), throwsStateError);
await future;
sink.add(1);
sink.addError("oh no");
- expect(sink.addStream(new Stream.empty()), completes);
+ expect(sink.addStream(Stream.empty()), completes);
});
});
});
test("close returns the done future", () {
- var sink = new NullStreamSink.error("oh no");
+ 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 4f59f62..c46c87b 100644
--- a/test/restartable_timer_test.dart
+++ b/test/restartable_timer_test.dart
@@ -8,100 +8,99 @@
main() {
test("runs the callback once the duration has elapsed", () {
- new FakeAsync().run((async) {
+ FakeAsync().run((async) {
var fired = false;
- new RestartableTimer(new Duration(seconds: 5), () {
+ RestartableTimer(Duration(seconds: 5), () {
fired = true;
});
- async.elapse(new Duration(seconds: 4));
+ async.elapse(Duration(seconds: 4));
expect(fired, isFalse);
- async.elapse(new Duration(seconds: 1));
+ async.elapse(Duration(seconds: 1));
expect(fired, isTrue);
});
});
test("doesn't run the callback if the timer is canceled", () {
- new FakeAsync().run((async) {
+ FakeAsync().run((async) {
var fired = false;
- var timer = new RestartableTimer(new Duration(seconds: 5), () {
+ var timer = RestartableTimer(Duration(seconds: 5), () {
fired = true;
});
- async.elapse(new Duration(seconds: 4));
+ async.elapse(Duration(seconds: 4));
expect(fired, isFalse);
timer.cancel();
- async.elapse(new Duration(seconds: 4));
+ async.elapse(Duration(seconds: 4));
expect(fired, isFalse);
});
});
test("resets the duration if the timer is reset before it fires", () {
- new FakeAsync().run((async) {
+ FakeAsync().run((async) {
var fired = false;
- var timer = new RestartableTimer(new Duration(seconds: 5), () {
+ var timer = RestartableTimer(Duration(seconds: 5), () {
fired = true;
});
- async.elapse(new Duration(seconds: 4));
+ async.elapse(Duration(seconds: 4));
expect(fired, isFalse);
timer.reset();
- async.elapse(new Duration(seconds: 4));
+ async.elapse(Duration(seconds: 4));
expect(fired, isFalse);
- async.elapse(new Duration(seconds: 1));
+ async.elapse(Duration(seconds: 1));
expect(fired, isTrue);
});
});
test("re-runs the callback if the timer is reset after firing", () {
- new FakeAsync().run((async) {
+ FakeAsync().run((async) {
var fired = 0;
- var timer = new RestartableTimer(new Duration(seconds: 5), () {
+ var timer = RestartableTimer(Duration(seconds: 5), () {
fired++;
});
- async.elapse(new Duration(seconds: 5));
+ async.elapse(Duration(seconds: 5));
expect(fired, equals(1));
timer.reset();
- async.elapse(new Duration(seconds: 5));
+ async.elapse(Duration(seconds: 5));
expect(fired, equals(2));
timer.reset();
- async.elapse(new Duration(seconds: 5));
+ async.elapse(Duration(seconds: 5));
expect(fired, equals(3));
});
});
test("runs the callback if the timer is reset after being canceled", () {
- new FakeAsync().run((async) {
+ FakeAsync().run((async) {
var fired = false;
- var timer = new RestartableTimer(new Duration(seconds: 5), () {
+ var timer = RestartableTimer(Duration(seconds: 5), () {
fired = true;
});
- async.elapse(new Duration(seconds: 4));
+ async.elapse(Duration(seconds: 4));
expect(fired, isFalse);
timer.cancel();
- async.elapse(new Duration(seconds: 4));
+ async.elapse(Duration(seconds: 4));
expect(fired, isFalse);
timer.reset();
- async.elapse(new Duration(seconds: 5));
+ async.elapse(Duration(seconds: 5));
expect(fired, isTrue);
});
});
test("only runs the callback once if the timer isn't reset", () {
- new FakeAsync().run((async) {
- new RestartableTimer(
- new Duration(seconds: 5), expectAsync0(() {}, count: 1));
- async.elapse(new Duration(seconds: 10));
+ FakeAsync().run((async) {
+ RestartableTimer(Duration(seconds: 5), expectAsync0(() {}, count: 1));
+ async.elapse(Duration(seconds: 10));
});
});
}
diff --git a/test/result/result_captureAll_test.dart b/test/result/result_captureAll_test.dart
index 172e38a..c7b688f 100644
--- a/test/result/result_captureAll_test.dart
+++ b/test/result/result_captureAll_test.dart
@@ -8,16 +8,16 @@
import "package:test/test.dart";
final someStack = StackTrace.current;
-Result<int> res(int n) => new Result<int>.value(n);
-Result err(n) => new ErrorResult("$n", someStack);
+Result<int> res(int n) => Result<int>.value(n);
+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++) {
if (throwWhen != null && throwWhen(i)) {
- yield new Future<int>.error("$i", someStack);
+ yield Future<int>.error("$i", someStack);
} else {
- yield new Future<int>.value(i);
+ yield Future<int>.value(i);
}
}
}
@@ -58,7 +58,7 @@
});
test("completion permutation 1-2-3", () async {
- var cs = new List.generate(3, (_) => new Completer<int>());
+ 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;
@@ -70,7 +70,7 @@
});
test("completion permutation 1-3-2", () async {
- var cs = new List.generate(3, (_) => new Completer<int>());
+ 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;
@@ -82,7 +82,7 @@
});
test("completion permutation 2-1-3", () async {
- var cs = new List.generate(3, (_) => new Completer<int>());
+ 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;
@@ -94,7 +94,7 @@
});
test("completion permutation 2-3-1", () async {
- var cs = new List.generate(3, (_) => new Completer<int>());
+ 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;
@@ -106,7 +106,7 @@
});
test("completion permutation 3-1-2", () async {
- var cs = new List.generate(3, (_) => new Completer<int>());
+ 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;
@@ -118,7 +118,7 @@
});
test("completion permutation 3-2-1", () async {
- var cs = new List.generate(3, (_) => new Completer<int>());
+ 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;
@@ -129,19 +129,19 @@
cs[0].complete(1);
});
- var seed = new Random().nextInt(0x100000000);
+ 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 cs = new List.generate(n, (_) => new Completer<int>());
+ var cs = List.generate(n, (_) => Completer<int>());
var all = Result.captureAll<int>(cs.map((c) => c.future));
- var rnd = new Random(seed);
+ var rnd = Random(seed);
var throwFlags = rnd.nextInt(1 << n); // Bit-flag for throwing.
bool throws(index) => (throwFlags & (1 << index)) != 0;
- var expected = new List.generate(n, (x) => throws(x) ? err(x) : res(x));
+ var expected = List.generate(n, (x) => throws(x) ? err(x) : res(x));
expect(all, completion(expected));
- var completeFunctions = new List<Function()>.generate(n, (i) {
+ var completeFunctions = List<Function()>.generate(n, (i) {
var c = cs[i];
return () =>
throws(i) ? c.completeError("$i", someStack) : c.complete(i);
@@ -167,19 +167,19 @@
test("no error", () async {
var all = await Result.captureAll<int>(<FutureOr<int>>[
1,
- new Future<int>(() => 2),
+ Future<int>(() => 2),
3,
- new Future<int>.value(4),
+ Future<int>.value(4),
]);
expect(all, [res(1), res(2), res(3), res(4)]);
});
test("error", () async {
var all = await Result.captureAll<int>(<FutureOr<int>>[
1,
- new Future<int>(() => 2),
+ Future<int>(() => 2),
3,
- new Future<int>(() async => await new Future.error("4", someStack)),
- new Future<int>.value(5)
+ 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 caaf668..4a049eb 100644
--- a/test/result/result_flattenAll_test.dart
+++ b/test/result/result_flattenAll_test.dart
@@ -6,8 +6,8 @@
import "package:test/test.dart";
final someStack = StackTrace.current;
-Result<T> res<T>(T n) => new Result<T>.value(n);
-Result err(n) => new ErrorResult("$n", someStack);
+Result<T> res<T>(T n) => Result<T>.value(n);
+Result err(n) => ErrorResult("$n", someStack);
/// Helper function creating an iterable of results.
Iterable<Result<int>> results(int count, {bool throwWhen(int index)}) sync* {
diff --git a/test/result/result_future_test.dart b/test/result/result_future_test.dart
index ffdbb7c..4218db2 100644
--- a/test/result/result_future_test.dart
+++ b/test/result/result_future_test.dart
@@ -12,8 +12,8 @@
Completer completer;
ResultFuture future;
setUp(() {
- completer = new Completer();
- future = new ResultFuture(completer.future);
+ completer = Completer();
+ future = ResultFuture(completer.future);
});
test('before completion, result is null', () {
@@ -30,7 +30,7 @@
});
test("after an error completion, result is the future's error", () {
- var trace = new Trace.current();
+ var trace = Trace.current();
completer.completeError('error', trace);
// The completer calls its listeners asynchronously. We have to wait
diff --git a/test/result/result_test.dart b/test/result/result_test.dart
index 33e146e..a33c1ba 100644
--- a/test/result/result_test.dart
+++ b/test/result/result_test.dart
@@ -10,10 +10,10 @@
import "package:test/test.dart";
void main() {
- var stack = new Trace.current();
+ var stack = Trace.current();
test("create result value", () {
- Result<int> result = new Result<int>.value(42);
+ Result<int> result = Result<int>.value(42);
expect(result.isValue, isTrue);
expect(result.isError, isFalse);
ValueResult value = result.asValue;
@@ -21,7 +21,7 @@
});
test("create result value 2", () {
- Result<int> result = new ValueResult<int>(42);
+ Result<int> result = ValueResult<int>(42);
expect(result.isValue, isTrue);
expect(result.isError, isFalse);
ValueResult<int> value = result.asValue;
@@ -29,7 +29,7 @@
});
test("create result error", () {
- Result<bool> result = new Result<bool>.error("BAD", stack);
+ Result<bool> result = Result<bool>.error("BAD", stack);
expect(result.isValue, isFalse);
expect(result.isError, isTrue);
ErrorResult error = result.asError;
@@ -38,7 +38,7 @@
});
test("create result error 2", () {
- Result<bool> result = new ErrorResult("BAD", stack);
+ Result<bool> result = ErrorResult("BAD", stack);
expect(result.isValue, isFalse);
expect(result.isError, isTrue);
ErrorResult error = result.asError;
@@ -47,7 +47,7 @@
});
test("create result error no stack", () {
- Result<bool> result = new Result<bool>.error("BAD");
+ Result<bool> result = Result<bool>.error("BAD");
expect(result.isValue, isFalse);
expect(result.isError, isTrue);
ErrorResult error = result.asError;
@@ -56,8 +56,8 @@
});
test("complete with value", () {
- Result<int> result = new ValueResult<int>(42);
- var c = new Completer<int>();
+ Result<int> result = ValueResult<int>(42);
+ var c = Completer<int>();
c.future.then(expectAsync1((int v) {
expect(v, equals(42));
}), onError: (e, s) {
@@ -67,8 +67,8 @@
});
test("complete with error", () {
- Result<bool> result = new ErrorResult("BAD", stack);
- var c = new Completer<bool>();
+ Result<bool> result = ErrorResult("BAD", stack);
+ var c = Completer<bool>();
c.future.then((bool v) {
fail("Unexpected value $v");
}, onError: expectAsync2((e, s) {
@@ -79,16 +79,16 @@
});
test("add sink value", () {
- var result = new ValueResult<int>(42);
- EventSink<int> sink = new TestSink(onData: expectAsync1((v) {
+ var result = ValueResult<int>(42);
+ EventSink<int> sink = TestSink(onData: expectAsync1((v) {
expect(v, equals(42));
}));
result.addTo(sink);
});
test("add sink error", () {
- Result<bool> result = new ErrorResult("BAD", stack);
- EventSink<bool> sink = new TestSink(onError: expectAsync2((e, s) {
+ Result<bool> result = ErrorResult("BAD", stack);
+ EventSink<bool> sink = TestSink(onError: expectAsync2((e, s) {
expect(e, equals("BAD"));
expect(s, same(stack));
}));
@@ -96,7 +96,7 @@
});
test("value as future", () {
- Result<int> result = new ValueResult<int>(42);
+ Result<int> result = ValueResult<int>(42);
result.asFuture.then(expectAsync1((int v) {
expect(v, equals(42));
}), onError: (e, s) {
@@ -105,7 +105,7 @@
});
test("error as future", () {
- Result<bool> result = new ErrorResult("BAD", stack);
+ Result<bool> result = ErrorResult("BAD", stack);
result.asFuture.then((bool v) {
fail("Unexpected value $v");
}, onError: expectAsync2((e, s) {
@@ -115,7 +115,7 @@
});
test("capture future value", () {
- Future<int> value = new Future<int>.value(42);
+ Future<int> value = Future<int>.value(42);
Result.capture(value).then(expectAsync1((Result result) {
expect(result.isValue, isTrue);
expect(result.isError, isFalse);
@@ -127,7 +127,7 @@
});
test("capture future error", () {
- Future<bool> value = new Future<bool>.error("BAD", stack);
+ Future<bool> value = Future<bool>.error("BAD", stack);
Result.capture(value).then(expectAsync1((Result result) {
expect(result.isValue, isFalse);
expect(result.isError, isTrue);
@@ -141,7 +141,7 @@
test("release future value", () {
Future<Result<int>> future =
- new Future<Result<int>>.value(new Result<int>.value(42));
+ Future<Result<int>>.value(Result<int>.value(42));
Result.release(future).then(expectAsync1((v) {
expect(v, equals(42));
}), onError: (e, s) {
@@ -152,7 +152,7 @@
test("release future error", () {
// An error in the result is unwrapped and reified by release.
Future<Result<bool>> future =
- new Future<Result<bool>>.value(new Result<bool>.error("BAD", stack));
+ Future<Result<bool>>.value(Result<bool>.error("BAD", stack));
Result.release(future).then((v) {
fail("Unexpected value: $v");
}, onError: expectAsync2((e, s) {
@@ -163,7 +163,7 @@
test("release future real error", () {
// An error in the error lane is passed through by release.
- Future<Result<bool>> future = new Future<Result<bool>>.error("BAD", stack);
+ Future<Result<bool>> future = Future<Result<bool>>.error("BAD", stack);
Result.release(future).then((v) {
fail("Unexpected value: $v");
}, onError: expectAsync2((e, s) {
@@ -173,13 +173,10 @@
});
test("capture stream", () {
- var c = new StreamController<int>();
+ var c = StreamController<int>();
var stream = Result.captureStream(c.stream);
- var expectedList = new Queue.from([
- new Result.value(42),
- new Result.error("BAD", stack),
- new Result.value(37)
- ]);
+ var expectedList = Queue.from(
+ [Result.value(42), Result.error("BAD", stack), Result.value(37)]);
void listener(Result actual) {
expect(expectedList.isEmpty, isFalse);
expectResult(actual, expectedList.removeFirst());
@@ -194,16 +191,15 @@
});
test("release stream", () {
- StreamController<Result<int>> c = new StreamController<Result<int>>();
+ StreamController<Result<int>> c = StreamController<Result<int>>();
Stream<int> stream = Result.releaseStream(c.stream);
var events = [
- new Result<int>.value(42),
- new Result<int>.error("BAD", stack),
- new Result<int>.value(37)
+ Result<int>.value(42),
+ Result<int>.error("BAD", stack),
+ Result<int>.value(37)
];
// Expect the data events, and an extra error event.
- var expectedList = new Queue.from(events)
- ..add(new Result.error("BAD2", stack));
+ var expectedList = Queue.from(events)..add(Result.error("BAD2", stack));
void dataListener(int v) {
expect(expectedList.isEmpty, isFalse);
@@ -231,7 +227,7 @@
});
test("release stream cancel on error", () {
- StreamController<Result<int>> c = new StreamController<Result<int>>();
+ StreamController<Result<int>> c = StreamController<Result<int>>();
Stream<int> stream = Result.releaseStream(c.stream);
stream.listen(expectAsync1((v) {
expect(v, equals(42));
@@ -241,34 +237,34 @@
}), onDone: () {
fail("Unexpected done event");
}, cancelOnError: true);
- c.add(new Result.value(42));
- c.add(new Result.error("BAD", stack));
- c.add(new Result.value(37));
+ c.add(Result.value(42));
+ c.add(Result.error("BAD", stack));
+ c.add(Result.value(37));
c.close();
});
test("flatten error 1", () {
- Result<int> error = new Result<int>.error("BAD", stack);
+ Result<int> error = Result<int>.error("BAD", stack);
Result<int> flattened =
- Result.flatten(new Result<Result<int>>.error("BAD", stack));
+ Result.flatten(Result<Result<int>>.error("BAD", stack));
expectResult(flattened, error);
});
test("flatten error 2", () {
- Result<int> error = new Result<int>.error("BAD", stack);
- Result<Result<int>> result = new Result<Result<int>>.value(error);
+ Result<int> error = Result<int>.error("BAD", stack);
+ Result<Result<int>> result = Result<Result<int>>.value(error);
Result<int> flattened = Result.flatten(result);
expectResult(flattened, error);
});
test("flatten value", () {
Result<Result<int>> result =
- new Result<Result<int>>.value(new Result<int>.value(42));
- expectResult(Result.flatten(result), new Result<int>.value(42));
+ Result<Result<int>>.value(Result<int>.value(42));
+ expectResult(Result.flatten(result), Result<int>.value(42));
});
test("handle unary", () {
- ErrorResult result = new Result.error("error", stack);
+ ErrorResult result = Result.error("error", stack);
bool called = false;
result.handle((error) {
called = true;
@@ -278,7 +274,7 @@
});
test("handle binary", () {
- ErrorResult result = new Result.error("error", stack);
+ ErrorResult result = Result.error("error", stack);
bool called = false;
result.handle((error, stackTrace) {
called = true;
@@ -289,7 +285,7 @@
});
test("handle unary and binary", () {
- ErrorResult result = new Result.error("error", stack);
+ ErrorResult result = Result.error("error", stack);
bool called = false;
result.handle((error, [stackTrace]) {
called = true;
@@ -300,7 +296,7 @@
});
test("handle neither unary nor binary", () {
- ErrorResult result = new Result.error("error", stack);
+ ErrorResult result = Result.error("error", stack);
expect(() => result.handle(() => fail("unreachable")), throwsA(anything));
expect(() => result.handle((a, b, c) => fail("unreachable")),
throwsA(anything));
@@ -332,9 +328,9 @@
final Function onDone;
TestSink(
- {void this.onData(T data): _nullData,
- void this.onError(e, StackTrace s): _nullError,
- void this.onDone(): _nullDone});
+ {void this.onData(T data) = _nullData,
+ void this.onError(e, StackTrace s) = _nullError,
+ void this.onDone() = _nullDone});
void add(T value) {
onData(value);
diff --git a/test/single_subscription_transformer_test.dart b/test/single_subscription_transformer_test.dart
index 74e462b..95b321b 100644
--- a/test/single_subscription_transformer_test.dart
+++ b/test/single_subscription_transformer_test.dart
@@ -11,7 +11,7 @@
void main() {
test("buffers events as soon as it's bound", () async {
- var controller = new StreamController.broadcast();
+ var controller = StreamController.broadcast();
var stream =
controller.stream.transform(const SingleSubscriptionTransformer());
@@ -31,7 +31,7 @@
test("cancels the subscription to the broadcast stream when it's canceled",
() async {
var canceled = false;
- var controller = new StreamController.broadcast(onCancel: () {
+ var controller = StreamController.broadcast(onCancel: () {
canceled = true;
});
var stream =
diff --git a/test/stream_completer_test.dart b/test/stream_completer_test.dart
index 55b4ce3..fb1f4a5 100644
--- a/test/stream_completer_test.dart
+++ b/test/stream_completer_test.dart
@@ -11,13 +11,13 @@
main() {
test("a stream is linked before listening", () async {
- var completer = new StreamCompleter();
+ var completer = StreamCompleter();
completer.setSourceStream(createStream());
expect(completer.stream.toList(), completion([1, 2, 3, 4]));
});
test("listened to before a stream is linked", () async {
- var completer = new StreamCompleter();
+ var completer = StreamCompleter();
var done = completer.stream.toList();
await flushMicrotasks();
completer.setSourceStream(createStream());
@@ -25,20 +25,20 @@
});
test("cancel before linking a stream doesn't listen on stream", () async {
- var completer = new StreamCompleter();
+ var completer = StreamCompleter();
var subscription = completer.stream.listen(null);
subscription.pause(); // Should be ignored.
subscription.cancel();
- completer.setSourceStream(new UnusableStream()); // Doesn't throw.
+ completer.setSourceStream(UnusableStream()); // Doesn't throw.
});
test("listen and pause before linking stream", () async {
- var controller = new StreamCompleter();
+ var controller = StreamCompleter();
var events = [];
var subscription = controller.stream.listen(events.add);
var done = subscription.asFuture();
subscription.pause();
- var sourceController = new StreamController();
+ var sourceController = StreamController();
sourceController..add(1)..add(2)..add(3)..add(4);
controller.setSourceStream(sourceController.stream);
await flushMicrotasks();
@@ -56,7 +56,7 @@
});
test("pause more than once", () async {
- var completer = new StreamCompleter();
+ var completer = StreamCompleter();
var events = [];
var subscription = completer.stream.listen(events.add);
var done = subscription.asFuture();
@@ -74,9 +74,9 @@
});
test("cancel new stream before source is done", () async {
- var completer = new StreamCompleter();
+ var completer = StreamCompleter();
var lastEvent = -1;
- var controller = new StreamController();
+ var controller = StreamController();
StreamSubscription subscription;
subscription = completer.stream.listen((value) {
expect(value, lessThan(3));
@@ -106,17 +106,17 @@
});
test("complete with setEmpty before listening", () async {
- var completer = new StreamCompleter();
+ var completer = StreamCompleter();
completer.setEmpty();
- var done = new Completer();
+ var done = Completer();
completer.stream.listen(unreachable("data"),
onError: unreachable("error"), onDone: done.complete);
await done.future;
});
test("complete with setEmpty after listening", () async {
- var completer = new StreamCompleter();
- var done = new Completer();
+ var completer = StreamCompleter();
+ var done = Completer();
completer.stream.listen(unreachable("data"),
onError: unreachable("error"), onDone: done.complete);
completer.setEmpty();
@@ -124,9 +124,9 @@
});
test("source stream isn't listened to until completer stream is", () async {
- var completer = new StreamCompleter();
+ var completer = StreamCompleter();
StreamController controller;
- controller = new StreamController(onListen: () {
+ controller = StreamController(onListen: () {
scheduleMicrotask(controller.close);
});
@@ -139,9 +139,9 @@
});
test("cancelOnError true when listening before linking stream", () async {
- var completer = new StreamCompleter();
+ var completer = StreamCompleter();
Object lastEvent = -1;
- var controller = new StreamController();
+ var controller = StreamController();
completer.stream.listen((value) {
expect(value, lessThan(3));
lastEvent = value;
@@ -172,9 +172,9 @@
});
test("cancelOnError true when listening after linking stream", () async {
- var completer = new StreamCompleter();
+ var completer = StreamCompleter();
Object lastEvent = -1;
- var controller = new StreamController();
+ var controller = StreamController();
completer.setSourceStream(controller.stream);
controller.add(1);
expect(controller.hasListener, isFalse);
@@ -204,7 +204,7 @@
});
test("linking a stream after setSourceStream before listen", () async {
- var completer = new StreamCompleter();
+ var completer = StreamCompleter();
completer.setSourceStream(createStream());
expect(() => completer.setSourceStream(createStream()), throwsStateError);
expect(() => completer.setEmpty(), throwsStateError);
@@ -215,7 +215,7 @@
});
test("linking a stream after setSourceStream after listen", () async {
- var completer = new StreamCompleter();
+ var completer = StreamCompleter();
var list = completer.stream.toList();
completer.setSourceStream(createStream());
expect(() => completer.setSourceStream(createStream()), throwsStateError);
@@ -227,7 +227,7 @@
});
test("linking a stream after setEmpty before listen", () async {
- var completer = new StreamCompleter();
+ var completer = StreamCompleter();
completer.setEmpty();
expect(() => completer.setSourceStream(createStream()), throwsStateError);
expect(() => completer.setEmpty(), throwsStateError);
@@ -238,7 +238,7 @@
});
test("linking a stream after setEmpty() after listen", () async {
- var completer = new StreamCompleter();
+ var completer = StreamCompleter();
var list = completer.stream.toList();
completer.setEmpty();
expect(() => completer.setSourceStream(createStream()), throwsStateError);
@@ -250,7 +250,7 @@
});
test("listening more than once after setting stream", () async {
- var completer = new StreamCompleter();
+ var completer = StreamCompleter();
completer.setSourceStream(createStream());
var list = completer.stream.toList();
expect(() => completer.stream.toList(), throwsStateError);
@@ -259,14 +259,14 @@
});
test("listening more than once before setting stream", () async {
- var completer = new StreamCompleter();
+ var completer = StreamCompleter();
completer.stream.toList();
expect(() => completer.stream.toList(), throwsStateError);
});
test("setting onData etc. before and after setting stream", () async {
- var completer = new StreamCompleter();
- var controller = new StreamController();
+ var completer = StreamCompleter();
+ var controller = StreamController();
var subscription = completer.stream.listen(null);
Object lastEvent = 0;
subscription.onData((value) => lastEvent = value);
@@ -294,8 +294,8 @@
});
test("pause w/ resume future accross setting stream", () async {
- var completer = new StreamCompleter();
- var resume = new Completer();
+ var completer = StreamCompleter();
+ var resume = Completer();
var subscription = completer.stream.listen(unreachable("data"));
subscription.pause(resume.future);
await flushMicrotasks();
@@ -309,8 +309,8 @@
});
test("asFuture with error accross setting stream", () async {
- var completer = new StreamCompleter();
- var controller = new StreamController();
+ var completer = StreamCompleter();
+ var controller = StreamController();
var subscription =
completer.stream.listen(unreachable("data"), cancelOnError: false);
var done = subscription.asFuture();
@@ -327,7 +327,7 @@
group("setError()", () {
test("produces a stream that emits a single error", () {
- var completer = new StreamCompleter();
+ var completer = StreamCompleter();
completer.stream.listen(unreachable("data"),
onError: expectAsync2((error, stackTrace) {
expect(error, equals("oh no"));
@@ -338,7 +338,7 @@
test("produces a stream that emits a single error on a later listen",
() async {
- var completer = new StreamCompleter();
+ var completer = StreamCompleter();
completer.setError("oh no");
await flushMicrotasks();
diff --git a/test/stream_group_test.dart b/test/stream_group_test.dart
index 83b685c..3c4a3a8 100644
--- a/test/stream_group_test.dart
+++ b/test/stream_group_test.dart
@@ -11,16 +11,16 @@
group("single-subscription", () {
StreamGroup<String> streamGroup;
setUp(() {
- streamGroup = new StreamGroup<String>();
+ streamGroup = StreamGroup<String>();
});
test("buffers events from multiple sources", () async {
- var controller1 = new StreamController<String>();
+ var controller1 = StreamController<String>();
streamGroup.add(controller1.stream);
controller1.add("first");
controller1.close();
- var controller2 = new StreamController<String>();
+ var controller2 = StreamController<String>();
streamGroup.add(controller2.stream);
controller2.add("second");
controller2.close();
@@ -34,12 +34,12 @@
});
test("buffers errors from multiple sources", () async {
- var controller1 = new StreamController<String>();
+ var controller1 = StreamController<String>();
streamGroup.add(controller1.stream);
controller1.addError("first");
controller1.close();
- var controller2 = new StreamController<String>();
+ var controller2 = StreamController<String>();
streamGroup.add(controller2.stream);
controller2.addError("second");
controller2.close();
@@ -49,14 +49,14 @@
expect(streamGroup.close(), completes);
var transformed = streamGroup.stream.transform(
- new StreamTransformer<String, String>.fromHandlers(
+ StreamTransformer<String, String>.fromHandlers(
handleError: (error, _, sink) => sink.add("error: $error")));
expect(transformed.toList(),
completion(equals(["error: first", "error: second"])));
});
test("buffers events and errors together", () async {
- var controller = new StreamController<String>();
+ var controller = StreamController<String>();
streamGroup.add(controller.stream);
controller.add("first");
@@ -72,7 +72,7 @@
expect(streamGroup.close(), completes);
var transformed = streamGroup.stream.transform(
- new StreamTransformer<String, String>.fromHandlers(
+ StreamTransformer<String, String>.fromHandlers(
handleData: (data, sink) => sink.add("data: $data"),
handleError: (error, _, sink) => sink.add("error: $error")));
expect(
@@ -88,7 +88,7 @@
});
test("emits events once there's a listener", () {
- var controller = new StreamController<String>();
+ var controller = StreamController<String>();
streamGroup.add(controller.stream);
expect(
@@ -102,7 +102,7 @@
});
test("doesn't buffer events from a broadcast stream", () async {
- var controller = new StreamController<String>.broadcast();
+ var controller = StreamController<String>.broadcast();
streamGroup.add(controller.stream);
controller.add("first");
@@ -116,7 +116,7 @@
});
test("when paused, buffers events from a broadcast stream", () async {
- var controller = new StreamController<String>.broadcast();
+ var controller = StreamController<String>.broadcast();
streamGroup.add(controller.stream);
var events = [];
@@ -136,7 +136,7 @@
});
test("emits events from a broadcast stream once there's a listener", () {
- var controller = new StreamController<String>.broadcast();
+ var controller = StreamController<String>.broadcast();
streamGroup.add(controller.stream);
expect(
@@ -152,8 +152,7 @@
test("forwards cancel errors", () async {
var subscription = streamGroup.stream.listen(null);
- var controller =
- new StreamController<String>(onCancel: () => throw "error");
+ var controller = StreamController<String>(onCancel: () => throw "error");
streamGroup.add(controller.stream);
await flushMicrotasks();
@@ -163,9 +162,9 @@
test("forwards a cancel future", () async {
var subscription = streamGroup.stream.listen(null);
- var completer = new Completer();
+ var completer = Completer();
var controller =
- new StreamController<String>(onCancel: () => completer.future);
+ StreamController<String>(onCancel: () => completer.future);
streamGroup.add(controller.stream);
await flushMicrotasks();
@@ -187,7 +186,7 @@
await flushMicrotasks();
var paused = false;
- var controller = new StreamController<String>(
+ var controller = StreamController<String>(
onPause: () => paused = true, onResume: () => paused = false);
subscription.pause();
@@ -211,7 +210,7 @@
test("immediately listens to and cancels the stream", () async {
var listened = false;
var canceled = false;
- var controller = new StreamController<String>(onListen: () {
+ var controller = StreamController<String>(onListen: () {
listened = true;
}, onCancel: expectAsync0(() {
expect(listened, isTrue);
@@ -226,15 +225,15 @@
test("forwards cancel errors", () {
var controller =
- new StreamController<String>(onCancel: () => throw "error");
+ StreamController<String>(onCancel: () => throw "error");
expect(streamGroup.add(controller.stream), throwsA("error"));
});
test("forwards a cancel future", () async {
- var completer = new Completer();
+ var completer = Completer();
var controller =
- new StreamController<String>(onCancel: () => completer.future);
+ StreamController<String>(onCancel: () => completer.future);
var fired = false;
streamGroup.add(controller.stream).then((_) => fired = true);
@@ -252,16 +251,16 @@
group("broadcast", () {
StreamGroup<String> streamGroup;
setUp(() {
- streamGroup = new StreamGroup<String>.broadcast();
+ streamGroup = StreamGroup<String>.broadcast();
});
test("buffers events from multiple sources", () async {
- var controller1 = new StreamController<String>();
+ var controller1 = StreamController<String>();
streamGroup.add(controller1.stream);
controller1.add("first");
controller1.close();
- var controller2 = new StreamController<String>();
+ var controller2 = StreamController<String>();
streamGroup.add(controller2.stream);
controller2.add("second");
controller2.close();
@@ -275,10 +274,10 @@
});
test("emits events from multiple sources once there's a listener", () {
- var controller1 = new StreamController<String>();
+ var controller1 = StreamController<String>();
streamGroup.add(controller1.stream);
- var controller2 = new StreamController<String>();
+ var controller2 = StreamController<String>();
streamGroup.add(controller2.stream);
expect(
@@ -294,7 +293,7 @@
test("doesn't buffer events once a listener has been added and removed",
() async {
- var controller = new StreamController<String>();
+ var controller = StreamController<String>();
streamGroup.add(controller.stream);
streamGroup.stream.listen(null).cancel();
@@ -311,7 +310,7 @@
});
test("doesn't buffer events from a broadcast stream", () async {
- var controller = new StreamController<String>.broadcast();
+ var controller = StreamController<String>.broadcast();
streamGroup.add(controller.stream);
controller.add("first");
controller.addError("second");
@@ -324,7 +323,7 @@
});
test("emits events from a broadcast stream once there's a listener", () {
- var controller = new StreamController<String>.broadcast();
+ var controller = StreamController<String>.broadcast();
streamGroup.add(controller.stream);
expect(
@@ -340,7 +339,7 @@
test("cancels and re-listens broadcast streams", () async {
var subscription = streamGroup.stream.listen(null);
- var controller = new StreamController<String>.broadcast();
+ var controller = StreamController<String>.broadcast();
streamGroup.add(controller.stream);
await flushMicrotasks();
@@ -359,7 +358,7 @@
var subscription = streamGroup.stream.listen(null);
var controller =
- new StreamController<String>(onCancel: expectAsync0(() {}, count: 0));
+ StreamController<String>(onCancel: expectAsync0(() {}, count: 0));
streamGroup.add(controller.stream);
await flushMicrotasks();
@@ -376,7 +375,7 @@
var events = [];
var subscription = streamGroup.stream.listen(events.add);
- var controller = new StreamController<String>();
+ var controller = StreamController<String>();
streamGroup.add(controller.stream);
await flushMicrotasks();
@@ -396,7 +395,7 @@
});
test("a single-subscription stream can be removed while dormant", () async {
- var controller = new StreamController<String>();
+ var controller = StreamController<String>();
streamGroup.add(controller.stream);
await flushMicrotasks();
@@ -415,17 +414,17 @@
group("regardless of type", () {
group("single-subscription", () {
- regardlessOfType(() => new StreamGroup<String>());
+ regardlessOfType(() => StreamGroup<String>());
});
group("broadcast", () {
- regardlessOfType(() => new StreamGroup<String>.broadcast());
+ regardlessOfType(() => StreamGroup<String>.broadcast());
});
});
test("merge() emits events from all components streams", () {
- var controller1 = new StreamController<String>();
- var controller2 = new StreamController<String>();
+ var controller1 = StreamController<String>();
+ var controller2 = StreamController<String>();
var merged = StreamGroup.merge([controller1.stream, controller2.stream]);
@@ -448,7 +447,7 @@
group("while dormant", () {
test("doesn't listen to the stream until the group is listened to",
() async {
- var controller = new StreamController<String>();
+ var controller = StreamController<String>();
expect(streamGroup.add(controller.stream), isNull);
await flushMicrotasks();
@@ -460,7 +459,7 @@
});
test("is a no-op if the stream is already in the group", () {
- var controller = new StreamController<String>();
+ var controller = StreamController<String>();
streamGroup.add(controller.stream);
streamGroup.add(controller.stream);
streamGroup.add(controller.stream);
@@ -478,7 +477,7 @@
});
test("listens to the stream immediately", () async {
- var controller = new StreamController<String>();
+ var controller = StreamController<String>();
expect(streamGroup.add(controller.stream), isNull);
await flushMicrotasks();
@@ -486,7 +485,7 @@
});
test("is a no-op if the stream is already in the group", () async {
- var controller = new StreamController<String>();
+ var controller = StreamController<String>();
// If the stream were actually listened to more than once, future
// calls to [add] would throw [StateError]s.
@@ -500,7 +499,7 @@
group("remove()", () {
group("while dormant", () {
test("stops emitting events for a stream that's removed", () async {
- var controller = new StreamController<String>();
+ var controller = StreamController<String>();
streamGroup.add(controller.stream);
expect(streamGroup.stream.toList(), completion(equals(["first"])));
@@ -514,14 +513,14 @@
});
test("is a no-op for an unknown stream", () {
- var controller = new StreamController<String>();
+ var controller = StreamController<String>();
expect(streamGroup.remove(controller.stream), isNull);
});
test("and closed closes the group when the last stream is removed",
() async {
- var controller1 = new StreamController<String>();
- var controller2 = new StreamController<String>();
+ var controller1 = StreamController<String>();
+ var controller2 = StreamController<String>();
streamGroup.add(controller1.stream);
streamGroup.add(controller2.stream);
@@ -541,7 +540,7 @@
group("while listening", () {
test("doesn't emit events from a removed stream", () {
- var controller = new StreamController<String>();
+ var controller = StreamController<String>();
streamGroup.add(controller.stream);
// The subscription to [controller.stream] is canceled synchronously, so
@@ -557,7 +556,7 @@
});
test("cancels the stream's subscription", () async {
- var controller = new StreamController<String>();
+ var controller = StreamController<String>();
streamGroup.add(controller.stream);
streamGroup.stream.listen(null);
@@ -571,7 +570,7 @@
test("forwards cancel errors", () async {
var controller =
- new StreamController<String>(onCancel: () => throw "error");
+ StreamController<String>(onCancel: () => throw "error");
streamGroup.add(controller.stream);
streamGroup.stream.listen(null);
@@ -581,9 +580,9 @@
});
test("forwards cancel futures", () async {
- var completer = new Completer();
+ var completer = Completer();
var controller =
- new StreamController<String>(onCancel: () => completer.future);
+ StreamController<String>(onCancel: () => completer.future);
streamGroup.stream.listen(null);
await flushMicrotasks();
@@ -603,7 +602,7 @@
});
test("is a no-op for an unknown stream", () async {
- var controller = new StreamController<String>();
+ var controller = StreamController<String>();
streamGroup.stream.listen(null);
await flushMicrotasks();
@@ -616,8 +615,8 @@
streamGroup.stream.listen(null, onDone: () => done = true);
await flushMicrotasks();
- var controller1 = new StreamController<String>();
- var controller2 = new StreamController<String>();
+ var controller1 = StreamController<String>();
+ var controller2 = StreamController<String>();
streamGroup.add(controller1.stream);
streamGroup.add(controller2.stream);
@@ -646,8 +645,8 @@
test(
"if there are streams, closes the group once those streams close "
"and there's a listener", () async {
- var controller1 = new StreamController<String>();
- var controller2 = new StreamController<String>();
+ var controller1 = StreamController<String>();
+ var controller2 = StreamController<String>();
streamGroup.add(controller1.stream);
streamGroup.add(controller2.stream);
@@ -673,8 +672,8 @@
streamGroup.stream.listen(null, onDone: () => done = true);
await flushMicrotasks();
- var controller1 = new StreamController<String>();
- var controller2 = new StreamController<String>();
+ var controller1 = StreamController<String>();
+ var controller2 = StreamController<String>();
streamGroup.add(controller1.stream);
streamGroup.add(controller2.stream);
@@ -699,7 +698,7 @@
var events = [];
streamGroup.stream.listen(events.add);
- var controller = new StreamController<String>();
+ var controller = StreamController<String>();
streamGroup.add(controller.stream);
await flushMicrotasks();
@@ -721,4 +720,4 @@
}
/// Wait for all microtasks to complete.
-Future flushMicrotasks() => new Future.delayed(Duration.zero);
+Future flushMicrotasks() => Future.delayed(Duration.zero);
diff --git a/test/stream_queue_test.dart b/test/stream_queue_test.dart
index 37dedb9..aaf1227 100644
--- a/test/stream_queue_test.dart
+++ b/test/stream_queue_test.dart
@@ -12,8 +12,8 @@
main() {
group("source stream", () {
test("is listened to on first request, paused between requests", () async {
- var controller = new StreamController<int>();
- var events = new StreamQueue<int>(controller.stream);
+ var controller = StreamController<int>();
+ var events = StreamQueue<int>(controller.stream);
await flushMicrotasks();
expect(controller.hasListener, isFalse);
@@ -44,7 +44,7 @@
group("eventsDispatched", () {
test("increments after a next future completes", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(events.eventsDispatched, equals(0));
await flushMicrotasks();
@@ -61,13 +61,13 @@
});
test("increments multiple times for multi-value requests", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
await events.take(3);
expect(events.eventsDispatched, equals(3));
});
test("increments multiple times for an accepted transaction", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
await events.withTransaction((queue) async {
await queue.next;
await queue.next;
@@ -77,7 +77,7 @@
});
test("doesn't increment for rest requests", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
await events.rest.toList();
expect(events.eventsDispatched, equals(0));
});
@@ -85,7 +85,7 @@
group("lookAhead operation", () {
test("as simple list of events", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.lookAhead(4), [1, 2, 3, 4]);
expect(await events.next, 1);
expect(await events.lookAhead(2), [2, 3]);
@@ -95,7 +95,7 @@
});
test("of 0 events", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(events.lookAhead(0), completion([]));
expect(events.next, completion(1));
expect(events.lookAhead(0), completion([]));
@@ -111,7 +111,7 @@
});
test("with bad arguments throws", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(() => events.lookAhead(-1), throwsArgumentError);
expect(await events.next, 1); // Did not consume event.
expect(() => events.lookAhead(-1), throwsArgumentError);
@@ -120,13 +120,13 @@
});
test("of too many arguments", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.lookAhead(6), [1, 2, 3, 4]);
await events.cancel();
});
test("too large later", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(await events.lookAhead(6), [3, 4]);
@@ -134,7 +134,7 @@
});
test("error", () async {
- var events = new StreamQueue<int>(createErrorStream());
+ var events = StreamQueue<int>(createErrorStream());
expect(events.lookAhead(4), throwsA("To err is divine!"));
expect(events.take(4), throwsA("To err is divine!"));
expect(await events.next, 4);
@@ -144,7 +144,7 @@
group("next operation", () {
test("simple sequence of requests", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
for (int i = 1; i <= 4; i++) {
expect(await events.next, i);
}
@@ -152,7 +152,7 @@
});
test("multiple requests at the same time", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
var result = await Future.wait(
[events.next, events.next, events.next, events.next]);
expect(result, [1, 2, 3, 4]);
@@ -160,7 +160,7 @@
});
test("sequence of requests with error", () async {
- var events = new StreamQueue<int>(createErrorStream());
+ var events = StreamQueue<int>(createErrorStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(events.next, throwsA("To err is divine!"));
@@ -171,7 +171,7 @@
group("skip operation", () {
test("of two elements in the middle of sequence", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.skip(2), 0);
expect(await events.next, 4);
@@ -179,7 +179,7 @@
});
test("with negative/bad arguments throws", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(() => events.skip(-1), throwsArgumentError);
// A non-int throws either a type error or an argument error,
// depending on whether it's checked mode or not.
@@ -190,7 +190,7 @@
});
test("of 0 elements works", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(events.skip(0), completion(0));
expect(events.next, completion(1));
expect(events.skip(0), completion(0));
@@ -206,13 +206,13 @@
});
test("of too many events ends at stream start", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.skip(6), 2);
await events.cancel();
});
test("of too many events after some events", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(await events.skip(6), 4);
@@ -220,7 +220,7 @@
});
test("of too many events ends at stream end", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(await events.next, 3);
@@ -230,20 +230,20 @@
});
test("of events with error", () async {
- var events = new StreamQueue<int>(createErrorStream());
+ var events = StreamQueue<int>(createErrorStream());
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 {
- var events = new StreamQueue<int>(createErrorStream());
+ var events = StreamQueue<int>(createErrorStream());
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 {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
var skip1 = events.skip(1);
var skip2 = events.skip(0);
var skip3 = events.skip(4);
@@ -267,7 +267,7 @@
group("take operation", () {
test("as simple take of events", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.take(2), [2, 3]);
expect(await events.next, 4);
@@ -275,7 +275,7 @@
});
test("of 0 events", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(events.take(0), completion([]));
expect(events.next, completion(1));
expect(events.take(0), completion([]));
@@ -291,7 +291,7 @@
});
test("with bad arguments throws", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(() => events.take(-1), throwsArgumentError);
expect(await events.next, 1); // Did not consume event.
expect(() => events.take(-1), throwsArgumentError);
@@ -300,13 +300,13 @@
});
test("of too many arguments", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.take(6), [1, 2, 3, 4]);
await events.cancel();
});
test("too large later", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(await events.take(6), [3, 4]);
@@ -314,7 +314,7 @@
});
test("error", () async {
- var events = new StreamQueue<int>(createErrorStream());
+ var events = StreamQueue<int>(createErrorStream());
expect(events.take(4), throwsA("To err is divine!"));
expect(await events.next, 4);
await events.cancel();
@@ -323,18 +323,18 @@
group("rest operation", () {
test("after single next", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.rest.toList(), [2, 3, 4]);
});
test("at start", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.rest.toList(), [1, 2, 3, 4]);
});
test("at end", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(await events.next, 3);
@@ -343,7 +343,7 @@
});
test("after end", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(await events.next, 3);
@@ -353,7 +353,7 @@
});
test("after receiving done requested before", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
var next1 = events.next;
var next2 = events.next;
var next3 = events.next;
@@ -368,17 +368,17 @@
});
test("with an error event error", () async {
- var events = new StreamQueue<int>(createErrorStream());
+ var events = StreamQueue<int>(createErrorStream());
expect(await events.next, 1);
var rest = events.rest;
- var events2 = new StreamQueue(rest);
+ var events2 = StreamQueue(rest);
expect(await events2.next, 2);
expect(events2.next, throwsA("To err is divine!"));
expect(await events2.next, 4);
});
test("closes the events, prevents other operations", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
var stream = events.rest;
expect(() => events.next, throwsStateError);
expect(() => events.skip(1), throwsStateError);
@@ -389,9 +389,9 @@
});
test("forwards to underlying stream", () async {
- var cancel = new Completer();
- var controller = new StreamController<int>(onCancel: () => cancel.future);
- var events = new StreamQueue<int>(controller.stream);
+ var cancel = Completer();
+ var controller = StreamController<int>(onCancel: () => cancel.future);
+ var events = StreamQueue<int>(controller.stream);
expect(controller.hasListener, isFalse);
var next = events.next;
expect(controller.hasListener, isTrue);
@@ -437,7 +437,7 @@
group("peek operation", () {
test("peeks one event", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.peek, 1);
expect(await events.next, 1);
expect(await events.peek, 2);
@@ -449,14 +449,14 @@
await events.cancel();
});
test("multiple requests at the same time", () async {
- var events = new StreamQueue<int>(createStream());
+ 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 {
- var events = new StreamQueue<int>(createErrorStream());
+ var events = StreamQueue<int>(createErrorStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(events.peek, throwsA("To err is divine!"));
@@ -470,7 +470,7 @@
group("cancel operation", () {
test("closes the events, prevents any other operation", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
await events.cancel();
expect(() => events.lookAhead(1), throwsStateError);
expect(() => events.next, throwsStateError);
@@ -483,16 +483,16 @@
test("cancels underlying subscription when called before any event",
() async {
- var cancelFuture = new Future.value(42);
- var controller = new StreamController<int>(onCancel: () => cancelFuture);
- var events = new StreamQueue<int>(controller.stream);
+ var cancelFuture = Future.value(42);
+ var controller = StreamController<int>(onCancel: () => cancelFuture);
+ var events = StreamQueue<int>(controller.stream);
expect(await events.cancel(), 42);
});
test("cancels underlying subscription, returns result", () async {
- var cancelFuture = new Future.value(42);
- var controller = new StreamController<int>(onCancel: () => cancelFuture);
- var events = new StreamQueue<int>(controller.stream);
+ var cancelFuture = Future.value(42);
+ var controller = StreamController<int>(onCancel: () => cancelFuture);
+ var events = StreamQueue<int>(controller.stream);
controller.add(1);
expect(await events.next, 1);
expect(await events.cancel(), 42);
@@ -500,7 +500,7 @@
group("with immediate: true", () {
test("closes the events, prevents any other operation", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
await events.cancel(immediate: true);
expect(() => events.next, throwsStateError);
expect(() => events.skip(1), throwsStateError);
@@ -510,10 +510,10 @@
});
test("cancels the underlying subscription immediately", () async {
- var controller = new StreamController<int>();
+ var controller = StreamController<int>();
controller.add(1);
- var events = new StreamQueue<int>(controller.stream);
+ var events = StreamQueue<int>(controller.stream);
expect(await events.next, 1);
expect(controller.hasListener, isTrue);
@@ -523,16 +523,15 @@
test("cancels the underlying subscription when called before any event",
() async {
- var cancelFuture = new Future.value(42);
- var controller =
- new StreamController<int>(onCancel: () => cancelFuture);
+ var cancelFuture = Future.value(42);
+ var controller = StreamController<int>(onCancel: () => cancelFuture);
- var events = new StreamQueue<int>(controller.stream);
+ var events = StreamQueue<int>(controller.stream);
expect(await events.cancel(immediate: true), 42);
});
test("closes pending requests", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(events.next, throwsStateError);
expect(events.hasNext, completion(isFalse));
@@ -543,8 +542,8 @@
test("returns the result of closing the underlying subscription",
() async {
var controller =
- new StreamController<int>(onCancel: () => new Future.value(42));
- var events = new StreamQueue<int>(controller.stream);
+ StreamController<int>(onCancel: () => Future.value(42));
+ var events = StreamQueue<int>(controller.stream);
expect(await events.cancel(immediate: true), 42);
});
@@ -552,8 +551,8 @@
() async {
var wasListened = false;
var controller =
- new StreamController<int>(onListen: () => wasListened = true);
- var events = new StreamQueue<int>(controller.stream);
+ StreamController<int>(onListen: () => wasListened = true);
+ var events = StreamQueue<int>(controller.stream);
expect(wasListened, isFalse);
expect(controller.hasListener, isFalse);
@@ -566,18 +565,18 @@
group("hasNext operation", () {
test("true at start", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.hasNext, isTrue);
});
test("true after start", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, isTrue);
});
test("true at end", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
for (int i = 1; i <= 4; i++) {
expect(await events.next, i);
}
@@ -585,7 +584,7 @@
});
test("true when enqueued", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
var values = <int>[];
for (int i = 1; i <= 3; i++) {
events.next.then(values.add);
@@ -596,7 +595,7 @@
});
test("false when enqueued", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
var values = <int>[];
for (int i = 1; i <= 4; i++) {
events.next.then(values.add);
@@ -607,8 +606,8 @@
});
test("true when data event", () async {
- var controller = new StreamController<int>();
- var events = new StreamQueue<int>(controller.stream);
+ var controller = StreamController<int>();
+ var events = StreamQueue<int>(controller.stream);
bool hasNext;
events.hasNext.then((result) {
@@ -623,8 +622,8 @@
});
test("true when error event", () async {
- var controller = new StreamController<int>();
- var events = new StreamQueue<int>(controller.stream);
+ var controller = StreamController<int>();
+ var events = StreamQueue<int>(controller.stream);
bool hasNext;
events.hasNext.then((result) {
@@ -640,7 +639,7 @@
});
test("- hasNext after hasNext", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.hasNext, true);
expect(await events.hasNext, true);
expect(await events.next, 1);
@@ -658,7 +657,7 @@
});
test("- next after true", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
expect(await events.next, 2);
@@ -666,7 +665,7 @@
});
test("- next after true, enqueued", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
var responses = <Object>[];
events.next.then(responses.add);
events.hasNext.then(responses.add);
@@ -678,7 +677,7 @@
});
test("- skip 0 after true", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
expect(await events.skip(0), 0);
@@ -686,7 +685,7 @@
});
test("- skip 1 after true", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
expect(await events.skip(1), 0);
@@ -694,7 +693,7 @@
});
test("- skip 2 after true", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
expect(await events.skip(2), 0);
@@ -702,7 +701,7 @@
});
test("- take 0 after true", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
expect(await events.take(0), isEmpty);
@@ -710,7 +709,7 @@
});
test("- take 1 after true", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
expect(await events.take(1), [2]);
@@ -718,7 +717,7 @@
});
test("- take 2 after true", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
expect(await events.take(2), [2, 3]);
@@ -726,7 +725,7 @@
});
test("- rest after true", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
var stream = events.rest;
@@ -734,7 +733,7 @@
});
test("- rest after true, at last", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(await events.next, 3);
@@ -744,7 +743,7 @@
});
test("- rest after false", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(await events.next, 3);
@@ -755,7 +754,7 @@
});
test("- cancel after true on data", () async {
- var events = new StreamQueue<int>(createStream());
+ var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(await events.hasNext, true);
@@ -763,7 +762,7 @@
});
test("- cancel after true on error", () async {
- var events = new StreamQueue<int>(createErrorStream());
+ var events = StreamQueue<int>(createErrorStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(await events.hasNext, true);
@@ -777,7 +776,7 @@
StreamQueue<int> queue1;
StreamQueue<int> queue2;
setUp(() async {
- events = new StreamQueue(createStream());
+ events = StreamQueue(createStream());
expect(await events.next, 1);
transaction = events.startTransaction();
queue1 = transaction.newQueue();
@@ -808,7 +807,7 @@
});
test("independently emit errors", () async {
- events = new StreamQueue(createErrorStream());
+ events = StreamQueue(createErrorStream());
expect(await events.next, 1);
transaction = events.startTransaction();
queue1 = transaction.newQueue();
@@ -872,8 +871,8 @@
// Regression test.
test("pending child rest requests emit no more events", () async {
- var controller = new StreamController();
- var events = new StreamQueue(controller.stream);
+ var controller = StreamController();
+ var events = StreamQueue(controller.stream);
var transaction = events.startTransaction();
var queue = transaction.newQueue();
@@ -906,8 +905,8 @@
});
test("before the transaction emits any events, does nothing", () async {
- var controller = new StreamController();
- var events = new StreamQueue(controller.stream);
+ var controller = StreamController();
+ var events = StreamQueue(controller.stream);
// Queue a request before the transaction, but don't let it complete
// until we're done with the transaction.
@@ -983,8 +982,8 @@
});
test("before the transaction emits any events, does nothing", () async {
- var controller = new StreamController();
- var events = new StreamQueue(controller.stream);
+ var controller = StreamController();
+ var events = StreamQueue(controller.stream);
// Queue a request before the transaction, but don't let it complete
// until we're done with the transaction.
@@ -1006,7 +1005,7 @@
group("withTransaction operation", () {
StreamQueue<int> events;
setUp(() async {
- events = new StreamQueue(createStream());
+ events = StreamQueue(createStream());
expect(await events.next, 1);
});
@@ -1060,7 +1059,7 @@
group("cancelable operation", () {
StreamQueue<int> events;
setUp(() async {
- events = new StreamQueue(createStream());
+ events = StreamQueue(createStream());
expect(await events.next, 1);
});
@@ -1120,7 +1119,7 @@
// doing rest. Each of the first rounds do 10 events of each type,
// the rest does 20 elements.
var eventCount = 20 * (3 * 3 + 1);
- var events = new StreamQueue<int>(createLongStream(eventCount));
+ var events = StreamQueue<int>(createLongStream(eventCount));
// Test expecting [startIndex .. startIndex + 9] as events using
// `next`.
@@ -1139,7 +1138,7 @@
// `take(10)`.
takeTest(startIndex) {
expect(events.take(10),
- completion(new List.generate(10, (i) => startIndex + i)));
+ completion(List.generate(10, (i) => startIndex + i)));
}
var tests = [nextTest, skipTest, takeTest];
@@ -1155,11 +1154,11 @@
}
// Then expect 20 more events as a `rest` call.
expect(events.rest.toList(),
- completion(new List.generate(20, (i) => counter + i)));
+ completion(List.generate(20, (i) => counter + i)));
});
}
-typedef T Func1Required<T>(T value);
+typedef Func1Required<T> = T Function(T value);
Stream<int> createStream() async* {
yield 1;
@@ -1172,7 +1171,7 @@
}
Stream<int> createErrorStream() {
- var controller = new StreamController<int>();
+ var controller = StreamController<int>();
() async {
controller.add(1);
await flushMicrotasks();
diff --git a/test/stream_sink_completer_test.dart b/test/stream_sink_completer_test.dart
index a149a7f..56860ce 100644
--- a/test/stream_sink_completer_test.dart
+++ b/test/stream_sink_completer_test.dart
@@ -12,12 +12,12 @@
main() {
StreamSinkCompleter completer;
setUp(() {
- completer = new StreamSinkCompleter();
+ completer = StreamSinkCompleter();
});
group("when a stream is linked before events are added", () {
test("data events are forwarded", () {
- var sink = new TestSink();
+ var sink = TestSink();
completer.setDestinationSink(sink);
completer.sink..add(1)..add(2)..add(3)..add(4);
@@ -28,7 +28,7 @@
});
test("error events are forwarded", () {
- var sink = new TestSink();
+ var sink = TestSink();
completer.setDestinationSink(sink);
completer.sink..addError("oh no")..addError("that's bad");
@@ -37,10 +37,10 @@
});
test("addStream is forwarded", () async {
- var sink = new TestSink();
+ var sink = TestSink();
completer.setDestinationSink(sink);
- var controller = new StreamController();
+ var controller = StreamController();
completer.sink.addStream(controller.stream);
controller.add(1);
@@ -61,15 +61,15 @@
});
test("close() is forwarded", () {
- var sink = new TestSink();
+ var sink = TestSink();
completer.setDestinationSink(sink);
completer.sink.close();
expect(sink.isClosed, isTrue);
});
test("the future from the inner close() is returned", () async {
- var closeCompleter = new Completer();
- var sink = new TestSink(onDone: () => closeCompleter.future);
+ var closeCompleter = Completer();
+ var sink = TestSink(onDone: () => closeCompleter.future);
completer.setDestinationSink(sink);
var closeCompleted = false;
@@ -86,14 +86,14 @@
});
test("errors are forwarded from the inner close()", () {
- var sink = new TestSink(onDone: () => throw "oh no");
+ var sink = TestSink(onDone: () => throw "oh no");
completer.setDestinationSink(sink);
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 = new TestSink(onDone: () => throw "oh no");
+ var sink = TestSink(onDone: () => throw "oh no");
completer.setDestinationSink(sink);
expect(completer.sink.close(), throwsA("oh no"));
@@ -102,7 +102,7 @@
});
test("errors aren't top-leveled if only done is listened to", () async {
- var sink = new 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"));
@@ -117,7 +117,7 @@
completer.sink..add(1)..add(2)..add(3)..add(4);
await flushMicrotasks();
- var sink = new TestSink();
+ var sink = TestSink();
completer.setDestinationSink(sink);
await flushMicrotasks();
@@ -131,7 +131,7 @@
completer.sink..addError("oh no")..addError("that's bad");
await flushMicrotasks();
- var sink = new TestSink();
+ var sink = TestSink();
completer.setDestinationSink(sink);
await flushMicrotasks();
@@ -140,7 +140,7 @@
});
test("addStream is forwarded", () async {
- var controller = new StreamController();
+ var controller = StreamController();
completer.sink.addStream(controller.stream);
controller.add(1);
@@ -150,7 +150,7 @@
controller.close();
await flushMicrotasks();
- var sink = new TestSink();
+ var sink = TestSink();
completer.setDestinationSink(sink);
await flushMicrotasks();
@@ -165,7 +165,7 @@
completer.sink.close();
await flushMicrotasks();
- var sink = new TestSink();
+ var sink = TestSink();
completer.setDestinationSink(sink);
await flushMicrotasks();
@@ -179,8 +179,8 @@
}));
await flushMicrotasks();
- var closeCompleter = new Completer();
- var sink = new TestSink(onDone: () => closeCompleter.future);
+ var closeCompleter = Completer();
+ var sink = TestSink(onDone: () => closeCompleter.future);
completer.setDestinationSink(sink);
await flushMicrotasks();
expect(closeCompleted, isFalse);
@@ -195,7 +195,7 @@
expect(completer.sink.close(), throwsA("oh no"));
await flushMicrotasks();
- var sink = new TestSink(onDone: () => throw "oh no");
+ var sink = TestSink(onDone: () => throw "oh no");
completer.setDestinationSink(sink);
});
@@ -203,7 +203,7 @@
expect(completer.sink.close(), throwsA("oh no"));
await flushMicrotasks();
- var sink = new 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.
@@ -215,7 +215,7 @@
expect(completer.sink.done, throwsA("oh no"));
await flushMicrotasks();
- var sink = new 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.
@@ -228,7 +228,7 @@
expect(completer.sink.close(), completes);
await flushMicrotasks();
- completer.setDestinationSink(new TestSink());
+ completer.setDestinationSink(TestSink());
await flushMicrotasks();
expect(completer.sink.done, completes);
@@ -239,7 +239,7 @@
expect(completer.sink.done, completes);
await flushMicrotasks();
- completer.setDestinationSink(new TestSink());
+ completer.setDestinationSink(TestSink());
await flushMicrotasks();
expect(completer.sink.close(), completes);
@@ -247,14 +247,14 @@
group("fromFuture()", () {
test("with a successful completion", () async {
- var futureCompleter = new Completer<StreamSink>();
+ var futureCompleter = Completer<StreamSink>();
var sink = StreamSinkCompleter.fromFuture(futureCompleter.future);
sink.add(1);
sink.add(2);
sink.add(3);
sink.close();
- var testSink = new TestSink();
+ var testSink = TestSink();
futureCompleter.complete(testSink);
await testSink.done;
@@ -264,7 +264,7 @@
});
test("with an error", () async {
- var futureCompleter = new Completer<StreamSink>();
+ var futureCompleter = Completer<StreamSink>();
var sink = StreamSinkCompleter.fromFuture(futureCompleter.future);
expect(sink.done, throwsA("oh no"));
futureCompleter.completeError("oh no");
@@ -288,10 +288,8 @@
});
test("doesn't allow the destination sink to be set multiple times", () {
- completer.setDestinationSink(new TestSink());
- expect(
- () => completer.setDestinationSink(new TestSink()), throwsStateError);
- expect(
- () => completer.setDestinationSink(new TestSink()), throwsStateError);
+ completer.setDestinationSink(TestSink());
+ expect(() => completer.setDestinationSink(TestSink()), throwsStateError);
+ expect(() => completer.setDestinationSink(TestSink()), throwsStateError);
});
}
diff --git a/test/stream_sink_transformer_test.dart b/test/stream_sink_transformer_test.dart
index 552bdaa..5e981a6 100644
--- a/test/stream_sink_transformer_test.dart
+++ b/test/stream_sink_transformer_test.dart
@@ -12,13 +12,13 @@
void main() {
StreamController controller;
setUp(() {
- controller = new StreamController();
+ controller = StreamController();
});
group("fromStreamTransformer", () {
test("transforms data events", () {
- var transformer = new StreamSinkTransformer.fromStreamTransformer(
- new StreamTransformer.fromHandlers(handleData: (i, sink) {
+ var transformer = StreamSinkTransformer.fromStreamTransformer(
+ StreamTransformer.fromHandlers(handleData: (i, sink) {
sink.add(i * 2);
}));
var sink = transformer.bind(controller.sink);
@@ -35,9 +35,8 @@
});
test("transforms error events", () {
- var transformer = new StreamSinkTransformer.fromStreamTransformer(
- new StreamTransformer.fromHandlers(
- handleError: (i, stackTrace, sink) {
+ var transformer = StreamSinkTransformer.fromStreamTransformer(
+ StreamTransformer.fromHandlers(handleError: (i, stackTrace, sink) {
sink.addError((i as num) * 2, stackTrace);
}));
var sink = transformer.bind(controller.sink);
@@ -57,8 +56,8 @@
});
test("transforms done events", () {
- var transformer = new StreamSinkTransformer.fromStreamTransformer(
- new StreamTransformer.fromHandlers(handleDone: (sink) {
+ var transformer = StreamSinkTransformer.fromStreamTransformer(
+ StreamTransformer.fromHandlers(handleDone: (sink) {
sink.add(1);
sink.close();
}));
@@ -73,16 +72,16 @@
});
test("forwards the future from inner.close", () async {
- var transformer = new StreamSinkTransformer.fromStreamTransformer(
- new StreamTransformer.fromHandlers());
- var innerSink = new CompleterStreamSink();
+ var transformer = StreamSinkTransformer.fromStreamTransformer(
+ StreamTransformer.fromHandlers());
+ var innerSink = CompleterStreamSink();
var sink = transformer.bind(innerSink);
// The futures shouldn't complete until the inner sink's close future
// completes.
- var doneResult = new ResultFuture(sink.done);
+ var doneResult = ResultFuture(sink.done);
doneResult.catchError((_) {});
- var closeResult = new ResultFuture(sink.close());
+ var closeResult = ResultFuture(sink.close());
closeResult.catchError((_) {});
await flushMicrotasks();
expect(doneResult.isComplete, isFalse);
@@ -96,11 +95,11 @@
});
test("doesn't top-level the future from inner.close", () async {
- var transformer = new StreamSinkTransformer.fromStreamTransformer(
- new StreamTransformer.fromHandlers(handleData: (_, sink) {
+ var transformer = StreamSinkTransformer.fromStreamTransformer(
+ StreamTransformer.fromHandlers(handleData: (_, sink) {
sink.close();
}));
- var innerSink = new CompleterStreamSink();
+ var innerSink = CompleterStreamSink();
var sink = transformer.bind(innerSink);
// This will close the inner sink, but it shouldn't top-level the error.
@@ -118,7 +117,7 @@
group("fromHandlers", () {
test("transforms data events", () {
var transformer =
- new StreamSinkTransformer.fromHandlers(handleData: (i, sink) {
+ StreamSinkTransformer.fromHandlers(handleData: (i, sink) {
sink.add(i * 2);
});
var sink = transformer.bind(controller.sink);
@@ -135,7 +134,7 @@
});
test("transforms error events", () {
- var transformer = new StreamSinkTransformer.fromHandlers(
+ var transformer = StreamSinkTransformer.fromHandlers(
handleError: (i, stackTrace, sink) {
sink.addError((i as num) * 2, stackTrace);
});
@@ -156,8 +155,7 @@
});
test("transforms done events", () {
- var transformer =
- new StreamSinkTransformer.fromHandlers(handleDone: (sink) {
+ var transformer = StreamSinkTransformer.fromHandlers(handleDone: (sink) {
sink.add(1);
sink.close();
});
@@ -172,15 +170,15 @@
});
test("forwards the future from inner.close", () async {
- var transformer = new StreamSinkTransformer.fromHandlers();
- var innerSink = new CompleterStreamSink();
+ var transformer = StreamSinkTransformer.fromHandlers();
+ var innerSink = CompleterStreamSink();
var sink = transformer.bind(innerSink);
// The futures shouldn't complete until the inner sink's close future
// completes.
- var doneResult = new ResultFuture(sink.done);
+ var doneResult = ResultFuture(sink.done);
doneResult.catchError((_) {});
- var closeResult = new ResultFuture(sink.close());
+ var closeResult = ResultFuture(sink.close());
closeResult.catchError((_) {});
await flushMicrotasks();
expect(doneResult.isComplete, isFalse);
@@ -195,10 +193,10 @@
test("doesn't top-level the future from inner.close", () async {
var transformer =
- new StreamSinkTransformer.fromHandlers(handleData: (_, sink) {
+ StreamSinkTransformer.fromHandlers(handleData: (_, sink) {
sink.close();
});
- var innerSink = new CompleterStreamSink();
+ var innerSink = CompleterStreamSink();
var sink = transformer.bind(innerSink);
// This will close the inner sink, but it shouldn't top-level the error.
diff --git a/test/stream_splitter_test.dart b/test/stream_splitter_test.dart
index c118b12..497f125 100644
--- a/test/stream_splitter_test.dart
+++ b/test/stream_splitter_test.dart
@@ -11,8 +11,8 @@
StreamController<int> controller;
StreamSplitter splitter;
setUp(() {
- controller = new StreamController<int>();
- splitter = new StreamSplitter<int>(controller.stream);
+ controller = StreamController<int>();
+ splitter = StreamSplitter<int>(controller.stream);
});
test("a branch that's created before the stream starts to replay it",
@@ -289,4 +289,4 @@
}
/// Wait for all microtasks to complete.
-Future flushMicrotasks() => new Future.delayed(Duration.zero);
+Future flushMicrotasks() => Future.delayed(Duration.zero);
diff --git a/test/stream_zip_test.dart b/test/stream_zip_test.dart
index 018c8ab..1e5f524 100644
--- a/test/stream_zip_test.dart
+++ b/test/stream_zip_test.dart
@@ -17,10 +17,10 @@
/// at periodic intervals.
Stream mks(Iterable iterable) {
Iterator iterator = iterable.iterator;
- StreamController controller = new StreamController();
+ StreamController controller = StreamController();
// Some varying time between 3 and 10 ms.
int ms = ((++ctr) * 5) % 7 + 3;
- new Timer.periodic(new Duration(milliseconds: ms), (Timer timer) {
+ Timer.periodic(Duration(milliseconds: ms), (Timer timer) {
if (iterator.moveNext()) {
controller.add(iterator.current);
} else {
@@ -38,7 +38,7 @@
// Test that zipping [streams] gives the results iterated by [expectedData].
testZip(Iterable<Stream> streams, Iterable expectedData) {
List data = [];
- Stream zip = new StreamZip(streams);
+ Stream zip = StreamZip(streams);
zip.listen(data.add, onDone: expectAsync0(() {
expect(data, equals(expectedData));
}));
@@ -145,9 +145,8 @@
test("Other-streams", () {
Stream st1 = mks([1, 2, 3, 4, 5, 6]).where((x) => x < 4);
Stream st2 =
- new Stream.periodic(const Duration(milliseconds: 5), (x) => x + 4)
- .take(3);
- StreamController c = new StreamController.broadcast();
+ Stream.periodic(const Duration(milliseconds: 5), (x) => x + 4).take(3);
+ StreamController c = StreamController.broadcast();
Stream st3 = c.stream;
testZip([
st1,
@@ -167,7 +166,7 @@
test("Error 1", () {
expect(
- new StreamZip([
+ StreamZip([
streamError(mks([1, 2, 3]), 2, "BAD-1"),
mks([4, 5, 6]),
mks([7, 8, 9])
@@ -177,7 +176,7 @@
test("Error 2", () {
expect(
- new StreamZip([
+ StreamZip([
mks([1, 2, 3]),
streamError(mks([4, 5, 6]), 5, "BAD-2"),
mks([7, 8, 9])
@@ -187,7 +186,7 @@
test("Error 3", () {
expect(
- new StreamZip([
+ StreamZip([
mks([1, 2, 3]),
mks([4, 5, 6]),
streamError(mks([7, 8, 9]), 8, "BAD-3")
@@ -197,7 +196,7 @@
test("Error at end", () {
expect(
- new StreamZip([
+ StreamZip([
mks([1, 2, 3]),
streamError(mks([4, 5, 6]), 6, "BAD-4"),
mks([7, 8, 9])
@@ -209,21 +208,21 @@
// StreamControllers' streams with no "close" called will never be done,
// so the fourth event of the first stream is guaranteed to come first.
expect(
- new StreamZip([
+ StreamZip([
streamError(mks([1, 2, 3, 4]), 4, "BAD-5"),
- (new StreamController()..add(4)..add(5)..add(6)).stream,
- (new StreamController()..add(7)..add(8)..add(9)).stream
+ (StreamController()..add(4)..add(5)..add(6)).stream,
+ (StreamController()..add(7)..add(8)..add(9)).stream
]).toList(),
throwsA(equals("BAD-5")));
});
test("Error after first end", () {
- StreamController controller = new StreamController();
+ StreamController 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 =
- new StreamTransformer.fromHandlers(handleDone: (EventSink s) {
+ StreamTransformer.fromHandlers(handleDone: (EventSink s) {
Timer.run(() {
controller.addError("BAD-6");
});
@@ -242,14 +241,14 @@
test("Pause/Resume", () {
int sc1p = 0;
- StreamController c1 = new StreamController(onPause: () {
+ StreamController c1 = StreamController(onPause: () {
sc1p++;
}, onResume: () {
sc1p--;
});
int sc2p = 0;
- StreamController c2 = new StreamController(onPause: () {
+ StreamController c2 = StreamController(onPause: () {
sc2p++;
}, onResume: () {
sc2p--;
@@ -260,12 +259,12 @@
expect(sc2p, equals(0));
}); // Call to complete test.
- Stream zip = new StreamZip([c1.stream, c2.stream]);
+ Stream zip = StreamZip([c1.stream, c2.stream]);
- const ms25 = const Duration(milliseconds: 25);
+ const ms25 = Duration(milliseconds: 25);
// StreamIterator uses pause and resume to control flow.
- StreamIterator it = new StreamIterator(zip);
+ StreamIterator it = StreamIterator(zip);
it.moveNext().then((hasMore) {
expect(hasMore, isTrue);
@@ -279,7 +278,7 @@
}).then((hasMore) {
expect(hasMore, isTrue);
expect(it.current, equals([5, 6]));
- new Future.delayed(ms25).then((_) {
+ Future.delayed(ms25).then((_) {
c2.add(8);
});
return it.moveNext();
@@ -303,18 +302,18 @@
});
test("pause-resume2", () {
- var s1 = new Stream.fromIterable([0, 2, 4, 6, 8]);
- var s2 = new Stream.fromIterable([1, 3, 5, 7]);
- var sz = new StreamZip([s1, s2]);
+ 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;
StreamSubscription sub;
sub = sz.listen(expectAsync1((v) {
expect(v, equals([ctr * 2, ctr * 2 + 1]));
if (ctr == 1) {
- sub.pause(new Future.delayed(const Duration(milliseconds: 25)));
+ sub.pause(Future.delayed(const Duration(milliseconds: 25)));
} else if (ctr == 2) {
sub.pause();
- new Future.delayed(const Duration(milliseconds: 25)).then((_) {
+ Future.delayed(const Duration(milliseconds: 25)).then((_) {
sub.resume();
});
}
diff --git a/test/stream_zip_zone_test.dart b/test/stream_zip_zone_test.dart
index a0773a6..c7756e6 100644
--- a/test/stream_zip_zone_test.dart
+++ b/test/stream_zip_zone_test.dart
@@ -10,19 +10,19 @@
main() {
StreamController controller;
- controller = new StreamController();
+ controller = StreamController();
testStream("singlesub-async", controller, controller.stream);
- controller = new StreamController.broadcast();
+ controller = StreamController.broadcast();
testStream("broadcast-async", controller, controller.stream);
- controller = new StreamController();
+ controller = StreamController();
testStream(
"asbroadcast-async", controller, controller.stream.asBroadcastStream());
- controller = new StreamController(sync: true);
+ controller = StreamController(sync: true);
testStream("singlesub-sync", controller, controller.stream);
- controller = new StreamController.broadcast(sync: true);
+ controller = StreamController.broadcast(sync: true);
testStream("broadcast-sync", controller, controller.stream);
- controller = new StreamController(sync: true);
+ controller = StreamController(sync: true);
testStream(
"asbroadcast-sync", controller, controller.stream.asBroadcastStream());
}
diff --git a/test/subscription_stream_test.dart b/test/subscription_stream_test.dart
index 804e92f..9460dec 100644
--- a/test/subscription_stream_test.dart
+++ b/test/subscription_stream_test.dart
@@ -13,7 +13,7 @@
test("subscription stream of an entire subscription", () async {
var stream = createStream();
var subscription = stream.listen(null);
- var subscriptionStream = new SubscriptionStream<int>(subscription);
+ var subscriptionStream = SubscriptionStream<int>(subscription);
await flushMicrotasks();
expect(subscriptionStream.toList(), completion([1, 2, 3, 4]));
});
@@ -21,13 +21,13 @@
test("subscription stream after two events", () async {
var stream = createStream();
var skips = 0;
- var completer = new Completer();
+ var completer = Completer();
StreamSubscription<int> subscription;
subscription = stream.listen((value) {
++skips;
expect(value, skips);
if (skips == 2) {
- completer.complete(new SubscriptionStream<int>(subscription));
+ completer.complete(SubscriptionStream<int>(subscription));
}
});
var subscriptionStream = await completer.future;
@@ -38,16 +38,16 @@
test("listening twice fails", () async {
var stream = createStream();
var sourceSubscription = stream.listen(null);
- var subscriptionStream = new SubscriptionStream<int>(sourceSubscription);
+ var subscriptionStream = SubscriptionStream<int>(sourceSubscription);
var subscription = subscriptionStream.listen(null);
expect(() => subscriptionStream.listen(null), throwsA(anything));
await subscription.cancel();
});
test("pause and cancel passed through to original stream", () async {
- var controller = new StreamController(onCancel: () async => 42);
+ var controller = StreamController(onCancel: () async => 42);
var sourceSubscription = controller.stream.listen(null);
- var subscriptionStream = new SubscriptionStream(sourceSubscription);
+ var subscriptionStream = SubscriptionStream(sourceSubscription);
expect(controller.isPaused, isTrue);
dynamic lastEvent;
var subscription = subscriptionStream.listen((value) {
@@ -75,16 +75,16 @@
SubscriptionStream subscriptionStream;
Future onCancel; // Completes if source stream is canceled before done.
setUp(() {
- var cancelCompleter = new Completer();
+ var cancelCompleter = Completer();
var source = createErrorStream(cancelCompleter);
onCancel = cancelCompleter.future;
var sourceSubscription =
source.listen(null, cancelOnError: sourceCancels);
- subscriptionStream = new SubscriptionStream<int>(sourceSubscription);
+ subscriptionStream = SubscriptionStream<int>(sourceSubscription);
});
test("- subscriptionStream: no", () async {
- var done = new Completer();
+ var done = Completer();
var events = [];
subscriptionStream.listen(events.add,
onError: events.add, onDone: done.complete, cancelOnError: false);
@@ -96,7 +96,7 @@
done.future.then((_) {
isDone = true;
});
- await new Future.delayed(const Duration(milliseconds: 5));
+ await Future.delayed(const Duration(milliseconds: 5));
expect(isDone, false);
} else {
expected.add(4);
@@ -106,7 +106,7 @@
});
test("- subscriptionStream: yes", () async {
- var completer = new Completer();
+ var completer = Completer();
var events = [];
subscriptionStream.listen(events.add,
onError: (value) {
@@ -128,7 +128,7 @@
var stream = createStream();
var sourceSubscription =
stream.listen(null, cancelOnError: cancelOnError);
- var subscriptionStream = new SubscriptionStream(sourceSubscription);
+ var subscriptionStream = SubscriptionStream(sourceSubscription);
var subscription =
subscriptionStream.listen(null, cancelOnError: cancelOnError);
expect(subscription.asFuture(42), completion(42));
@@ -138,7 +138,7 @@
var stream = createErrorStream();
var sourceSubscription =
stream.listen(null, cancelOnError: cancelOnError);
- var subscriptionStream = new SubscriptionStream(sourceSubscription);
+ var subscriptionStream = SubscriptionStream(sourceSubscription);
var subscription =
subscriptionStream.listen(null, cancelOnError: cancelOnError);
@@ -166,7 +166,7 @@
await flushMicrotasks();
yield 2;
await flushMicrotasks();
- yield* new Future<int>.error("To err is divine!").asStream();
+ yield* Future<int>.error("To err is divine!").asStream();
await flushMicrotasks();
yield 4;
await flushMicrotasks();
diff --git a/test/subscription_transformer_test.dart b/test/subscription_transformer_test.dart
index dbbf597..2a709a4 100644
--- a/test/subscription_transformer_test.dart
+++ b/test/subscription_transformer_test.dart
@@ -13,8 +13,8 @@
group("with no callbacks", () {
test("forwards cancellation", () async {
var isCanceled = false;
- var cancelCompleter = new Completer();
- var controller = new StreamController(onCancel: expectAsync0(() {
+ var cancelCompleter = Completer();
+ var controller = StreamController(onCancel: expectAsync0(() {
isCanceled = true;
return cancelCompleter.future;
}));
@@ -40,7 +40,7 @@
});
test("forwards pausing and resuming", () async {
- var controller = new StreamController();
+ var controller = StreamController();
var subscription = controller.stream
.transform(subscriptionTransformer())
.listen(expectAsync1((_) {}, count: 0));
@@ -63,12 +63,12 @@
});
test("forwards pausing with a resume future", () async {
- var controller = new StreamController();
+ var controller = StreamController();
var subscription = controller.stream
.transform(subscriptionTransformer())
.listen(expectAsync1((_) {}, count: 0));
- var completer = new Completer();
+ var completer = Completer();
subscription.pause(completer.future);
await flushMicrotasks();
expect(controller.isPaused, isTrue);
@@ -83,7 +83,7 @@
test("invokes the callback when the subscription is canceled", () async {
var isCanceled = false;
var callbackInvoked = false;
- var controller = new StreamController(onCancel: expectAsync0(() {
+ var controller = StreamController(onCancel: expectAsync0(() {
isCanceled = true;
}));
var subscription = controller.stream.transform(
@@ -103,8 +103,8 @@
});
test("invokes the callback once and caches its result", () async {
- var completer = new Completer();
- var controller = new StreamController();
+ var completer = Completer();
+ var controller = StreamController();
var subscription = controller.stream
.transform(subscriptionTransformer(
handleCancel: expectAsync1((inner) => completer.future)))
@@ -134,7 +134,7 @@
group("with a pause callback", () {
test("invokes the callback when pause is called", () async {
var pauseCount = 0;
- var controller = new StreamController();
+ var controller = StreamController();
var subscription = controller.stream
.transform(subscriptionTransformer(
handlePause: expectAsync1((inner) {
@@ -166,7 +166,7 @@
test("doesn't invoke the callback when the subscription has been canceled",
() async {
- var controller = new StreamController();
+ var controller = StreamController();
var subscription = controller.stream
.transform(subscriptionTransformer(
handlePause: expectAsync1((_) {}, count: 0)))
@@ -182,7 +182,7 @@
group("with a resume callback", () {
test("invokes the callback when resume is called", () async {
var resumeCount = 0;
- var controller = new StreamController();
+ var controller = StreamController();
var subscription = controller.stream
.transform(subscriptionTransformer(
handleResume: expectAsync1((inner) {
@@ -214,14 +214,14 @@
test("invokes the callback when a resume future completes", () async {
var resumed = false;
- var controller = new StreamController();
+ var controller = StreamController();
var subscription = controller.stream.transform(
subscriptionTransformer(handleResume: expectAsync1((inner) {
resumed = true;
inner.resume();
}))).listen(expectAsync1((_) {}, count: 0));
- var completer = new Completer();
+ var completer = Completer();
subscription.pause(completer.future);
await flushMicrotasks();
expect(resumed, isFalse);
@@ -233,7 +233,7 @@
test("doesn't invoke the callback when the subscription has been canceled",
() async {
- var controller = new StreamController();
+ var controller = StreamController();
var subscription = controller.stream
.transform(subscriptionTransformer(
handlePause: expectAsync1((_) {}, count: 0)))
@@ -249,7 +249,7 @@
group("when the outer subscription is canceled but the inner is not", () {
StreamSubscription subscription;
setUp(() {
- var controller = new StreamController();
+ var controller = StreamController();
subscription = controller.stream
.transform(subscriptionTransformer(handleCancel: (_) {}))
.listen(expectAsync1((_) {}, count: 0),
diff --git a/test/typed_wrapper/stream_subscription_test.dart b/test/typed_wrapper/stream_subscription_test.dart
index 50c07b6..bbec8f7 100644
--- a/test/typed_wrapper/stream_subscription_test.dart
+++ b/test/typed_wrapper/stream_subscription_test.dart
@@ -15,11 +15,10 @@
StreamSubscription wrapper;
bool isCanceled;
setUp(() {
- controller = new StreamController<Object>(onCancel: () {
+ controller = StreamController<Object>(onCancel: () {
isCanceled = true;
});
- wrapper =
- new TypeSafeStreamSubscription<int>(controller.stream.listen(null));
+ wrapper = TypeSafeStreamSubscription<int>(controller.stream.listen(null));
});
test("onData()", () {
@@ -72,11 +71,10 @@
StreamSubscription wrapper;
bool isCanceled;
setUp(() {
- controller = new StreamController<Object>(onCancel: () {
+ controller = StreamController<Object>(onCancel: () {
isCanceled = true;
});
- wrapper =
- new TypeSafeStreamSubscription<int>(controller.stream.listen(null));
+ wrapper = TypeSafeStreamSubscription<int>(controller.stream.listen(null));
});
group("throws a CastError for", () {
@@ -84,9 +82,9 @@
expect(() {
// TODO(nweiz): Use the wrapper declared in setUp when sdk#26226 is
// fixed.
- controller = new StreamController<Object>();
- wrapper = new TypeSafeStreamSubscription<int>(
- controller.stream.listen(null));
+ controller = StreamController<Object>();
+ wrapper =
+ TypeSafeStreamSubscription<int>(controller.stream.listen(null));
wrapper.onData(expectAsync1((_) {}, count: 0));
controller.add("foo");
diff --git a/test/utils.dart b/test/utils.dart
index 3f8c0ef..e517c78 100644
--- a/test/utils.dart
+++ b/test/utils.dart
@@ -9,9 +9,9 @@
import "package:test/test.dart";
/// A zero-millisecond timer should wait until after all microtasks.
-Future flushMicrotasks() => new Future.delayed(Duration.zero);
+Future flushMicrotasks() => Future.delayed(Duration.zero);
-typedef void OptionalArgAction([a, b]);
+typedef OptionalArgAction = void Function([dynamic a, dynamic b]);
/// A generic unreachable callback function.
///
@@ -38,17 +38,17 @@
/// A matcher that runs a callback in its own zone and asserts that that zone
/// emits a [CastError].
-final throwsZonedCastError = throwsZoned(new TypeMatcher<CastError>());
+final throwsZonedCastError = throwsZoned(TypeMatcher<CastError>());
/// A matcher that matches a callback or future that throws a [CastError].
-final throwsCastError = throwsA(new TypeMatcher<CastError>());
+final throwsCastError = throwsA(TypeMatcher<CastError>());
/// 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 new UnimplementedError("Gotcha!");
+ throw UnimplementedError("Gotcha!");
}
}
@@ -58,7 +58,7 @@
/// The [completer] field allows the user to control the future returned by
/// [done] and [close].
class CompleterStreamSink<T> implements StreamSink<T> {
- final completer = new Completer();
+ final completer = Completer();
Future get done => completer.future;
@@ -80,7 +80,7 @@
var _isClosed = false;
Future get done => _doneCompleter.future;
- final _doneCompleter = new Completer();
+ final _doneCompleter = Completer();
final Function _onDone;
@@ -91,22 +91,22 @@
TestSink({onDone()}) : _onDone = onDone ?? (() {});
void add(T event) {
- results.add(new Result<T>.value(event));
+ results.add(Result<T>.value(event));
}
void addError(error, [StackTrace stackTrace]) {
- results.add(new Result<T>.error(error, stackTrace));
+ results.add(Result<T>.error(error, stackTrace));
}
Future addStream(Stream<T> stream) {
- var completer = new Completer.sync();
+ var completer = Completer.sync();
stream.listen(add, onError: addError, onDone: completer.complete);
return completer.future;
}
Future close() {
_isClosed = true;
- _doneCompleter.complete(new Future.microtask(_onDone));
+ _doneCompleter.complete(Future.microtask(_onDone));
return done;
}
}
