test: replace indexOf with includes

Start the transition to Array.prototype.includes() and
String.prototype.includes(). This commit refactors most of the
comparisons of Array.prototype.indexOf() and String.prototype.indexOf()
return values with -1 to the former methods in tests.
PR-URL: #12604
Refs: #12586
Reviewed-By: Alexey Orlenko <eaglexrlnk@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Gibson Fahnestock <gibfahn@gmail.com>

Author: gwer

test/inspector/test-inspector.js

@@ -34,7 +34,7 @@ function checkBadPath(err, response) {
 functionexpectMainScriptSource(result){
 constexpected=helper.mainScriptSource();
 constsource=result['scriptSource'];
-assert(source&&(source.indexOf(expected)>=0),
+assert(source&&(source.includes(expected)),
 'Script source is wrong: '+source);
 }
 

test/parallel/test-child-process-default-options.js

@@ -23,6 +23,6 @@ child.stdout.on('data', function(chunk) {
 });
 
 process.on('exit',function(){
-assert.ok(response.indexOf('HELLO=WORLD')>=0,
+assert.ok(response.includes('HELLO=WORLD'),
 'spawn did not use process.env as default');
 });

test/parallel/test-child-process-env.js

@@ -29,6 +29,6 @@ child.stdout.on('data', function(chunk) {
 });
 
 process.on('exit',function(){
-assert.ok(response.indexOf('HELLO=WORLD')>=0);
-assert.ok(response.indexOf('FOO=BAR')>=0);
+assert.ok(response.includes('HELLO=WORLD'));
+assert.ok(response.includes('FOO=BAR'));
 });

test/parallel/test-child-process-exec-env.js

@@ -35,5 +35,5 @@ process.on('exit', function() {
 console.log('response: ',response);
 assert.strictEqual(1,success_count);
 assert.strictEqual(0,error_count);
-assert.ok(response.indexOf('HELLO=WORLD')>=0);
+assert.ok(response.includes('HELLO=WORLD'));
 });

test/parallel/test-child-process-spawnsync-input.js

@@ -31,7 +31,7 @@ function verifyBufOutput(ret) {
 assert.deepStrictEqual(ret.stderr,msgErrBuf);
 }
 
-if(process.argv.indexOf('spawnchild')!==-1){
+if(process.argv.includes('spawnchild')){
 switch(process.argv[3]){
 case'1':
 ret=spawnSync(process.execPath,args,{stdio: 'inherit'});

test/parallel/test-domain-throw-error-then-throw-from-uncaught-exception-handler.js

@@ -17,7 +17,7 @@ const RAN_UNCAUGHT_EXCEPTION_HANDLER_EXIT_CODE = 42;
 
 if(process.argv[2]==='child'){
 process.on('uncaughtException',common.mustCall(functiononUncaught(){
-if(process.execArgv.indexOf('--abort-on-uncaught-exception')!==-1){
+if(process.execArgv.includes('--abort-on-uncaught-exception')){
 // When passing --abort-on-uncaught-exception to the child process,
 // we want to make sure that this handler (the process' uncaughtException
 // event handler) wasn't called. Unfortunately we can't parse the child

test/parallel/test-domain-with-abort-on-uncaught-exception.js

@@ -43,11 +43,11 @@ if (process.argv[2] === 'child') {
 d.on('error',function(err){
 // Swallowing the error on purpose if 'throwInDomainErrHandler' is not
 // set
-if(process.argv.indexOf('throwInDomainErrHandler')!==-1){
+if(process.argv.includes('throwInDomainErrHandler')){
 // If useTryCatch is set, wrap the throw in a try/catch block.
 // This is to make sure that a caught exception does not trigger
 // an abort.
-if(process.argv.indexOf('useTryCatch')!==-1){
+if(process.argv.includes('useTryCatch')){
 try{
 thrownewError(domainErrHandlerExMessage);
 }catch(e){

test/parallel/test-error-reporting.js

@@ -15,7 +15,7 @@ function errExec(script, callback) {
 assert.ok(stderr.split('\n').length>2);
 
 // Assert the script is mentioned in error output.
-assert.ok(stderr.indexOf(script)>=0);
+assert.ok(stderr.includes(script));
 
 // Proxy the args for more tests.
 callback(err,stdout,stderr);

test/parallel/test-fs-error-messages.js

@@ -13,66 +13,66 @@ const existingDir2 = path.join(common.fixturesDir, 'keys');
 
 fs.stat(fn,function(err){
 assert.strictEqual(fn,err.path);
-assert.ok(0<=err.message.indexOf(fn));
+assert.ok(err.message.includes(fn));
 });
 
 fs.lstat(fn,function(err){
-assert.ok(0<=err.message.indexOf(fn));
+assert.ok(err.message.includes(fn));
 });
 
 fs.readlink(fn,function(err){
-assert.ok(0<=err.message.indexOf(fn));
+assert.ok(err.message.includes(fn));
 });
 
 fs.link(fn,'foo',function(err){
-assert.ok(0<=err.message.indexOf(fn));
+assert.ok(err.message.includes(fn));
 });
 
 fs.link(existingFile,existingFile2,function(err){
-assert.ok(0<=err.message.indexOf(existingFile));
-assert.ok(0<=err.message.indexOf(existingFile2));
+assert.ok(err.message.includes(existingFile));
+assert.ok(err.message.includes(existingFile2));
 });
 
 fs.symlink(existingFile,existingFile2,function(err){
-assert.ok(0<=err.message.indexOf(existingFile));
-assert.ok(0<=err.message.indexOf(existingFile2));
+assert.ok(err.message.includes(existingFile));
+assert.ok(err.message.includes(existingFile2));
 });
 
 fs.unlink(fn,function(err){
-assert.ok(0<=err.message.indexOf(fn));
+assert.ok(err.message.includes(fn));
 });
 
 fs.rename(fn,'foo',function(err){
-assert.ok(0<=err.message.indexOf(fn));
+assert.ok(err.message.includes(fn));
 });
 
 fs.rename(existingDir,existingDir2,function(err){
-assert.ok(0<=err.message.indexOf(existingDir));
-assert.ok(0<=err.message.indexOf(existingDir2));
+assert.ok(err.message.includes(existingDir));
+assert.ok(err.message.includes(existingDir2));
 });
 
 fs.rmdir(fn,function(err){
-assert.ok(0<=err.message.indexOf(fn));
+assert.ok(err.message.includes(fn));
 });
 
 fs.mkdir(existingFile,0o666,function(err){
-assert.ok(0<=err.message.indexOf(existingFile));
+assert.ok(err.message.includes(existingFile));
 });
 
 fs.rmdir(existingFile,function(err){
-assert.ok(0<=err.message.indexOf(existingFile));
+assert.ok(err.message.includes(existingFile));
 });
 
 fs.chmod(fn,0o666,function(err){
-assert.ok(0<=err.message.indexOf(fn));
+assert.ok(err.message.includes(fn));
 });
 
 fs.open(fn,'r',0o666,function(err){
-assert.ok(0<=err.message.indexOf(fn));
+assert.ok(err.message.includes(fn));
 });
 
 fs.readFile(fn,function(err){
-assert.ok(0<=err.message.indexOf(fn));
+assert.ok(err.message.includes(fn));
 });
 
 // Sync
@@ -85,122 +85,122 @@ try {
 fs.statSync(fn);
 }catch(err){
 errors.push('stat');
-assert.ok(0<=err.message.indexOf(fn));
+assert.ok(err.message.includes(fn));
 }
 
 try{
 ++expected;
 fs.mkdirSync(existingFile,0o666);
 }catch(err){
 errors.push('mkdir');
-assert.ok(0<=err.message.indexOf(existingFile));
+assert.ok(err.message.includes(existingFile));
 }
 
 try{
 ++expected;
 fs.chmodSync(fn,0o666);
 }catch(err){
 errors.push('chmod');
-assert.ok(0<=err.message.indexOf(fn));
+assert.ok(err.message.includes(fn));
 }
 
 try{
 ++expected;
 fs.lstatSync(fn);
 }catch(err){
 errors.push('lstat');
-assert.ok(0<=err.message.indexOf(fn));
+assert.ok(err.message.includes(fn));
 }
 
 try{
 ++expected;
 fs.readlinkSync(fn);
 }catch(err){
 errors.push('readlink');
-assert.ok(0<=err.message.indexOf(fn));
+assert.ok(err.message.includes(fn));
 }
 
 try{
 ++expected;
 fs.linkSync(fn,'foo');
 }catch(err){
 errors.push('link');
-assert.ok(0<=err.message.indexOf(fn));
+assert.ok(err.message.includes(fn));
 }
 
 try{
 ++expected;
 fs.linkSync(existingFile,existingFile2);
 }catch(err){
 errors.push('link');
-assert.ok(0<=err.message.indexOf(existingFile));
-assert.ok(0<=err.message.indexOf(existingFile2));
+assert.ok(err.message.includes(existingFile));
+assert.ok(err.message.includes(existingFile2));
 }
 
 try{
 ++expected;
 fs.symlinkSync(existingFile,existingFile2);
 }catch(err){
 errors.push('symlink');
-assert.ok(0<=err.message.indexOf(existingFile));
-assert.ok(0<=err.message.indexOf(existingFile2));
+assert.ok(err.message.includes(existingFile));
+assert.ok(err.message.includes(existingFile2));
 }
 
 try{
 ++expected;
 fs.unlinkSync(fn);
 }catch(err){
 errors.push('unlink');
-assert.ok(0<=err.message.indexOf(fn));
+assert.ok(err.message.includes(fn));
 }
 
 try{
 ++expected;
 fs.rmdirSync(fn);
 }catch(err){
 errors.push('rmdir');
-assert.ok(0<=err.message.indexOf(fn));
+assert.ok(err.message.includes(fn));
 }
 
 try{
 ++expected;
 fs.rmdirSync(existingFile);
 }catch(err){
 errors.push('rmdir');
-assert.ok(0<=err.message.indexOf(existingFile));
+assert.ok(err.message.includes(existingFile));
 }
 
 try{
 ++expected;
 fs.openSync(fn,'r');
 }catch(err){
 errors.push('opens');
-assert.ok(0<=err.message.indexOf(fn));
+assert.ok(err.message.includes(fn));
 }
 
 try{
 ++expected;
 fs.renameSync(fn,'foo');
 }catch(err){
 errors.push('rename');
-assert.ok(0<=err.message.indexOf(fn));
+assert.ok(err.message.includes(fn));
 }
 
 try{
 ++expected;
 fs.renameSync(existingDir,existingDir2);
 }catch(err){
 errors.push('rename');
-assert.ok(0<=err.message.indexOf(existingDir));
-assert.ok(0<=err.message.indexOf(existingDir2));
+assert.ok(err.message.includes(existingDir));
+assert.ok(err.message.includes(existingDir2));
 }
 
 try{
 ++expected;
 fs.readdirSync(fn);
 }catch(err){
 errors.push('readdir');
-assert.ok(0<=err.message.indexOf(fn));
+assert.ok(err.message.includes(fn));
 }
 
 process.on('exit',function(){

test/parallel/test-http-client-parse-error.js

@@ -26,7 +26,7 @@ net.createServer(function(c) {
 path: '/'
 }).on('error',function(e){
 console.log('got error from client');
-assert.ok(e.message.indexOf('Parse Error')>=0);
+assert.ok(e.message.includes('Parse Error'));
 assert.strictEqual(e.code,'HPE_INVALID_CONSTANT');
 parseErrors++;
 }).end();