Use UnmodifiableListView to expose read-only lists.

pkg/scheduled_test/lib/src/schedule.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library schedule;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:stack_trace/stack_trace.dart';
@@ skipping 44 matching lines @@
   /// Returns the [Task] that's currently executing, or `null` if there is no
   /// such task. This will be `null` both before the schedule starts running and
   /// after it's finished.
   Task get currentTask => _currentTask;
   Task _currentTask;
 
   /// The current state of the schedule.
   ScheduleState get state => _state;
   ScheduleState _state = ScheduleState.SET_UP;
 
-  // TODO(nweiz): make this a read-only view once issue 8321 is fixed.
   /// Errors thrown by the task queues.
   ///
   /// When running tasks in [tasks], this will always be empty. If an error
   /// occurs in [tasks], it will be added to this list and then [onException]
   /// will be run. If an error occurs there as well, it will be added to this
   /// list and [onComplete] will be run. Errors thrown during [onComplete] will
   /// also be added to this list, although no scheduled tasks will be run
   /// afterwards.
   ///
   /// Any out-of-band callbacks that throw errors will also have those errors
   /// added to this list.
-  final errors = <ScheduleError>[];
+  List<ScheduleError> get errors =>

[Bob Nystrom, 2013/04/22 22:11:40]

Is it worth exposing UnmodifiableListView in the type annotation so that callers
know they cannot modify it?

[nweiz, 2013/04/22 22:46:40]

I don't think so. I want the flexibility to swap out the implementation of these
fields without changing the API.

+      new UnmodifiableListView<ScheduleError>(_errors);
+  final _errors = <ScheduleError>[];
 
-  // TODO(nweiz): make this a read-only view once issue 8321 is fixed.
   /// Additional debugging info registered via [addDebugInfo].
-  final debugInfo = <String>[];
+  List<String> get debugInfo => new UnmodifiableListView<String>(_debugInfo);
+  final _debugInfo = <String>[];
 
   /// The task queue that's currently being run. One of [tasks], [onException],
   /// or [onComplete]. This starts as [tasks], and can only be `null` after the
   /// schedule is done.
   TaskQueue get currentQueue =>
     _state == ScheduleState.DONE ? null : _currentQueue;
   TaskQueue _currentQueue;
 
   /// The time to wait before terminating a task queue for inactivity. Defaults
   /// to 5 seconds. This can be set to `null` to disable timeouts entirely. Note
@@ skipping 113 matching lines @@
       throw scheduleError;
     } else {
       _currentQueue._signalError(scheduleError);
     }
   }
 
   /// Adds [info] to the debugging output that will be printed if the test
   /// fails. Unlike [signalError], this won't cause the test to fail, nor will
   /// it short-circuit the current [TaskQueue]; it's just useful for providing
   /// additional information that may not fit cleanly into an existing error.
-  void addDebugInfo(String info) => debugInfo.add(info);
+  void addDebugInfo(String info) => _debugInfo.add(info);
 
   /// Notifies the schedule of an error that occurred in a task or out-of-band
   /// callback after the appropriate queue has timed out. If this schedule is
   /// still running, the error will be added to the errors list to be shown
   /// along with the timeout error; otherwise, a top-level error will be thrown.
   void _signalPostTimeoutError(error, [stackTrace]) {
     var scheduleError = new ScheduleError.from(this, error,
         stackTrace: stackTrace);
     _addError(scheduleError);
     if (_state == ScheduleState.DONE) {
@@ skipping 85 matching lines @@
             "timed out after $_timeout of inactivity."));
       });
     }
   }
 
   /// Register an error in the schedule's error list. This ensures that there
   /// are no duplicate errors, and that all errors are wrapped in
   /// [ScheduleError].
   void _addError(error) {
     if (error is ScheduleError && errors.contains(error)) return;
-    errors.add(new ScheduleError.from(this, error));
+    _errors.add(new ScheduleError.from(this, error));
   }
 }
 
 /// An enum of states for a [Schedule].
 class ScheduleState {
   /// The schedule can have tasks added to its queue, but is not yet running
   /// them.
   static const SET_UP = const ScheduleState._("SET_UP");
 
   /// The schedule is actively running tasks. This includes running tasks in
   /// [Schedule.onException] and [Schedule.onComplete].
   static const RUNNING = const ScheduleState._("RUNNING");
 
   /// The schedule has finished running all its tasks, either successfully or
   /// with an error.
   static const DONE = const ScheduleState._("DONE");
 
   /// The name of the state.
   final String name;
 
   const ScheduleState._(this.name);
 
   String toString() => name;
 }
 
 /// A queue of asynchronous tasks to execute in order.
 class TaskQueue {
-  // TODO(nweiz): make this a read-only view when issue 8321 is fixed.
   /// The tasks in the queue.
-  Iterable<Task> get contents => _contents;
+  List<Task> get contents => new UnmodifiableListView<Task>(_contents);
   final _contents = new Queue<Task>();
 
   /// The name of the queue, for debugging purposes.
   final String name;
 
   /// If `true`, then new [Task]s in this queue will capture the current stack
   /// trace before running.
   bool get captureStackTraces => _schedule.captureStackTraces;
 
   /// The [Schedule] that created this queue.
   final Schedule _schedule;
 
   /// An out-of-band error signaled by [_schedule]. If this is non-null, it
   /// indicates that the queue should stop as soon as possible and re-throw this
   /// error.
   ScheduleError _error;
 
   /// The [SubstituteFuture] for the currently-running task in the queue, or
   /// null if no task is currently running.
   SubstituteFuture _taskFuture;
 
   /// The toal number of out-of-band callbacks that have been registered on
   /// [this].
   int _totalCallbacks = 0;
 
   /// Whether to stop running after the current task.
   bool _aborted = false;
 
-  // TODO(nweiz): make this a read-only view when issue 8321 is fixed.
   /// The descriptions of all callbacks that are blocking the completion of
   /// [this].
-  Iterable<String> get pendingCallbacks => _pendingCallbacks;
+  List<String> get pendingCallbacks =>
+      new UnmodifiableListView<String>(_pendingCallbacks);
   final _pendingCallbacks = new Queue<String>();
 
   /// A completer that will be completed once [_pendingCallbacks] becomes empty
   /// after the queue finishes running its tasks.
   Future get _noPendingCallbacks => _noPendingCallbacksCompleter.future;
   final Completer _noPendingCallbacksCompleter = new Completer();
 
   /// A [Future] that completes when the tasks in [this] are all complete. If an
   /// error occurs while running this queue, the returned [Future] will complete
   /// with that error.
@@ skipping 204 matching lines @@
           return prefixLines(childString,
               firstPrefix: "  $prefix ", prefix: "  | ");
         }).join('\n');
         taskString = '$taskString\n$childrenString';
       }
 
       return taskString;
     }).join("\n");
   }
 }