/**

* @license

* Copyright Google Inc. 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

*/

import {patchFilteredProperties} from '../../lib/browser/property-descriptor';

import {patchEventTarget} from '../../lib/common/events';

import {isIEOrEdge, zoneSymbol} from '../../lib/common/utils';

import {getEdgeVersion, getIEVersion, ifEnvSupports, ifEnvSupportsWithDone, isEdge} from '../test-util';

import Spy = jasmine.Spy;

declare const global: any;

const noop = function() {};

function windowPrototype() {

return !!(global['Window'] && global['Window'].prototype);

}

function promiseUnhandleRejectionSupport() {

return !!global['PromiseRejectionEvent'];

}

function canPatchOnProperty(obj: any, prop: string) {

const func = function() {

if (!obj) {

return false;

}

const desc = Object.getOwnPropertyDescriptor(obj, prop);

if (!desc || !desc.configurable) {

return false;

}

return true;

};

(func as any).message = 'patchOnProperties';

return func;

}

let supportsPassive = false;

try {

const opts = Object.defineProperty({}, 'passive', {

get: function() {

supportsPassive = true;

}

});

window.addEventListener('test', opts as any, opts);

window.removeEventListener('test', opts as any, opts);

} catch (e) {

}

function supportEventListenerOptions() {

return supportsPassive;

}

(supportEventListenerOptions as any).message = 'supportsEventListenerOptions';

function supportCanvasTest() {

const HTMLCanvasElement = (window as any)['HTMLCanvasElement'];

const supportCanvas = typeof HTMLCanvasElement !== 'undefined' && HTMLCanvasElement.prototype &&

HTMLCanvasElement.prototype.toBlob;

const FileReader = (window as any)['FileReader'];

const supportFileReader = typeof FileReader !== 'undefined';

return supportCanvas && supportFileReader;

}

(supportCanvasTest as any).message = 'supportCanvasTest';

function ieOrEdge() {

return isIEOrEdge();

}

(ieOrEdge as any).message = 'IE/Edge Test';

class TestEventListener {

logs: string[] = [];

addEventListener(eventName: string, listener: any, options: any) {

this.logs.push(options);

}

removeEventListener(eventName: string, listener: any, options: any) {}

}

describe('Zone', function() {

const rootZone = Zone.current;

(Zone as any)[zoneSymbol('ignoreConsoleErrorUncaughtError')] = true;

describe('hooks', function() {

it('should allow you to override alert/prompt/confirm', function() {

const alertSpy = jasmine.createSpy('alert');

const promptSpy = jasmine.createSpy('prompt');

const confirmSpy = jasmine.createSpy('confirm');

const spies:

{[k: string]: Function} = {'alert': alertSpy, 'prompt': promptSpy, 'confirm': confirmSpy};

const myZone = Zone.current.fork({

name: 'spy',

onInvoke: (

parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone,

callback: Function, applyThis?: any, applyArgs?: any[], source?: string): any => {

if (source) {

spies[source].apply(null, applyArgs);

} else {

return parentZoneDelegate.invoke(targetZone, callback, applyThis, applyArgs, source);

}

}

});

myZone.run(function() {

alert('alertMsg');

prompt('promptMsg', 'default');

confirm('confirmMsg');

});

expect(alertSpy).toHaveBeenCalledWith('alertMsg');

expect(promptSpy).toHaveBeenCalledWith('promptMsg', 'default');

expect(confirmSpy).toHaveBeenCalledWith('confirmMsg');

});

describe(

'DOM onProperty hooks',

ifEnvSupports(canPatchOnProperty(HTMLElement.prototype, 'onclick'), function() {

let mouseEvent = document.createEvent('Event');

let hookSpy: Spy, eventListenerSpy: Spy;

const zone = rootZone.fork({

name: 'spy',

onScheduleTask:

(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task):

any => {

hookSpy();

return parentZoneDelegate.scheduleTask(targetZone, task);

}

});

beforeEach(function() {

mouseEvent.initEvent('mousedown', true, true);

hookSpy = jasmine.createSpy('hook');

eventListenerSpy = jasmine.createSpy('eventListener');

});

function checkIsOnPropertiesPatched(target: any, ignoredProperties?: string[]) {

for (let prop in target) {

if (ignoredProperties &&

ignoredProperties.filter(ignoreProp => ignoreProp === prop).length > 0) {

continue;

}

if (prop.substr(0, 2) === 'on' && prop.length > 2) {

target[prop] = noop;

if (!target[Zone.__symbol__('ON_PROPERTY' + prop.substr(2))]) {

console.log('onProp is null:', prop);

} else {

target[prop] = null;

expect(!target[Zone.__symbol__('ON_PROPERTY' + prop.substr(2))]).toBeTruthy();

}

}

}

}

it('should patch all possbile on properties on element', function() {

const htmlElementTagNames: string[] = [

'a', 'area', 'audio', 'base', 'basefont', 'blockquote', 'br',

'button', 'canvas', 'caption', 'col', 'colgroup', 'data', 'datalist',

'del', 'dir', 'div', 'dl', 'embed', 'fieldset', 'font',

'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4',

'h5', 'h6', 'head', 'hr', 'html', 'iframe', 'img',

'input', 'ins', 'isindex', 'label', 'legend', 'li', 'link',

'listing', 'map', 'marquee', 'menu', 'meta', 'meter', 'nextid',

'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture',

'pre', 'progress', 'q', 'script', 'select', 'source', 'span',

'style', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot',

'th', 'thead', 'time', 'title', 'tr', 'track', 'ul',

'video'

];

htmlElementTagNames.forEach(tagName => {

checkIsOnPropertiesPatched(document.createElement(tagName), ['onorientationchange']);

});

});

it('should patch all possbile on properties on body', function() {

checkIsOnPropertiesPatched(document.body, ['onorientationchange']);

});

it('should patch all possbile on properties on Document', function() {

checkIsOnPropertiesPatched(document, ['onorientationchange']);

});

it('should patch all possbile on properties on Window', function() {

checkIsOnPropertiesPatched(window, [

'onvrdisplayactivate', 'onvrdisplayblur', 'onvrdisplayconnect',

'onvrdisplaydeactivate', 'onvrdisplaydisconnect', 'onvrdisplayfocus',

'onvrdisplaypointerrestricted', 'onvrdisplaypointerunrestricted',

'onorientationchange', 'onerror'

]);

});

it('should patch all possbile on properties on xhr', function() {

checkIsOnPropertiesPatched(new XMLHttpRequest());

});

it('should not patch ignored on properties', function() {

const TestTarget: any = (window as any)['TestTarget'];

patchFilteredProperties(

TestTarget.prototype, ['prop1', 'prop2'], global['__Zone_ignore_on_properties']);

const testTarget = new TestTarget();

Zone.current.fork({name: 'test'}).run(() => {

testTarget.onprop1 = function() {

// onprop1 should not be patched

expect(Zone.current.name).toEqual('test1');

};

testTarget.onprop2 = function() {

// onprop2 should be patched

expect(Zone.current.name).toEqual('test');

};

});

Zone.current.fork({name: 'test1'}).run(() => {

testTarget.dispatchEvent('prop1');

testTarget.dispatchEvent('prop2');

});

});

it('should not patch ignored eventListener', function() {

let scrollEvent = document.createEvent('Event');

scrollEvent.initEvent('scroll', true, true);

const zone = Zone.current.fork({name: 'run'});

Zone.current.fork({name: 'scroll'}).run(() => {

document.addEventListener('scroll', () => {

expect(Zone.current.name).toEqual(zone.name);

});

});

zone.run(() => {

document.dispatchEvent(scrollEvent);

});

});

it('should be able to clear on handler added before load zone.js', function() {

const TestTarget: any = (window as any)['TestTarget'];

patchFilteredProperties(

TestTarget.prototype, ['prop3'], global['__Zone_ignore_on_properties']);

const testTarget = new TestTarget();

Zone.current.fork({name: 'test'}).run(() => {

expect(testTarget.onprop3).toBeTruthy();

const newProp3Handler = function() {};

testTarget.onprop3 = newProp3Handler;

expect(testTarget.onprop3).toBe(newProp3Handler);

testTarget.onprop3 = null;

expect(!testTarget.onprop3).toBeTruthy();

testTarget.onprop3 = function() {

// onprop1 should not be patched

expect(Zone.current.name).toEqual('test');

};

});

Zone.current.fork({name: 'test1'}).run(() => {

testTarget.dispatchEvent('prop3');

});

});

it('window onclick should be in zone',

ifEnvSupports(canPatchOnProperty(window, 'onmousedown'), function() {

zone.run(function() {

window.onmousedown = eventListenerSpy;

});

window.dispatchEvent(mouseEvent);

expect(hookSpy).toHaveBeenCalled();

expect(eventListenerSpy).toHaveBeenCalled();

window.removeEventListener('mousedown', eventListenerSpy);

}));

it('window onresize should be patched',

ifEnvSupports(canPatchOnProperty(window, 'onmousedown'), function() {

window.onresize = eventListenerSpy;

const innerResizeProp: any = (window as any)[zoneSymbol('ON_PROPERTYresize')];

expect(innerResizeProp).toBeTruthy();

innerResizeProp();

expect(eventListenerSpy).toHaveBeenCalled();

window.removeEventListener('resize', eventListenerSpy);

}));

it('document onclick should be in zone',

ifEnvSupports(canPatchOnProperty(Document.prototype, 'onmousedown'), function() {

zone.run(function() {

document.onmousedown = eventListenerSpy;

});

document.dispatchEvent(mouseEvent);

expect(hookSpy).toHaveBeenCalled();

expect(eventListenerSpy).toHaveBeenCalled();

document.removeEventListener('mousedown', eventListenerSpy);

}));

it('event handler with null context should use event.target',

ifEnvSupports(canPatchOnProperty(Document.prototype, 'onmousedown'), function() {

const ieVer = getIEVersion();

if (ieVer && ieVer === 9) {

// in ie9, this is window object even we call func.apply(undefined)

return;

}

const logs: string[] = [];

const EventTarget = (window as any)['EventTarget'];

let oriAddEventListener = EventTarget && EventTarget.prototype ?

(EventTarget.prototype as any)[zoneSymbol('addEventListener')] :

(HTMLSpanElement.prototype as any)[zoneSymbol('addEventListener')];

if (!oriAddEventListener) {

// no patched addEventListener found

return;

}

let handler1: Function;

let handler2: Function;

const listener = function() {

logs.push('listener1');

};

const listener1 = function() {

logs.push('listener2');

};

HTMLSpanElement.prototype.addEventListener = function(

eventName: string, callback: any) {

if (eventName === 'click') {

handler1 = callback;

} else if (eventName === 'mousedown') {

handler2 = callback;

}

return oriAddEventListener.apply(this, arguments);

};

(HTMLSpanElement.prototype as any)[zoneSymbol('addEventListener')] = null;

patchEventTarget(window, [HTMLSpanElement.prototype]);

const span = document.createElement('span');

document.body.appendChild(span);

zone.run(function() {

span.addEventListener('click', listener);

span.onmousedown = listener1;

});

expect(handler1!).toBe(handler2!);

handler1!.apply(undefined, [{type: 'click', target: span}]);

handler2!.apply(undefined, [{type: 'mousedown', target: span}]);

expect(hookSpy).toHaveBeenCalled();

expect(logs).toEqual(['listener1', 'listener2']);

document.body.removeChild(span);

if (EventTarget) {

(EventTarget.prototype as any)[zoneSymbol('addEventListener')] =

oriAddEventListener;

} else {

(HTMLSpanElement.prototype as any)[zoneSymbol('addEventListener')] =

oriAddEventListener;

}

}));

it('SVGElement onclick should be in zone',

ifEnvSupports(

canPatchOnProperty(SVGElement && SVGElement.prototype, 'onmousedown'), function() {

const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');

document.body.appendChild(svg);

zone.run(function() {

svg.onmousedown = eventListenerSpy;

});

svg.dispatchEvent(mouseEvent);

expect(hookSpy).toHaveBeenCalled();

expect(eventListenerSpy).toHaveBeenCalled();

svg.removeEventListener('mouse', eventListenerSpy);

document.body.removeChild(svg);

}));

it('get window onerror should not throw error',

ifEnvSupports(canPatchOnProperty(window, 'onerror'), function() {

const testFn = function() {

let onerror = window.onerror;

window.onerror = function() {};

onerror = window.onerror;

};

expect(testFn).not.toThrow();

}));

it('window.onerror callback signiture should be (message, source, lineno, colno, error)',

ifEnvSupportsWithDone(canPatchOnProperty(window, 'onerror'), function(done: DoneFn) {

let testError = new Error('testError');

window.onerror = function(

message: any, source?: string, lineno?: number, colno?: number, error?: any) {

expect(message).toContain('testError');

if (getEdgeVersion() !== 14) {

// Edge 14, error will be undefined.

expect(error).toBe(testError);

}

(window as any).onerror = null;

setTimeout(done);

return true;

};

setTimeout(() => {

throw testError;

}, 100);

}));

}));

describe('eventListener hooks', function() {

let button: HTMLButtonElement;

let clickEvent: Event;

beforeEach(function() {

button = document.createElement('button');

clickEvent = document.createEvent('Event');

clickEvent.initEvent('click', true, true);

document.body.appendChild(button);

});

afterEach(function() {

document.body.removeChild(button);

});

it('should support addEventListener', function() {

const hookSpy = jasmine.createSpy('hook');

const eventListenerSpy = jasmine.createSpy('eventListener');

const zone = rootZone.fork({

name: 'spy',

onScheduleTask:

(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task):

any => {

hookSpy();

return parentZoneDelegate.scheduleTask(targetZone, task);

}

});

zone.run(function() {

button.addEventListener('click', eventListenerSpy);

});

button.dispatchEvent(clickEvent);

expect(hookSpy).toHaveBeenCalled();

expect(eventListenerSpy).toHaveBeenCalled();

});

it('should be able to access addEventListener information in onScheduleTask', function() {

const hookSpy = jasmine.createSpy('hook');

const eventListenerSpy = jasmine.createSpy('eventListener');

let scheduleButton;

let scheduleEventName;

let scheduleCapture;

let scheduleTask;

const zone = rootZone.fork({

name: 'spy',

onScheduleTask:

(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task):

any => {

hookSpy();

scheduleButton = (task.data as any).taskData.target;

scheduleEventName = (task.data as any).taskData.eventName;

scheduleCapture = (task.data as any).taskData.capture;

scheduleTask = task;

return parentZoneDelegate.scheduleTask(targetZone, task);

}

});

zone.run(function() {

button.addEventListener('click', eventListenerSpy);

});

button.dispatchEvent(clickEvent);

expect(hookSpy).toHaveBeenCalled();

expect(eventListenerSpy).toHaveBeenCalled();

expect(scheduleButton).toBe(button);

expect(scheduleEventName).toBe('click');

expect(scheduleCapture).toBe(false);

expect(scheduleTask && (scheduleTask as any).data.taskData).toBe(null);

});

it('should support addEventListener on window', ifEnvSupports(windowPrototype, function() {

const hookSpy = jasmine.createSpy('hook');

const eventListenerSpy = jasmine.createSpy('eventListener');

const zone = rootZone.fork({

name: 'spy',

onScheduleTask: (

parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task):

any => {

hookSpy();

return parentZoneDelegate.scheduleTask(targetZone, task);

}

});

zone.run(function() {

window.addEventListener('click', eventListenerSpy);

});

window.dispatchEvent(clickEvent);

expect(hookSpy).toHaveBeenCalled();

expect(eventListenerSpy).toHaveBeenCalled();

}));

it('should support removeEventListener', function() {

const hookSpy = jasmine.createSpy('hook');

const eventListenerSpy = jasmine.createSpy('eventListener');

const zone = rootZone.fork({

name: 'spy',

onCancelTask:

(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task):

any => {

hookSpy();

return parentZoneDelegate.cancelTask(targetZone, task);

}

});

zone.run(function() {

button.addEventListener('click', eventListenerSpy);

button.removeEventListener('click', eventListenerSpy);

});

button.dispatchEvent(clickEvent);

expect(hookSpy).toHaveBeenCalled();

expect(eventListenerSpy).not.toHaveBeenCalled();

});

describe(

'should support addEventListener/removeEventListener with AddEventListenerOptions with capture setting',

ifEnvSupports(supportEventListenerOptions, function() {

let hookSpy: Spy;

let cancelSpy: Spy;

let logs: string[];

const zone = rootZone.fork({

name: 'spy',

onScheduleTask:

(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone,

task: Task): any => {

hookSpy();

return parentZoneDelegate.scheduleTask(targetZone, task);

},

onCancelTask:

(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone,

task: Task): any => {

cancelSpy();

return parentZoneDelegate.cancelTask(targetZone, task);

}

});

const docListener = () => {

logs.push('document');

};

const btnListener = () => {

logs.push('button');

};

beforeEach(() => {

logs = [];

hookSpy = jasmine.createSpy('hook');

cancelSpy = jasmine.createSpy('cancel');

});

it('should handle child event when addEventListener with capture true', () => {

// test capture true

zone.run(function() {

(document as any).addEventListener('click', docListener, {capture: true});

button.addEventListener('click', btnListener);

});

button.dispatchEvent(clickEvent);

expect(hookSpy).toHaveBeenCalled();

expect(logs).toEqual(['document', 'button']);

logs = [];

(document as any).removeEventListener('click', docListener, {capture: true});

button.removeEventListener('click', btnListener);

expect(cancelSpy).toHaveBeenCalled();

button.dispatchEvent(clickEvent);

expect(logs).toEqual([]);

});

it('should handle child event when addEventListener with capture true', () => {

// test capture false

zone.run(function() {

(document as any).addEventListener('click', docListener, {capture: false});

button.addEventListener('click', btnListener);

});

button.dispatchEvent(clickEvent);

expect(hookSpy).toHaveBeenCalled();

expect(logs).toEqual(['button', 'document']);

logs = [];

(document as any).removeEventListener('click', docListener, {capture: false});

button.removeEventListener('click', btnListener);

expect(cancelSpy).toHaveBeenCalled();

button.dispatchEvent(clickEvent);

expect(logs).toEqual([]);

});

}));

describe(

'should ignore duplicate event handler',

ifEnvSupports(supportEventListenerOptions, function() {

let hookSpy: Spy;

let cancelSpy: Spy;

let logs: string[];

const zone = rootZone.fork({

name: 'spy',

onScheduleTask:

(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone,

task: Task): any => {

hookSpy();

return parentZoneDelegate.scheduleTask(targetZone, task);

},

onCancelTask:

(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone,

task: Task): any => {

cancelSpy();

return parentZoneDelegate.cancelTask(targetZone, task);

}

});

const docListener = () => {

logs.push('document options');

};

beforeEach(() => {

logs = [];

hookSpy = jasmine.createSpy('hook');

cancelSpy = jasmine.createSpy('cancel');

});

const testDuplicate = function(args1?: any, args2?: any) {

zone.run(function() {

if (args1) {

(document as any).addEventListener('click', docListener, args1);

} else {

(document as any).addEventListener('click', docListener);

}

if (args2) {

(document as any).addEventListener('click', docListener, args2);

} else {

(document as any).addEventListener('click', docListener);

}

});

button.dispatchEvent(clickEvent);

expect(hookSpy).toHaveBeenCalled();

expect(logs).toEqual(['document options']);

logs = [];

(document as any).removeEventListener('click', docListener, args1);

expect(cancelSpy).toHaveBeenCalled();

button.dispatchEvent(clickEvent);

expect(logs).toEqual([]);

};

it('should ignore duplicate handler', () => {

let captureFalse = [

undefined, false, {capture: false}, {capture: false, passive: false},

{passive: false}, {}

];

let captureTrue = [true, {capture: true}, {capture: true, passive: false}];

for (let i = 0; i < captureFalse.length; i++) {

for (let j = 0; j < captureFalse.length; j++) {

testDuplicate(captureFalse[i], captureFalse[j]);

}

}

for (let i = 0; i < captureTrue.length; i++) {

for (let j = 0; j < captureTrue.length; j++) {

testDuplicate(captureTrue[i], captureTrue[j]);

}

}

});

}));

describe(

'should support mix useCapture with AddEventListenerOptions capture',

ifEnvSupports(supportEventListenerOptions, function() {

let hookSpy: Spy;

let cancelSpy: Spy;

let logs: string[];

const zone = rootZone.fork({

name: 'spy',

onScheduleTask:

(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone,

task: Task): any => {

hookSpy();

return parentZoneDelegate.scheduleTask(targetZone, task);

},

onCancelTask:

(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone,

task: Task): any => {

cancelSpy();

return parentZoneDelegate.cancelTask(targetZone, task);

}

});

const docListener = () => {

logs.push('document options');

};

const docListener1 = () => {

logs.push('document useCapture');

};

const btnListener = () => {

logs.push('button');

};

beforeEach(() => {

logs = [];

hookSpy = jasmine.createSpy('hook');

cancelSpy = jasmine.createSpy('cancel');

});

const testAddRemove = function(args1?: any, args2?: any) {

zone.run(function() {

if (args1) {

(document as any).addEventListener('click', docListener, args1);

} else {

(document as any).addEventListener('click', docListener);

}

if (args2) {

(document as any).removeEventListener('click', docListener, args2);

} else {

(document as any).removeEventListener('click', docListener);

}

});

button.dispatchEvent(clickEvent);

expect(cancelSpy).toHaveBeenCalled();

expect(logs).toEqual([]);

};

it('should be able to add/remove same handler with mix options and capture',

function() {

let captureFalse = [

undefined, false, {capture: false}, {capture: false, passive: false},

{passive: false}, {}

];

let captureTrue = [true, {capture: true}, {capture: true, passive: false}];

for (let i = 0; i < captureFalse.length; i++) {

for (let j = 0; j < captureFalse.length; j++) {

testAddRemove(captureFalse[i], captureFalse[j]);

}

}

for (let i = 0; i < captureTrue.length; i++) {

for (let j = 0; j < captureTrue.length; j++) {

testAddRemove(captureTrue[i], captureTrue[j]);

}

}

});

const testDifferent = function(args1?: any, args2?: any) {

zone.run(function() {

if (args1) {

(document as any).addEventListener('click', docListener, args1);

} else {

(document as any).addEventListener('click', docListener);

}

if (args2) {

(document as any).addEventListener('click', docListener1, args2);

} else {

(document as any).addEventListener('click', docListener1);

}

});

button.dispatchEvent(clickEvent);

expect(hookSpy).toHaveBeenCalled();

expect(logs.sort()).toEqual(['document options', 'document useCapture']);

logs = [];

if (args1) {

(document as any).removeEventListener('click', docListener, args1);

} else {

(document as any).removeEventListener('click', docListener);

}

button.dispatchEvent(clickEvent);

expect(logs).toEqual(['document useCapture']);

logs = [];

if (args2) {

(document as any).removeEventListener('click', docListener1, args2);

} else {

(document as any).removeEventListener('click', docListener1);

}

button.dispatchEvent(clickEvent);

expect(logs).toEqual([]);

};

it('should be able to add different handlers for same event', function() {

let captureFalse = [

undefined, false, {capture: false}, {capture: false, passive: false},

{passive: false}, {}

];

let captureTrue = [true, {capture: true}, {capture: true, passive: false}];

for (let i = 0; i < captureFalse.length; i++) {

for (let j = 0; j < captureTrue.length; j++) {

testDifferent(captureFalse[i], captureTrue[j]);

}

}

for (let i = 0; i < captureTrue.length; i++) {

for (let j = 0; j < captureFalse.length; j++) {

testDifferent(captureTrue[i], captureFalse[j]);

}

}

});

it('should handle options.capture true with capture true correctly', function() {

zone.run(function() {

(document as any).addEventListener('click', docListener, {capture: true});

document.addEventListener('click', docListener1, true);

button.addEventListener('click', btnListener);

});

button.dispatchEvent(clickEvent);

expect(hookSpy).toHaveBeenCalled();

expect(logs).toEqual(['document options', 'document useCapture', 'button']);

logs = [];

(document as any).removeEventListener('click', docListener, {capture: true});

button.dispatchEvent(clickEvent);

expect(logs).toEqual(['document useCapture', 'button']);

logs = [];

document.removeEventListener('click', docListener1, true);

button.dispatchEvent(clickEvent);

expect(logs).toEqual(['button']);

logs = [];

button.removeEventListener('click', btnListener);

expect(cancelSpy).toHaveBeenCalled();

button.dispatchEvent(clickEvent);

expect(logs).toEqual([]);

});

}));

it('should support addEventListener with AddEventListenerOptions once setting',

ifEnvSupports(supportEventListenerOptions, function() {

let hookSpy = jasmine.createSpy('hook');

let logs: string[] = [];

const zone = rootZone.fork({

name: 'spy',

onScheduleTask: (

parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task):

any => {

hookSpy();

return parentZoneDelegate.scheduleTask(targetZone, task);

}

});

zone.run(function() {

(button as any).addEventListener('click', function() {

logs.push('click');

}, {once: true});

});

button.dispatchEvent(clickEvent);

expect(hookSpy).toHaveBeenCalled();

expect(logs.length).toBe(1);

expect(logs).toEqual(['click']);

logs = [];

button.dispatchEvent(clickEvent);

expect(logs.length).toBe(0);

}));

it('should support addEventListener with AddEventListenerOptions once setting and capture',

ifEnvSupports(supportEventListenerOptions, function() {

let hookSpy = jasmine.createSpy('hook');

let logs: string[] = [];

const zone = rootZone.fork({

name: 'spy',

onScheduleTask: (

parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task):

any => {

hookSpy();

return parentZoneDelegate.scheduleTask(targetZone, task);

}

});

zone.run(function() {

(button as any).addEventListener('click', function() {

logs.push('click');

}, {once: true, capture: true});

});

button.dispatchEvent(clickEvent);

expect(hookSpy).toHaveBeenCalled();

expect(logs.length).toBe(1);

expect(logs).toEqual(['click']);

logs = [];

button.dispatchEvent(clickEvent);

expect(logs.length).toBe(0);

}));

it('should support add multipe listeners with AddEventListenerOptions once setting and same capture after normal listener',

ifEnvSupports(supportEventListenerOptions, function() {

let logs: string[] = [];

button.addEventListener('click', function() {

logs.push('click');

}, true);

(button as any).addEventListener('click', function() {

logs.push('once click');

}, {once: true, capture: true});

button.dispatchEvent(clickEvent);

expect(logs.length).toBe(2);

expect(logs).toEqual(['click', 'once click']);

logs = [];

button.dispatchEvent(clickEvent);

expect(logs.length).toBe(1);

expect(logs).toEqual(['click']);

}));

it('should support add multipe listeners with AddEventListenerOptions once setting and mixed capture after normal listener',

ifEnvSupports(supportEventListenerOptions, function() {

let logs: string[] = [];

button.addEventListener('click', function() {

logs.push('click');

});

(button as any).addEventListener('click', function() {

logs.push('once click');

}, {once: true, capture: true});

button.dispatchEvent(clickEvent);

expect(logs.length).toBe(2);

expect(logs).toEqual(['click', 'once click']);

logs = [];

button.dispatchEvent(clickEvent);

expect(logs.length).toBe(1);

expect(logs).toEqual(['click']);

}));

it('should support add multipe listeners with AddEventListenerOptions once setting before normal listener',

ifEnvSupports(supportEventListenerOptions, function() {

let logs: string[] = [];

(button as any).addEventListener('click', function() {

logs.push('once click');

}, {once: true});

button.addEventListener('click', function() {

logs.push('click');

});

button.dispatchEvent(clickEvent);

expect(logs.length).toBe(2);

expect(logs).toEqual(['once click', 'click']);

logs = [];

button.dispatchEvent(clickEvent);

expect(logs.length).toBe(1);

expect(logs).toEqual(['click']);

}));

it('should support add multipe listeners with AddEventListenerOptions once setting with same capture before normal listener',

ifEnvSupports(supportEventListenerOptions, function() {

let logs: string[] = [];

(button as any).addEventListener('click', function() {

logs.push('once click');

}, {once: true, capture: true});

button.addEventListener('click', function() {

logs.push('click');

}, true);

button.dispatchEvent(clickEvent);

expect(logs.length).toBe(2);

expect(logs).toEqual(['once click', 'click']);

logs = [];

button.dispatchEvent(clickEvent);

expect(logs.length).toBe(1);

expect(logs).toEqual(['click']);