Index: third_party/pkg/angular/test/core/zone_spec.dart |
diff --git a/third_party/pkg/angular/test/core/zone_spec.dart b/third_party/pkg/angular/test/core/zone_spec.dart |
deleted file mode 100644 |
index a50b1c9a0802ff376b144d609ffe135809f91649..0000000000000000000000000000000000000000 |
--- a/third_party/pkg/angular/test/core/zone_spec.dart |
+++ /dev/null |
@@ -1,361 +0,0 @@ |
-library zone_spec; |
- |
-import '../_specs.dart'; |
- |
-import 'dart:async'; |
- |
-main() => describe('zone', () { |
- var zone; |
- var exceptionHandler; |
- beforeEach(module((Module module) { |
- exceptionHandler = new LoggingExceptionHandler(); |
- module.value(ExceptionHandler, exceptionHandler); |
- })); |
- |
- beforeEach(inject((Logger log, ExceptionHandler eh) { |
- zone = new NgZone(); |
- zone.onTurnDone = () { |
- log('onTurnDone'); |
- }; |
- zone.onError = (e, s, ls) => eh(e, s); |
- })); |
- |
- |
- describe('exceptions', () { |
- it('should rethrow exceptions from the body and call onError', () { |
- var error; |
- zone.onError = (e, s, l) => error = e; |
- expect(() { |
- zone.run(() { |
- throw ['hello']; |
- }); |
- }).toThrow('hello'); |
- expect(error).toEqual(['hello']); |
- }); |
- |
- |
- it('should call onError for errors from scheduleMicrotask', async(inject(() { |
- zone.run(() { |
- scheduleMicrotask(() { |
- throw ["async exception"]; |
- }); |
- }); |
- |
- expect(exceptionHandler.errors.length).toEqual(1); |
- expect(exceptionHandler.errors[0].error).toEqual(["async exception"]); |
- }))); |
- |
- |
- it('should allow executing code outside the zone', inject(() { |
- var zone = new NgZone(); |
- var outerZone = Zone.current; |
- var ngZone; |
- var outsideZone; |
- zone.run(() { |
- ngZone = Zone.current; |
- zone.runOutsideAngular(() { |
- outsideZone = Zone.current; |
- }); |
- }); |
- |
- expect(outsideZone).toEqual(outerZone); |
- expect(ngZone.parent).toEqual((outerZone)); |
- })); |
- |
- |
- it('should rethrow exceptions from the onTurnDone and call onError when the zone is sync', () { |
- zone.onTurnDone = () { |
- throw ["fromOnTurnDone"]; |
- }; |
- |
- expect(() { |
- zone.run(() { }); |
- }).toThrow('fromOnTurnDone'); |
- |
- expect(exceptionHandler.errors.length).toEqual(1); |
- expect(exceptionHandler.errors[0].error).toEqual(["fromOnTurnDone"]); |
- }); |
- |
- |
- it('should rethrow exceptions from the onTurnDone and call onError when the zone is async', () { |
- var asyncRan = false; |
- |
- zone.onTurnDone = () { |
- throw ["fromOnTurnDone"]; |
- }; |
- |
- expect(() { |
- zone.run(() { |
- scheduleMicrotask(() { |
- asyncRan = true; |
- }); |
- }); |
- }).toThrow('fromOnTurnDone'); |
- |
- expect(asyncRan).toBeTruthy(); |
- expect(exceptionHandler.errors.length).toEqual(1); |
- expect(exceptionHandler.errors[0].error).toEqual(["fromOnTurnDone"]); |
- }); |
- }); |
- |
- xdescribe('long stack traces', () { |
- it('should have nice error when crossing scheduleMicrotask boundries', async(inject(() { |
- var error; |
- var stack; |
- var longStacktrace; |
- |
- zone.onError = (e, s, f) { |
- error = e; |
- stack = s; |
- longStacktrace = f; |
- }; |
- var FRAME = new RegExp(r'.*\(.*\:(\d+):\d+\)'); |
- |
- var line = ((){ try {throw [];} catch(e, s) { return int.parse(FRAME.firstMatch('$s')[1]);}})(); |
- var throwFn = () { throw ['double zonned']; }; |
- var inner = () => zone.run(throwFn); |
- var middle = () => scheduleMicrotask(inner); |
- var outer = () => scheduleMicrotask(middle); |
- zone.run(outer); |
- |
- microLeap(); |
- expect(error).toEqual(['double zonned']); |
- |
- // Not in dart2js.. |
- if ('$stack'.contains('.dart.js')) { |
- return; |
- } |
- |
- expect('$stack').toContain('zone_spec.dart:${line+1}'); |
- expect('$stack').toContain('zone_spec.dart:${line+2}'); |
- expect('$longStacktrace').toContain('zone_spec.dart:${line+3}'); |
- expect('$longStacktrace').toContain('zone_spec.dart:${line+4}'); |
- expect('$longStacktrace').toContain('zone_spec.dart:${line+5}'); |
- }))); |
- }); |
- |
- it('should call onTurnDone after a synchronous block', inject((Logger log) { |
- zone.run(() { |
- log('run'); |
- }); |
- expect(log.result()).toEqual('run; onTurnDone'); |
- })); |
- |
- |
- it('should return the body return value from run', () { |
- expect(zone.run(() { return 6; })).toEqual(6); |
- }); |
- |
- |
- it('should call onTurnDone for a scheduleMicrotask in onTurnDone', async(inject((Logger log) { |
- var ran = false; |
- zone.onTurnDone = () { |
- if (!ran) { |
- scheduleMicrotask(() { ran = true; log('onTurnAsync'); }); |
- } |
- log('onTurnDone'); |
- }; |
- zone.run(() { |
- log('run'); |
- }); |
- microLeap(); |
- |
- expect(log.result()).toEqual('run; onTurnDone; onTurnAsync; onTurnDone'); |
- }))); |
- |
- |
- it('should call onTurnDone for a scheduleMicrotask in onTurnDone triggered by a scheduleMicrotask in run', async(inject((Logger log) { |
- var ran = false; |
- zone.onTurnDone = () { |
- if (!ran) { |
- scheduleMicrotask(() { ran = true; log('onTurnAsync'); }); |
- } |
- log('onTurnDone'); |
- }; |
- zone.run(() { |
- scheduleMicrotask(() { log('scheduleMicrotask'); }); |
- log('run'); |
- }); |
- microLeap(); |
- |
- expect(log.result()).toEqual('run; scheduleMicrotask; onTurnDone; onTurnAsync; onTurnDone'); |
- }))); |
- |
- |
- |
- it('should call onTurnDone once after a turn', async(inject((Logger log) { |
- zone.run(() { |
- log('run start'); |
- scheduleMicrotask(() { |
- log('async'); |
- }); |
- log('run end'); |
- }); |
- microLeap(); |
- |
- expect(log.result()).toEqual('run start; run end; async; onTurnDone'); |
- }))); |
- |
- |
- it('should work for Future.value as well', async(inject((Logger log) { |
- var futureRan = false; |
- zone.onTurnDone = () { |
- if (!futureRan) { |
- new Future.value(null).then((_) { log('onTurn future'); }); |
- futureRan = true; |
- } |
- log('onTurnDone'); |
- }; |
- |
- zone.run(() { |
- log('run start'); |
- new Future.value(null) |
- .then((_) { |
- log('future then'); |
- new Future.value(null) |
- .then((_) { log('future ?'); }); |
- return new Future.value(null); |
- }) |
- .then((_) { |
- log('future ?'); |
- }); |
- log('run end'); |
- }); |
- microLeap(); |
- |
- expect(log.result()).toEqual('run start; run end; future then; future ?; future ?; onTurnDone; onTurn future; onTurnDone'); |
- }))); |
- |
- |
- it('should call onTurnDone after each turn', async(inject((Logger log) { |
- Completer a, b; |
- zone.run(() { |
- a = new Completer(); |
- b = new Completer(); |
- a.future.then((_) => log('a then')); |
- b.future.then((_) => log('b then')); |
- log('run start'); |
- }); |
- microLeap(); |
- zone.run(() { |
- a.complete(null); |
- }); |
- microLeap(); |
- zone.run(() { |
- b.complete(null); |
- }); |
- microLeap(); |
- |
- expect(log.result()).toEqual('run start; onTurnDone; a then; onTurnDone; b then; onTurnDone'); |
- }))); |
- |
- |
- it('should call onTurnDone after each turn in a chain', async(inject((Logger log) { |
- zone.run(() { |
- log('run start'); |
- scheduleMicrotask(() { |
- log('async1'); |
- scheduleMicrotask(() { |
- log('async2'); |
- }); |
- }); |
- log('run end'); |
- }); |
- microLeap(); |
- |
- expect(log.result()).toEqual('run start; run end; async1; async2; onTurnDone'); |
- }))); |
- |
- it('should call onTurnDone for futures created outside of run body', async(inject((Logger log) { |
- var future = new Future.value(4).then((x) => new Future.value(x)); |
- zone.run(() { |
- future.then((_) => log('future then')); |
- log('zone run'); |
- }); |
- microLeap(); |
- |
- expect(log.result()).toEqual('zone run; onTurnDone; future then; onTurnDone'); |
- }))); |
- |
- |
- it('should call onTurnDone even if there was an exception in body', async(inject((Logger log) { |
- zone.onError = (e, s, l) => log('onError'); |
- expect(() => zone.run(() { |
- log('zone run'); |
- throw 'zoneError'; |
- })).toThrow('zoneError'); |
- expect(() => zone.assertInTurn()).toThrow(); |
- expect(log.result()).toEqual('zone run; onError; onTurnDone'); |
- }))); |
- |
- |
- it('should call onTurnDone even if there was an exception in scheduleMicrotask', async(inject((Logger log) { |
- zone.onError = (e, s, l) => log('onError'); |
- zone.run(() { |
- log('zone run'); |
- scheduleMicrotask(() { |
- log('scheduleMicrotask'); |
- throw new Error(); |
- }); |
- }); |
- |
- microLeap(); |
- |
- expect(() => zone.assertInTurn()).toThrow(); |
- expect(log.result()).toEqual('zone run; scheduleMicrotask; onError; onTurnDone'); |
- }))); |
- |
- it('should support assertInZone', async(() { |
- var calls = ''; |
- zone.onTurnDone = () { |
- zone.assertInZone(); |
- calls += 'done;'; |
- }; |
- zone.run(() { |
- zone.assertInZone(); |
- calls += 'sync;'; |
- scheduleMicrotask(() { |
- zone.assertInZone(); |
- calls += 'async;'; |
- }); |
- }); |
- |
- microLeap(); |
- expect(calls).toEqual('sync;async;done;'); |
- })); |
- |
- it('should throw outside of the zone', () { |
- expect(async(() { |
- zone.assertInZone(); |
- microLeap(); |
- })).toThrow(); |
- }); |
- |
- |
- it('should support assertInTurn', async(() { |
- var calls = ''; |
- zone.onTurnDone = () { |
- calls += 'done;'; |
- zone.assertInTurn(); |
- }; |
- zone.run(() { |
- calls += 'sync;'; |
- zone.assertInTurn(); |
- scheduleMicrotask(() { |
- calls += 'async;'; |
- zone.assertInTurn(); |
- }); |
- }); |
- |
- microLeap(); |
- expect(calls).toEqual('sync;async;done;'); |
- })); |
- |
- |
- it('should assertInTurn outside of the zone', () { |
- expect(async(() { |
- zone.assertInTurn(); |
- microLeap(); |
- })).toThrow('ssertion'); // Support both dart2js and the VM with half a word. |
- }); |
-}); |