[apple/javascriptcore.git] / tests / stress / custom-iterators.js

// This test checks the behavior of custom iterable objects.

var returnCalled = false;
var iter = {
    __key: 0,
    next: function () {
        return {
            done: this.__key === 42,
            value: this.__key++
        };
    },
    [Symbol.iterator]: function () {
        return this;
    },
    return: function () {
        returnCalled = true;
    }
};
var expected = 0;
for (var value of iter) {
    if (value !== expected++)
        throw "Error: bad value: " + value;
}
if (returnCalled)
    throw "Error: return is called.";


var returnCalled = false;
var iter = {
    __key: 0,
    next: function () {
        return {
            done: this.__key === 42,
            value: this.__key++
        };
    },
    [Symbol.iterator]: function () {
        return this;
    },
    return: function () {
        returnCalled = true;
        return {
            done: true,
            value: undefined
        };
    }
};

try {
    for (var value of iter) {
        throw "Error: Terminate iteration.";
    }
} catch (e) {
    if (String(e) !== "Error: Terminate iteration.")
        throw "Error: bad error thrown: " + e;
}
if (!returnCalled)
    throw "Error: return is not called.";


var returnCalled = false;
var iter = {
    __key: 0,
    next: function () {
        return {
            done: this.__key === 42,
            value: this.__key++
        };
    },
    [Symbol.iterator]: function () {
        return this;
    },
    return: function () {
        returnCalled = true;
        return {
            done: true,
            value: undefined
        };
    }
};

for (var value of iter) {
    break;
}
if (!returnCalled)
    throw "Error: return is not called.";


var returnCalled = false;
var iter = {
    __key: 0,
    get next() {
        throw "Error: looking up next.";
    },
    [Symbol.iterator]: function () {
        return this;
    },
    return: function () {
        returnCalled = true;
    }
};
try {
    for (var value of iter) {
        throw "Error: Iteration should not occur.";
    }
} catch (e) {
    if (String(e) !== "Error: looking up next.")
        throw "Error: bad error thrown: " + e;
}
if (returnCalled)
    throw "Error: return is called.";


var iter = {
    __key: 0,
    next: function () {
        return {
            done: this.__key === 42,
            value: this.__key++
        };
    },
    [Symbol.iterator]: function () {
        return this;
    },
    get return() {
        throw "Error: looking up return."
    }
};
try {
    for (var value of iter) {
        throw "Error: Terminate iteration.";
    }
} catch (e) {
    if (String(e) !== "Error: looking up return.")
        throw "Error: bad error thrown: " + e;
}


var returnCalled = false;
var iter = {
    __key: 0,
    next: function () {
        throw "Error: next is called."
    },
    [Symbol.iterator]: function () {
        return this;
    },
    return: function () {
        returnCalled = true;
        return {
            done: true,
            value: undefined
        };
    }
};

try {
    for (var value of iter) {
        throw "Error: Terminate iteration.";
    }
} catch (e) {
    if (String(e) !== "Error: next is called.")
        throw "Error: bad error thrown: " + e;
}
if (returnCalled)
    throw "Error: return is called.";


var returnCalled = false;
var iter = {
    __key: 0,
    next: function () {
        return { done: false, value: 42 };
    },
    [Symbol.iterator]: function () {
        return this;
    },
    return: function () {
        returnCalled = true;
        throw "Error: return is called.";
    }
};

try {
    for (var value of iter) {
        throw "Error: Terminate iteration.";
    }
} catch (e) {
    if (String(e) !== "Error: Terminate iteration.")
        throw "Error: bad error thrown: " + e;
}
if (!returnCalled)
    throw "Error: return is not called.";


var returnCalled = false;
var iter = {
    __key: 0,
    next: function () {
        return { done: false, value: 42 };
    },
    [Symbol.iterator]: function () {
        return this;
    },
    return: function () {
        returnCalled = true;
        throw "Error: return is called.";
    }
};
try {
    for (var value of iter) {
        break;
    }
} catch (e) {
    if (String(e) !== "Error: return is called.")
        throw "Error: bad error thrown: " + e;
}
if (!returnCalled)
    throw "Error: return is not called.";


var primitives = [
    undefined,
    null,
    42,
    "string",
    true,
    Symbol("Cocoa")
];

function iteratorInterfaceErrorTest(notIteratorResult) {
    var returnCalled = false;
    var iter = {
        __key: 0,
        next: function () {
            return notIteratorResult;
        },
        [Symbol.iterator]: function () {
            return this;
        },
        return: function () {
            returnCalled = true;
            return undefined;
        }
    };
    try {
        for (var value of iter) {
            throw "Error: Iteration should not occur.";
        }
    } catch (e) {
        if (String(e) !== "TypeError: Iterator result interface is not an object.")
            throw "Error: bad error thrown: " + e;
    }
    if (returnCalled)
        throw "Error: return is called.";
}

function iteratorInterfaceErrorTestReturn(notIteratorResult) {
    var returnCalled = false;
    var iter = {
        __key: 0,
        next: function () {
            return { done: false, value: 42 };
        },
        [Symbol.iterator]: function () {
            return this;
        },
        return: function () {
            returnCalled = true;
            return notIteratorResult;
        }
    };
    try {
        for (var value of iter) {
            throw "Error: Terminate iteration.";
        }
    } catch (e) {
        if (String(e) !== "Error: Terminate iteration.")
            throw "Error: bad error thrown: " + e;
    }
    if (!returnCalled)
        throw "Error: return is not called.";
}

primitives.forEach(iteratorInterfaceErrorTest);
primitives.forEach(iteratorInterfaceErrorTestReturn);


function iteratorInterfaceBreakTestReturn(notIteratorResult) {
    var returnCalled = false;
    var iter = {
        __key: 0,
        next: function () {
            return { done: false, value: 42 };
        },
        [Symbol.iterator]: function () {
            return this;
        },
        return: function () {
            returnCalled = true;
            return notIteratorResult;
        }
    };
    try {
        for (var value of iter) {
            break;
        }
    } catch (e) {
        if (String(e) !== "TypeError: Iterator result interface is not an object.")
            throw "Error: bad error thrown: " + e;
    }
    if (!returnCalled)
        throw "Error: return is not called.";
}

primitives.forEach(iteratorInterfaceBreakTestReturn);
Commit	Line	Data
ed1e77d3 A	1	// This test checks the behavior of custom iterable objects.
	2
	3	var returnCalled = false;
	4	var iter = {
	5	__key: 0,
	6	next: function () {
	7	return {
	8	done: this.__key === 42,
	9	value: this.__key++
	10	};
	11	},
	12	[Symbol.iterator]: function () {
	13	return this;
	14	},
	15	return: function () {
	16	returnCalled = true;
	17	}
	18	};
	19	var expected = 0;
	20	for (var value of iter) {
	21	if (value !== expected++)
	22	throw "Error: bad value: " + value;
	23	}
	24	if (returnCalled)
	25	throw "Error: return is called.";
	26
	27
	28
	29	var returnCalled = false;
	30	var iter = {
	31	__key: 0,
	32	next: function () {
	33	return {
	34	done: this.__key === 42,
	35	value: this.__key++
	36	};
	37	},
	38	[Symbol.iterator]: function () {
	39	return this;
	40	},
	41	return: function () {
	42	returnCalled = true;
	43	return {
	44	done: true,
	45	value: undefined
	46	};
	47	}
	48	};
	49
	50	try {
	51	for (var value of iter) {
	52	throw "Error: Terminate iteration.";
	53	}
	54	} catch (e) {
	55	if (String(e) !== "Error: Terminate iteration.")
	56	throw "Error: bad error thrown: " + e;
	57	}
	58	if (!returnCalled)
	59	throw "Error: return is not called.";
	60
	61
	62
	63	var returnCalled = false;
	64	var iter = {
65	__key: 0,
66	next: function () {
67	return {
68	done: this.__key === 42,
69	value: this.__key++
70	};
71	},
72	[Symbol.iterator]: function () {
73	return this;
74	},
75	return: function () {
76	returnCalled = true;
77	return {
78	done: true,
79	value: undefined
80	};
81	}
82	};
83
84	for (var value of iter) {
85	break;
86	}
87	if (!returnCalled)
88	throw "Error: return is not called.";
89
90
91
92	var returnCalled = false;
93	var iter = {
94	__key: 0,
95	get next() {
96	throw "Error: looking up next.";
97	},
98	[Symbol.iterator]: function () {
99	return this;
100	},
101	return: function () {
102	returnCalled = true;
103	}
104	};
105	try {
106	for (var value of iter) {
107	throw "Error: Iteration should not occur.";
108	}
109	} catch (e) {
110	if (String(e) !== "Error: looking up next.")
111	throw "Error: bad error thrown: " + e;
112	}
113	if (returnCalled)
114	throw "Error: return is called.";
115
116
117
118	var iter = {
119	__key: 0,
120	next: function () {
121	return {
122	done: this.__key === 42,
123	value: this.__key++
124	};
125	},
126	[Symbol.iterator]: function () {
127	return this;
128	},
129	get return() {
130	throw "Error: looking up return."
131	}
132	};
133	try {
134	for (var value of iter) {
135	throw "Error: Terminate iteration.";
136	}
137	} catch (e) {
138	if (String(e) !== "Error: looking up return.")
139	throw "Error: bad error thrown: " + e;
140	}
141
142
143
144	var returnCalled = false;
145	var iter = {
146	__key: 0,
147	next: function () {
148	throw "Error: next is called."
149	},
150	[Symbol.iterator]: function () {
151	return this;
152	},
153	return: function () {
154	returnCalled = true;
155	return {
156	done: true,
157	value: undefined
158	};
159	}
160	};
161
162	try {
163	for (var value of iter) {
164	throw "Error: Terminate iteration.";
165	}
166	} catch (e) {
167	if (String(e) !== "Error: next is called.")
168	throw "Error: bad error thrown: " + e;
169	}
170	if (returnCalled)
171	throw "Error: return is called.";
172
173
174
175	var returnCalled = false;
176	var iter = {
177	__key: 0,
178	next: function () {
179	return { done: false, value: 42 };
180	},
181	[Symbol.iterator]: function () {
182	return this;
183	},
184	return: function () {
185	returnCalled = true;
186	throw "Error: return is called.";
187	}
188	};
189
190	try {
191	for (var value of iter) {
192	throw "Error: Terminate iteration.";
193	}
194	} catch (e) {
195	if (String(e) !== "Error: Terminate iteration.")
196	throw "Error: bad error thrown: " + e;
197	}
198	if (!returnCalled)
199	throw "Error: return is not called.";
200
201
202	var returnCalled = false;
203	var iter = {
204	__key: 0,
205	next: function () {
206	return { done: false, value: 42 };
207	},
208	[Symbol.iterator]: function () {
209	return this;
210	},
211	return: function () {
212	returnCalled = true;
213	throw "Error: return is called.";
214	}
215	};
216	try {
217	for (var value of iter) {
218	break;
219	}
220	} catch (e) {
221	if (String(e) !== "Error: return is called.")
222	throw "Error: bad error thrown: " + e;
223	}
224	if (!returnCalled)
225	throw "Error: return is not called.";
226
227
228	var primitives = [
229	undefined,
230	null,
231	42,
232	"string",
233	true,
234	Symbol("Cocoa")
235	];
236
237	function iteratorInterfaceErrorTest(notIteratorResult) {
238	var returnCalled = false;
239	var iter = {
240	__key: 0,
241	next: function () {
242	return notIteratorResult;
243	},
244	[Symbol.iterator]: function () {
245	return this;
246	},
247	return: function () {
248	returnCalled = true;
249	return undefined;
250	}
251	};
252	try {
253	for (var value of iter) {
254	throw "Error: Iteration should not occur.";
255	}
256	} catch (e) {
257	if (String(e) !== "TypeError: Iterator result interface is not an object.")
258	throw "Error: bad error thrown: " + e;
259	}
260	if (returnCalled)
261	throw "Error: return is called.";
262	}
263
264	function iteratorInterfaceErrorTestReturn(notIteratorResult) {
265	var returnCalled = false;
266	var iter = {
267	__key: 0,
268	next: function () {
269	return { done: false, value: 42 };
270	},
271	[Symbol.iterator]: function () {
272	return this;
273	},
274	return: function () {
275	returnCalled = true;
276	return notIteratorResult;
277	}
278	};
279	try {
280	for (var value of iter) {
281	throw "Error: Terminate iteration.";
282	}
283	} catch (e) {
284	if (String(e) !== "Error: Terminate iteration.")
285	throw "Error: bad error thrown: " + e;
286	}
287	if (!returnCalled)
288	throw "Error: return is not called.";
289	}
290
291	primitives.forEach(iteratorInterfaceErrorTest);
292	primitives.forEach(iteratorInterfaceErrorTestReturn);
293
294
295	function iteratorInterfaceBreakTestReturn(notIteratorResult) {
296	var returnCalled = false;
297	var iter = {
298	__key: 0,
299	next: function () {
300	return { done: false, value: 42 };
301	},
302	[Symbol.iterator]: function () {
303	return this;
304	},
305	return: function () {
306	returnCalled = true;
307	return notIteratorResult;
308	}
309	};
310	try {
311	for (var value of iter) {
312	break;
313	}
314	} catch (e) {
315	if (String(e) !== "TypeError: Iterator result interface is not an object.")
316	throw "Error: bad error thrown: " + e;
317	}
318	if (!returnCalled)
319	throw "Error: return is not called.";
320	}
321
322	primitives.forEach(iteratorInterfaceBreakTestReturn);