function forEach(obj, f, context) {
if (isGeneratorFunction(obj)) {
return forEach(obj(), f, context);
} else if (isIterator(obj)) {
var value = obj.next();
while (!value.done) {
if (f.call(context, value.value, 'value', obj) === false) {
return;
}
value = obj.next();
}
} else {
var type = t(obj);
var func = defaultTypeAdaptorStorage.requireAdaptor(type, 'forEach');
func(obj, f, context);
}
}
Assertion.add("throw", function(message, properties) {
var fn = this.obj;
var err = {};
var errorInfo = "";
var thrown = false;
if (isGeneratorFunction(fn)) {
return should(fn()).throw(message, properties);
} else if (isIterator(fn)) {
return should(fn.next.bind(fn)).throw(message, properties);
}
this.is.a.Function();
var errorMatched = true;
try {
fn();
} catch (e) {
thrown = true;
err = e;
}
if (thrown) {
if (message) {
if ("string" == typeof message) {
errorMatched = message == err.message;
} else if (message instanceof RegExp) {
errorMatched = message.test(err.message);
} else if ("function" == typeof message) {
errorMatched = err instanceof message;
} else if (null != message) {
try {
should(err).match(message);
} catch (e) {
if (e instanceof should.AssertionError) {
errorInfo = ": " + e.message;
errorMatched = false;
} else {
throw e;
}
}
}
if (!errorMatched) {
if ("string" == typeof message || message instanceof RegExp) {
errorInfo =
" with a message matching " +
i(message) +
", but got '" +
err.message +
"'";
} else if ("function" == typeof message) {
errorInfo =
" of type " +
functionName(message) +
", but got " +
functionName(err.constructor);
}
} else if ("function" == typeof message && properties) {
try {
should(err).match(properties);
} catch (e) {
if (e instanceof should.AssertionError) {
errorInfo = ": " + e.message;
errorMatched = false;
} else {
throw e;
}
}
}
} else {
errorInfo = " (got " + i(err) + ")";
}
}
this.params = { operator: "to throw exception" + errorInfo };
this.assert(thrown);
this.assert(errorMatched);
});