Joey Perrott d1ea1f4c7f build: update license headers to reference Google LLC ()
Update the license headers throughout the repository to reference Google LLC
rather than Google Inc, for the required license headers.

PR Close 
2020-05-26 14:26:58 -04:00

863 lines
29 KiB
TypeScript

/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
// test bluebird promise patch
// this spec will not be integrated with Travis CI, because I don't
// want to add bluebird into devDependencies, you can run this spec
// on your local environment
process.on('unhandledRejection', (reason, p) => {
console.log('Unhandled Rejection at:', p, 'reason:', reason);
// application specific logging, throwing an error, or other logic here
});
describe('bluebird promise', () => {
let BluebirdPromise: any;
beforeAll(() => {
BluebirdPromise = require('bluebird');
// import bluebird patch
require('../../lib/extra/bluebird');
const patchBluebird = (Zone as any)[(Zone as any).__symbol__('bluebird')];
patchBluebird(BluebirdPromise);
});
let log: string[];
const zone = Zone.root.fork({
name: 'bluebird',
onScheduleTask: (delegate, curr, targetZone, task) => {
log.push('schedule bluebird task ' + task.source);
return delegate.scheduleTask(targetZone, task);
},
onInvokeTask: (delegate, curr, target, task, applyThis, applyArgs) => {
log.push('invoke bluebird task ' + task.source);
return delegate.invokeTask(target, task, applyThis, applyArgs);
}
});
beforeEach(() => {
log = [];
});
it('bluebird promise then method should be in zone and treated as microTask', (done) => {
zone.run(() => {
const p = new BluebirdPromise((resolve: any, reject: any) => {
setTimeout(() => {
resolve('test');
}, 0);
});
p.then(() => {
expect(Zone.current.name).toEqual('bluebird');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
done();
});
});
});
it('bluebird promise catch method should be in zone and treated as microTask', (done) => {
zone.run(() => {
const p = new BluebirdPromise((resolve: any, reject: any) => {
setTimeout(() => {
reject('test');
}, 0);
});
p.catch(() => {
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise spread method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.all([BluebirdPromise.resolve('test1'), BluebirdPromise.resolve('test2')])
.spread((r1: string, r2: string) => {
expect(r1).toEqual('test1');
expect(r2).toEqual('test2');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise finally method should be in zone', (done) => {
zone.run(() => {
const p = new BluebirdPromise((resolve: any, reject: any) => {
setTimeout(() => {
resolve('test');
}, 0);
});
p.finally(() => {
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise join method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise
.join(
BluebirdPromise.resolve('test1'), BluebirdPromise.resolve('test2'),
(r1: string, r2: string) => {
expect(r1).toEqual('test1');
expect(r2).toEqual('test2');
expect(Zone.current.name).toEqual('bluebird');
})
.then(() => {
expect(Zone.current.name).toEqual('bluebird');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
done();
});
});
});
it('bluebird promise try method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise
.try(() => {
throw new Error('promise error');
})
.catch((err: Error) => {
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
expect(err.message).toEqual('promise error');
done();
});
});
});
it('bluebird promise method method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise
.method(() => {
return 'test';
})()
.then((result: string) => {
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
expect(result).toEqual('test');
done();
});
});
});
it('bluebird promise resolve method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.resolve('test').then((result: string) => {
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
expect(result).toEqual('test');
done();
});
});
});
it('bluebird promise reject method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.reject('error').catch((error: any) => {
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
expect(error).toEqual('error');
done();
});
});
});
it('bluebird promise all method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.all([BluebirdPromise.resolve('test1'), BluebirdPromise.resolve('test2')])
.then((r: string[]) => {
expect(r[0]).toEqual('test1');
expect(r[1]).toEqual('test2');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise props method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise
.props({test1: BluebirdPromise.resolve('test1'), test2: BluebirdPromise.resolve('test2')})
.then((r: any) => {
expect(r.test1).toEqual('test1');
expect(r.test2).toEqual('test2');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise any method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.any([BluebirdPromise.resolve('test1'), BluebirdPromise.resolve('test2')])
.then((r: any) => {
expect(r).toEqual('test1');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise some method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.some([BluebirdPromise.resolve('test1'), BluebirdPromise.resolve('test2')], 1)
.then((r: any) => {
expect(r.length).toBe(1);
expect(r[0]).toEqual('test1');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise map method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise
.map(
['test1', 'test2'],
(value: any) => {
return BluebirdPromise.resolve(value);
})
.then((r: string[]) => {
expect(r.length).toBe(2);
expect(r[0]).toEqual('test1');
expect(r[1]).toEqual('test2');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise reduce method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise
.reduce(
[1, 2],
(total: string, value: string) => {
return BluebirdPromise.resolve(total + value);
})
.then((r: number) => {
expect(r).toBe(3);
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBeTruthy();
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length)
.toBeTruthy();
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise filter method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise
.filter(
[1, 2, 3],
(value: number) => {
return value % 2 === 0 ? BluebirdPromise.resolve(true) :
BluebirdPromise.resolve(false);
})
.then((r: number[]) => {
expect(r[0]).toBe(2);
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise each method should be in zone', (done) => {
zone.run(() => {
const arr = [1, 2, 3];
BluebirdPromise
.each(
BluebirdPromise.map(arr, (item: number) => BluebirdPromise.resolve(item)),
(r: number, idx: number) => {
expect(r).toBe(arr[idx]);
expect(Zone.current.name).toEqual('bluebird');
})
.then((r: any) => {
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBeTruthy();
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length)
.toBeTruthy();
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise mapSeries method should be in zone', (done) => {
zone.run(() => {
const arr = [1, 2, 3];
BluebirdPromise
.mapSeries(
BluebirdPromise.map(arr, (item: number) => BluebirdPromise.resolve(item)),
(r: number, idx: number) => {
expect(r).toBe(arr[idx]);
expect(Zone.current.name).toEqual('bluebird');
})
.then((r: any) => {
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBeTruthy();
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length)
.toBeTruthy();
expect(Zone.current.name).toEqual('bluebird');
done();
});
;
});
});
it('bluebird promise race method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.race([BluebirdPromise.resolve('test1'), BluebirdPromise.resolve('test2')])
.then((r: string) => {
expect(r).toEqual('test1');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise using/disposer method should be in zone', (done) => {
zone.run(() => {
const p = new BluebirdPromise((resolve: Function, reject: any) => {
setTimeout(() => {
resolve('test');
}, 0);
});
p.leakObj = [];
const disposer = p.disposer(() => {
p.leakObj = null;
});
BluebirdPromise
.using(
disposer,
(v: string) => {
p.leakObj.push(v);
})
.then(() => {
expect(Zone.current.name).toEqual('bluebird');
expect(p.leakObj).toBe(null);
// using will generate several promise inside bluebird
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBeTruthy();
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length)
.toBeTruthy();
done();
});
});
});
it('bluebird promise promisify method should be in zone and treated as microTask', (done) => {
const func = (cb: Function) => {
setTimeout(() => {
cb(null, 'test');
}, 10);
};
const promiseFunc = BluebirdPromise.promisify(func);
zone.run(() => {
promiseFunc().then((r: string) => {
expect(Zone.current.name).toEqual('bluebird');
expect(r).toBe('test');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
done();
});
});
});
it('bluebird promise promisifyAll method should be in zone', (done) => {
const obj = {
func1: (cb: Function) => {
setTimeout(() => {
cb(null, 'test1');
}, 10);
},
func2: (cb: Function) => {
setTimeout(() => {
cb(null, 'test2');
}, 10);
},
};
const promiseObj = BluebirdPromise.promisifyAll(obj);
zone.run(() => {
BluebirdPromise.all([promiseObj.func1Async(), promiseObj.func2Async()])
.then((r: string[]) => {
expect(Zone.current.name).toEqual('bluebird');
expect(r[0]).toBe('test1');
expect(r[1]).toBe('test2');
// using will generate several promise inside
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
done();
});
});
});
it('bluebird promise fromCallback method should be in zone', (done) => {
const resolver = (cb: Function) => {
setTimeout(() => {
cb(null, 'test');
}, 10);
};
zone.run(() => {
BluebirdPromise.fromCallback(resolver).then((r: string) => {
expect(Zone.current.name).toEqual('bluebird');
expect(r).toBe('test');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
done();
});
});
});
it('bluebird promise asCallback method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.resolve('test').asCallback((err: Error, r: string) => {
expect(Zone.current.name).toEqual('bluebird');
expect(r).toBe('test');
done();
});
});
});
it('bluebird promise delay method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.resolve('test').delay(10).then((r: string) => {
expect(Zone.current.name).toEqual('bluebird');
expect(r).toBe('test');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
done();
});
});
});
it('bluebird promise timeout method should be in zone', (done) => {
zone.run(() => {
new BluebirdPromise((resolve: any, reject: any) => {
setTimeout(() => {
resolve('test');
}, 10);
})
.timeout(100)
.then((r: string) => {
expect(Zone.current.name).toEqual('bluebird');
expect(r).toBe('test');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
done();
});
});
});
it('bluebird promise tap method should be in zone', (done) => {
zone.run(() => {
const p = new BluebirdPromise((resolve: any, reject: any) => {
setTimeout(() => {
resolve('test');
}, 0);
});
p.tap(() => {
expect(Zone.current.name).toEqual('bluebird');
}).then(() => {
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise call method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise
.map(
['test1', 'test2'],
(value: any) => {
return BluebirdPromise.resolve(value);
})
.call(
'shift',
(value: any) => {
return value;
})
.then((r: string) => {
expect(r).toEqual('test1');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise get method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.resolve(['test1', 'test2']).get(-1).then((r: string) => {
expect(r).toEqual('test2');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise return method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.resolve().return('test1').then((r: string) => {
expect(r).toEqual('test1');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise throw method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.resolve().throw('test1').catch((r: string) => {
expect(r).toEqual('test1');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise catchReturn method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.reject().catchReturn('test1').then((r: string) => {
expect(r).toEqual('test1');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise catchThrow method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.reject().catchThrow('test1').catch((r: string) => {
expect(r).toEqual('test1');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise reflect method should be in zone', (done) => {
zone.run(() => {
const promises = [BluebirdPromise.resolve('test1'), BluebirdPromise.reject('test2')];
BluebirdPromise
.all(promises.map(promise => {
return promise.reflect();
}))
.each((r: any) => {
if (r.isFulfilled()) {
expect(r.value()).toEqual('test1');
} else {
expect(r.reason()).toEqual('test2');
done();
}
expect(Zone.current.name).toEqual('bluebird');
});
});
});
it('bluebird should be able to run into different zone', (done: Function) => {
Zone.current.fork({name: 'zone_A'}).run(() => {
new BluebirdPromise((resolve: any, reject: any) => {
expect(Zone.current.name).toEqual('zone_A');
resolve(1);
}).then((r: any) => {
expect(Zone.current.name).toEqual('zone_A');
});
});
Zone.current.fork({name: 'zone_B'}).run(() => {
new BluebirdPromise((resolve: any, reject: any) => {
expect(Zone.current.name).toEqual('zone_B');
resolve(2);
}).then((r: any) => {
expect(Zone.current.name).toEqual('zone_B');
done();
});
});
});
it('should be able to chain promise', (done: DoneFn) => {
Zone.current.fork({name: 'zone_A'}).run(() => {
new BluebirdPromise((resolve: any, reject: any) => {
expect(Zone.current.name).toEqual('zone_A');
resolve(1);
})
.then((r: any) => {
expect(r).toBe(1);
expect(Zone.current.name).toEqual('zone_A');
return Promise.resolve(2);
})
.then((r: any) => {
expect(r).toBe(2);
expect(Zone.current.name).toEqual('zone_A');
});
});
Zone.current.fork({name: 'zone_B'}).run(() => {
new BluebirdPromise((resolve: any, reject: any) => {
expect(Zone.current.name).toEqual('zone_B');
reject(1);
})
.then(
() => {
fail('should not be here.');
},
(r: any) => {
expect(r).toBe(1);
expect(Zone.current.name).toEqual('zone_B');
return Promise.resolve(2);
})
.then((r: any) => {
expect(r).toBe(2);
expect(Zone.current.name).toEqual('zone_B');
done();
});
});
});
it('should catch rejected chained bluebird promise', (done: DoneFn) => {
const logs: string[] = [];
const zone = Zone.current.fork({
name: 'testErrorHandling',
onHandleError: function() {
// should not get here
logs.push('onHandleError');
return true;
}
});
zone.runGuarded(() => {
return BluebirdPromise.resolve()
.then(() => {
throw new Error('test error');
})
.catch(() => {
expect(logs).toEqual([]);
done();
});
});
});
it('should catch rejected chained global promise', (done: DoneFn) => {
const logs: string[] = [];
const zone = Zone.current.fork({
name: 'testErrorHandling',
onHandleError: function() {
// should not get here
logs.push('onHandleError');
return true;
}
});
zone.runGuarded(() => {
return Promise.resolve()
.then(() => {
throw new Error('test error');
})
.catch(() => {
expect(logs).toEqual([]);
done();
});
});
});
it('should catch rejected bluebird promise', (done: DoneFn) => {
const logs: string[] = [];
const zone = Zone.current.fork({
name: 'testErrorHandling',
onHandleError: function() {
// should not get here
logs.push('onHandleError');
return true;
}
});
zone.runGuarded(() => {
return BluebirdPromise.reject().catch(() => {
expect(logs).toEqual([]);
done();
});
});
});
it('should catch rejected global promise', (done: DoneFn) => {
const logs: string[] = [];
const zone = Zone.current.fork({
name: 'testErrorHandling',
onHandleError: function() {
// should not get here
logs.push('onHandleError');
return true;
}
});
zone.runGuarded(() => {
return Promise.reject(new Error('reject')).catch(() => {
expect(logs).toEqual([]);
done();
});
});
});
it('should trigger onHandleError when unhandledRejection', (done: DoneFn) => {
const zone = Zone.current.fork({
name: 'testErrorHandling',
onHandleError: function() {
setTimeout(done, 100);
return true;
}
});
zone.runGuarded(() => {
return Promise.reject(new Error('reject'));
});
});
it('should trigger onHandleError when unhandledRejection in chained Promise', (done: DoneFn) => {
const zone = Zone.current.fork({
name: 'testErrorHandling',
onHandleError: function() {
setTimeout(done, 100);
return true;
}
});
zone.runGuarded(() => {
return Promise.resolve().then(() => {
throw new Error('test');
});
});
});
it('should not trigger unhandledrejection if zone.onHandleError return false', (done: DoneFn) => {
const listener = function() {
fail('should not be here');
};
if (typeof window !== 'undefined') {
window.addEventListener('unhandledrejection', listener);
} else if (typeof process !== 'undefined') {
process.on('unhandledRejection', listener);
}
const zone = Zone.current.fork({
name: 'testErrorHandling',
onHandleError: function() {
setTimeout(() => {
if (typeof window !== 'undefined') {
window.removeEventListener('unhandledrejection', listener);
} else if (typeof process !== 'undefined') {
process.removeListener('unhandledRejection', listener);
}
done();
}, 500);
return false;
}
});
zone.runGuarded(() => {
return Promise.resolve().then(() => {
throw new Error('test');
});
});
});
it('should trigger unhandledrejection if zone.onHandleError return true', (done: DoneFn) => {
const listener = function(event: any) {
if (typeof window !== 'undefined') {
expect(event.detail.reason.message).toEqual('test');
} else if (typeof process !== 'undefined') {
expect(event.message).toEqual('test');
}
if (typeof window !== 'undefined') {
window.removeEventListener('unhandledrejection', listener);
} else if (typeof process !== 'undefined') {
process.removeListener('unhandledRejection', listener);
}
done();
};
if (typeof window !== 'undefined') {
window.addEventListener('unhandledrejection', listener);
} else if (typeof process !== 'undefined') {
process.on('unhandledRejection', listener);
}
const zone = Zone.current.fork({
name: 'testErrorHandling',
onHandleError: function() {
return true;
}
});
zone.runGuarded(() => {
return Promise.resolve().then(() => {
throw new Error('test');
});
});
});
});