OLD | NEW |
1 // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 import 'dart:async'; | 5 import 'dart:async'; |
6 import 'package:logging/logging.dart'; | 6 import 'package:logging/logging.dart'; |
7 import 'package:observe/observe.dart'; | 7 import 'package:observe/observe.dart'; |
8 import 'package:observe/src/dirty_check.dart' as dirty_check; | 8 import 'package:observe/src/dirty_check.dart' as dirty_check; |
9 import 'package:unittest/unittest.dart'; | 9 import 'package:unittest/unittest.dart'; |
10 import 'observe_test_utils.dart'; | 10 import 'observe_test_utils.dart'; |
11 | 11 |
12 void main() { | 12 main() => dirtyCheckZone().run(_tests); |
| 13 |
| 14 void _tests() { |
13 // Note: to test the basic Observable system, we use ObservableBox due to its | 15 // Note: to test the basic Observable system, we use ObservableBox due to its |
14 // simplicity. We also test a variant that is based on dirty-checking. | 16 // simplicity. We also test a variant that is based on dirty-checking. |
15 | 17 |
16 observeTest('no observers at the start', () { | 18 test('no observers at the start', () { |
17 expect(dirty_check.allObservablesCount, 0); | 19 expect(dirty_check.allObservablesCount, 0); |
18 }); | 20 }); |
19 | 21 |
20 group('WatcherModel', () => _observeTests((x) => new WatcherModel(x))); | 22 group('WatcherModel', () => _observeTests((x) => new WatcherModel(x))); |
21 | 23 |
22 group('ObservableBox', () => _observeTests((x) => new ObservableBox(x))); | 24 group('ObservableBox', () => _observeTests((x) => new ObservableBox(x))); |
23 | 25 |
24 group('ModelSubclass', () => _observeTests((x) => new ModelSubclass(x))); | 26 group('ModelSubclass', () => _observeTests((x) => new ModelSubclass(x))); |
25 | 27 |
26 group('dirtyCheck loops can be debugged', () { | 28 group('dirtyCheck loops can be debugged', () { |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
66 int initialObservers; | 68 int initialObservers; |
67 setUp(() { | 69 setUp(() { |
68 initialObservers = dirty_check.allObservablesCount; | 70 initialObservers = dirty_check.allObservablesCount; |
69 subs = []; | 71 subs = []; |
70 | 72 |
71 if (watch) scheduleMicrotask(Observable.dirtyCheck); | 73 if (watch) scheduleMicrotask(Observable.dirtyCheck); |
72 }); | 74 }); |
73 | 75 |
74 tearDown(() { | 76 tearDown(() { |
75 for (var sub in subs) sub.cancel(); | 77 for (var sub in subs) sub.cancel(); |
76 performMicrotaskCheckpoint(); | 78 return new Future(() { |
77 | 79 expect(dirty_check.allObservablesCount, initialObservers, |
78 expect(dirty_check.allObservablesCount, initialObservers, | 80 reason: 'Observable object leaked'); |
79 reason: 'Observable object leaked'); | 81 }); |
80 }); | 82 }); |
81 | 83 |
82 observeTest('handle future result', () { | 84 test('handle future result', () { |
83 var callback = expectAsync0((){}); | 85 var callback = expectAsync0((){}); |
84 return new Future(callback); | 86 return new Future(callback); |
85 }); | 87 }); |
86 | 88 |
87 observeTest('no observers', () { | 89 test('no observers', () { |
88 var t = createModel(123); | 90 var t = createModel(123); |
89 expect(t.value, 123); | 91 expect(t.value, 123); |
90 t.value = 42; | 92 t.value = 42; |
91 expect(t.value, 42); | 93 expect(t.value, 42); |
92 expect(t.hasObservers, false); | 94 expect(t.hasObservers, false); |
93 }); | 95 }); |
94 | 96 |
95 observeTest('listen adds an observer', () { | 97 test('listen adds an observer', () { |
96 var t = createModel(123); | 98 var t = createModel(123); |
97 expect(t.hasObservers, false); | 99 expect(t.hasObservers, false); |
98 | 100 |
99 subs.add(t.changes.listen((n) {})); | 101 subs.add(t.changes.listen((n) {})); |
100 expect(t.hasObservers, true); | 102 expect(t.hasObservers, true); |
101 }); | 103 }); |
102 | 104 |
103 observeTest('changes delived async', () { | 105 test('changes delived async', () { |
104 var t = createModel(123); | 106 var t = createModel(123); |
105 int called = 0; | 107 int called = 0; |
106 | 108 |
107 subs.add(t.changes.listen(expectAsync1((records) { | 109 subs.add(t.changes.listen(expectAsync1((records) { |
108 called++; | 110 called++; |
109 expectPropertyChanges(records, watch ? 1 : 2); | 111 expectPropertyChanges(records, watch ? 1 : 2); |
110 }))); | 112 }))); |
111 | 113 |
112 t.value = 41; | 114 t.value = 41; |
113 t.value = 42; | 115 t.value = 42; |
114 expect(called, 0); | 116 expect(called, 0); |
115 }); | 117 }); |
116 | 118 |
117 observeTest('cause changes in handler', () { | 119 test('cause changes in handler', () { |
118 var t = createModel(123); | 120 var t = createModel(123); |
119 int called = 0; | 121 int called = 0; |
120 | 122 |
121 subs.add(t.changes.listen(expectAsync1((records) { | 123 subs.add(t.changes.listen(expectAsync1((records) { |
122 called++; | 124 called++; |
123 expectPropertyChanges(records, 1); | 125 expectPropertyChanges(records, 1); |
124 if (called == 1) { | 126 if (called == 1) { |
125 // Cause another change | 127 // Cause another change |
126 t.value = 777; | 128 t.value = 777; |
127 } | 129 } |
128 }, count: 2))); | 130 }, count: 2))); |
129 | 131 |
130 t.value = 42; | 132 t.value = 42; |
131 }); | 133 }); |
132 | 134 |
133 observeTest('multiple observers', () { | 135 test('multiple observers', () { |
134 var t = createModel(123); | 136 var t = createModel(123); |
135 | 137 |
136 verifyRecords(records) { | 138 verifyRecords(records) { |
137 expectPropertyChanges(records, watch ? 1 : 2); | 139 expectPropertyChanges(records, watch ? 1 : 2); |
138 }; | 140 }; |
139 | 141 |
140 subs.add(t.changes.listen(expectAsync1(verifyRecords))); | 142 subs.add(t.changes.listen(expectAsync1(verifyRecords))); |
141 subs.add(t.changes.listen(expectAsync1(verifyRecords))); | 143 subs.add(t.changes.listen(expectAsync1(verifyRecords))); |
142 | 144 |
143 t.value = 41; | 145 t.value = 41; |
144 t.value = 42; | 146 t.value = 42; |
145 }); | 147 }); |
146 | 148 |
147 observeTest('performMicrotaskCheckpoint', () { | 149 test('async processing model', () { |
148 var t = createModel(123); | 150 var t = createModel(123); |
149 var records = []; | 151 var records = []; |
150 subs.add(t.changes.listen((r) { records.addAll(r); })); | 152 subs.add(t.changes.listen((r) { records.addAll(r); })); |
151 t.value = 41; | 153 t.value = 41; |
152 t.value = 42; | 154 t.value = 42; |
153 expectChanges(records, [], reason: 'changes delived async'); | 155 expectChanges(records, [], reason: 'changes delived async'); |
154 | 156 |
155 performMicrotaskCheckpoint(); | 157 return new Future(() { |
156 expectPropertyChanges(records, watch ? 1 : 2); | 158 expectPropertyChanges(records, watch ? 1 : 2); |
157 records.clear(); | 159 records.clear(); |
158 | 160 |
159 t.value = 777; | 161 t.value = 777; |
160 expectChanges(records, [], reason: 'changes delived async'); | 162 expectChanges(records, [], reason: 'changes delived async'); |
161 | 163 |
162 performMicrotaskCheckpoint(); | 164 }).then(newMicrotask).then((_) { |
163 expectPropertyChanges(records, 1); | 165 expectPropertyChanges(records, 1); |
164 | 166 |
165 // Has no effect if there are no changes | 167 // Has no effect if there are no changes |
166 performMicrotaskCheckpoint(); | 168 Observable.dirtyCheck(); |
167 expectPropertyChanges(records, 1); | 169 expectPropertyChanges(records, 1); |
| 170 }); |
168 }); | 171 }); |
169 | 172 |
170 observeTest('cancel listening', () { | 173 test('cancel listening', () { |
171 var t = createModel(123); | 174 var t = createModel(123); |
172 var sub; | 175 var sub; |
173 sub = t.changes.listen(expectAsync1((records) { | 176 sub = t.changes.listen(expectAsync1((records) { |
174 expectPropertyChanges(records, 1); | 177 expectPropertyChanges(records, 1); |
175 sub.cancel(); | 178 sub.cancel(); |
176 t.value = 777; | 179 t.value = 777; |
177 scheduleMicrotask(Observable.dirtyCheck); | 180 scheduleMicrotask(Observable.dirtyCheck); |
178 })); | 181 })); |
179 t.value = 42; | 182 t.value = 42; |
180 }); | 183 }); |
181 | 184 |
182 observeTest('cancel and reobserve', () { | 185 test('cancel and reobserve', () { |
183 var t = createModel(123); | 186 var t = createModel(123); |
184 var sub; | 187 var sub; |
185 sub = t.changes.listen(expectAsync1((records) { | 188 sub = t.changes.listen(expectAsync1((records) { |
186 expectPropertyChanges(records, 1); | 189 expectPropertyChanges(records, 1); |
187 sub.cancel(); | 190 sub.cancel(); |
188 | 191 |
189 scheduleMicrotask(expectAsync0(() { | 192 scheduleMicrotask(expectAsync0(() { |
190 subs.add(t.changes.listen(expectAsync1((records) { | 193 subs.add(t.changes.listen(expectAsync1((records) { |
191 expectPropertyChanges(records, 1); | 194 expectPropertyChanges(records, 1); |
192 }))); | 195 }))); |
193 t.value = 777; | 196 t.value = 777; |
194 scheduleMicrotask(Observable.dirtyCheck); | 197 scheduleMicrotask(Observable.dirtyCheck); |
195 })); | 198 })); |
196 })); | 199 })); |
197 t.value = 42; | 200 t.value = 42; |
198 }); | 201 }); |
199 | 202 |
200 observeTest('cannot modify changes list', () { | 203 test('cannot modify changes list', () { |
201 var t = createModel(123); | 204 var t = createModel(123); |
202 var records = null; | 205 var records = null; |
203 subs.add(t.changes.listen((r) { records = r; })); | 206 subs.add(t.changes.listen((r) { records = r; })); |
204 t.value = 42; | 207 t.value = 42; |
205 | 208 |
206 performMicrotaskCheckpoint(); | 209 return new Future(() { |
207 expectPropertyChanges(records, 1); | 210 expectPropertyChanges(records, 1); |
208 | 211 |
209 // Verify that mutation operations on the list fail: | 212 // Verify that mutation operations on the list fail: |
210 | 213 |
211 expect(() { | 214 expect(() { |
212 records[0] = new PropertyChangeRecord(t, #value, 0, 1); | 215 records[0] = new PropertyChangeRecord(t, #value, 0, 1); |
213 }, throwsUnsupportedError); | 216 }, throwsUnsupportedError); |
214 | 217 |
215 expect(() { records.clear(); }, throwsUnsupportedError); | 218 expect(() { records.clear(); }, throwsUnsupportedError); |
216 | 219 |
217 expect(() { records.length = 0; }, throwsUnsupportedError); | 220 expect(() { records.length = 0; }, throwsUnsupportedError); |
| 221 }); |
218 }); | 222 }); |
219 | 223 |
220 observeTest('notifyChange', () { | 224 test('notifyChange', () { |
221 var t = createModel(123); | 225 var t = createModel(123); |
222 var records = []; | 226 var records = []; |
223 subs.add(t.changes.listen((r) { records.addAll(r); })); | 227 subs.add(t.changes.listen((r) { records.addAll(r); })); |
224 t.notifyChange(new PropertyChangeRecord(t, #value, 123, 42)); | 228 t.notifyChange(new PropertyChangeRecord(t, #value, 123, 42)); |
225 | 229 |
226 performMicrotaskCheckpoint(); | 230 return new Future(() { |
227 expectPropertyChanges(records, 1); | 231 expectPropertyChanges(records, 1); |
228 expect(t.value, 123, reason: 'value did not actually change.'); | 232 expect(t.value, 123, reason: 'value did not actually change.'); |
| 233 }); |
229 }); | 234 }); |
230 | 235 |
231 observeTest('notifyPropertyChange', () { | 236 test('notifyPropertyChange', () { |
232 var t = createModel(123); | 237 var t = createModel(123); |
233 var records = null; | 238 var records = null; |
234 subs.add(t.changes.listen((r) { records = r; })); | 239 subs.add(t.changes.listen((r) { records = r; })); |
235 expect(t.notifyPropertyChange(#value, t.value, 42), 42, | 240 expect(t.notifyPropertyChange(#value, t.value, 42), 42, |
236 reason: 'notifyPropertyChange returns newValue'); | 241 reason: 'notifyPropertyChange returns newValue'); |
237 | 242 |
238 performMicrotaskCheckpoint(); | 243 return new Future(() { |
239 expectPropertyChanges(records, 1); | 244 expectPropertyChanges(records, 1); |
240 expect(t.value, 123, reason: 'value did not actually change.'); | 245 expect(t.value, 123, reason: 'value did not actually change.'); |
| 246 }); |
241 }); | 247 }); |
242 } | 248 } |
243 | 249 |
244 expectPropertyChanges(records, int number) { | 250 expectPropertyChanges(records, int number) { |
245 expect(records.length, number, reason: 'expected $number change records'); | 251 expect(records.length, number, reason: 'expected $number change records'); |
246 for (var record in records) { | 252 for (var record in records) { |
247 expect(record is PropertyChangeRecord, true, reason: | 253 expect(record is PropertyChangeRecord, true, reason: |
248 'record should be PropertyChangeRecord'); | 254 'record should be PropertyChangeRecord'); |
249 expect((record as PropertyChangeRecord).name, #value, reason: | 255 expect((record as PropertyChangeRecord).name, #value, reason: |
250 'record should indicate a change to the "value" property'); | 256 'record should indicate a change to the "value" property'); |
251 } | 257 } |
252 } | 258 } |
253 | 259 |
254 // A test model based on dirty checking. | 260 // A test model based on dirty checking. |
255 class WatcherModel<T> extends Observable { | 261 class WatcherModel<T> extends Observable { |
256 @observable T value; | 262 @observable T value; |
257 | 263 |
258 WatcherModel([T initialValue]) : value = initialValue; | 264 WatcherModel([T initialValue]) : value = initialValue; |
259 | 265 |
260 String toString() => '#<$runtimeType value: $value>'; | 266 String toString() => '#<$runtimeType value: $value>'; |
261 } | 267 } |
262 | 268 |
263 class ModelSubclass<T> extends WatcherModel<T> { | 269 class ModelSubclass<T> extends WatcherModel<T> { |
264 ModelSubclass([T initialValue]) : super(initialValue); | 270 ModelSubclass([T initialValue]) : super(initialValue); |
265 } | 271 } |
OLD | NEW |