assert: make sure throws is able to handle primitives

This fixes some possible issues with `assert.throws` and
`assert.rejects` in combination with an validation object. It will
now properly handle primitive values being thrown as error.
It also makes sure the `generatedMessage` property is properly set
if `assert.throws` or `assert.rejects` is used in combination with
an validation object and improves the error performance in such cases
by only creating the error once.
In addition it will fix detecting regular expressions from a different
context such as n-api that are passed through as validator for
`assert.throws` or `assert.rejects`. Until now those were not tested.
PR-URL: #20482
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>

Author: BridgeAR

lib/assert.js

@@ -382,16 +382,16 @@ function compareExceptionKey(actual, expected, key, message, keys) {
 consta=newComparison(actual,keys);
 constb=newComparison(expected,keys,actual);
 
-consttmpLimit=Error.stackTraceLimit;
-Error.stackTraceLimit=0;
 consterr=newAssertionError({
 actual: a,
 expected: b,
 operator: 'deepStrictEqual',
 stackStartFn: assert.throws
 });
-Error.stackTraceLimit=tmpLimit;
-message=err.message;
+err.actual=actual;
+err.expected=expected;
+err.operator='throws';
+throwerr;
 }
 innerFail({
  actual,
@@ -405,14 +405,34 @@ function compareExceptionKey(actual, expected, key, message, keys) {
 
 functionexpectedException(actual,expected,msg){
 if(typeofexpected!=='function'){
-if(expectedinstanceofRegExp)
+if(isRegExp(expected))
 returnexpected.test(actual);
 // assert.doesNotThrow does not accept objects.
 if(arguments.length===2){
 thrownewERR_INVALID_ARG_TYPE(
 'expected',['Function','RegExp'],expected
 );
 }
+
+// TODO: Disallow primitives as error argument.
+// This is here to prevent a breaking change.
+if(typeofexpected!=='object'){
+returntrue;
+}
+
+// Handle primitives properly.
+if(typeofactual!=='object'||actual===null){
+consterr=newAssertionError({
+ actual,
+ expected,
+message: msg,
+operator: 'deepStrictEqual',
+stackStartFn: assert.throws
+});
+err.operator='throws';
+throwerr;
+}
+
 constkeys=Object.keys(expected);
 // Special handle errors to make sure the name and the message are compared
 // as well.

test/message/assert_throws_stack.out

@@ -1,6 +1,6 @@
 assert.js:*
-throw new AssertionError(obj);
- ^
+ throw err;
+^
 
 AssertionError [ERR_ASSERTION]: Input A expected to strictly deep-equal input B:
 + expected - actual

test/parallel/test-assert.js

@@ -740,7 +740,9 @@ common.expectsError(
 constframes=err.stack.split('\n');
 const[,filename,line,column]=frames[1].match(/\((.+):(\d+):(\d+)\)/);
 // Reset the cache to check again
+constsize=errorCache.size;
 errorCache.delete(`${filename}${line-1}${column-1}`);
+assert.strictEqual(errorCache.size,size-1);
 constdata=`${'\n'.repeat(line-1)}${' '.repeat(column-1)}`+
 'ok(failed(badly));';
 try{
@@ -849,6 +851,7 @@ common.expectsError(
 {
 name: 'AssertionError [ERR_ASSERTION]',
 code: 'ERR_ASSERTION',
+generatedMessage: true,
 message: `${start}\n${actExp}\n\n`+
 " Comparison {\n name: 'Error',\n- message: 'foo'"+
 "\n+ message: ''\n }"
@@ -940,3 +943,45 @@ assert.throws(
 ' }'
 }
 );
+
+{
+letactual=null;
+constexpected={message: 'foo'};
+assert.throws(
+()=>assert.throws(
+()=>{throwactual;},
+expected
+),
+{
+operator: 'throws',
+ actual,
+ expected,
+generatedMessage: true,
+message: `${start}\n${actExp}\n\n`+
+'- null\n'+
+'+ {\n'+
+"+ message: 'foo'\n"+
+'+ }'
+}
+);
+
+actual='foobar';
+constmessage='message';
+assert.throws(
+()=>assert.throws(
+()=>{throwactual;},
+{message: 'foobar'},
+message
+),
+{
+ actual,
+ message,
+operator: 'throws',
+generatedMessage: false
+}
+);
+}
+
+// TODO: This case is only there to make sure there is no breaking change.
+// eslint-disable-next-line no-restricted-syntax, no-throw-literal
+assert.throws(()=>{throw4;},4);