test: use ES6 classes instead of util.inherits

PR-URL: #16938
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>

Author: tniessen

test/parallel/test-crypto-lazy-transform-writable.js

@@ -7,7 +7,6 @@ if (!common.hasCrypto)
 constassert=require('assert');
 constcrypto=require('crypto');
 constStream=require('stream');
-constutil=require('util');
 
 consthasher1=crypto.createHash('sha256');
 consthasher2=crypto.createHash('sha256');
@@ -18,12 +17,12 @@ hasher1.end();
 
 constexpected=hasher1.read().toString('hex');
 
-functionOldStream(){
-Stream.call(this);
-
-this.readable=true;
+classOldStreamextendsStream{
+constructor(){
+super();
+this.readable=true;
+}
 }
-util.inherits(OldStream,Stream);
 
 conststream=newOldStream();
 

test/parallel/test-crypto-stream.js

@@ -26,26 +26,26 @@ if (!common.hasCrypto)
 
 constassert=require('assert');
 conststream=require('stream');
-constutil=require('util');
 constcrypto=require('crypto');
 
-// Small stream to buffer converter
-functionStream2buffer(callback){
-stream.Writable.call(this);
+if(!common.hasFipsCrypto){
+// Small stream to buffer converter
+classStream2bufferextendsstream.Writable{
+constructor(callback){
+super();
 
-this._buffers=[];
-this.once('finish',function(){
-callback(null,Buffer.concat(this._buffers));
-});
-}
-util.inherits(Stream2buffer,stream.Writable);
+this._buffers=[];
+this.once('finish',function(){
+callback(null,Buffer.concat(this._buffers));
+});
+}
 
-Stream2buffer.prototype._write=function(data,encodeing,done){
-this._buffers.push(data);
-returndone(null);
-};
+_write(data,encodeing,done){
+this._buffers.push(data);
+returndone(null);
+}
+}
 
-if(!common.hasFipsCrypto){
 // Create an md5 hash of "Hallo world"
 consthasher1=crypto.createHash('md5');
 hasher1.pipe(newStream2buffer(common.mustCall(functionend(err,hash){

test/parallel/test-event-emitter-listeners.js

@@ -24,12 +24,9 @@
 require('../common');
 constassert=require('assert');
 constevents=require('events');
-constutil=require('util');
 
 functionlistener(){}
 functionlistener2(){}
-classTestStream{constructor(){}}
-util.inherits(TestStream,events.EventEmitter);
 
 {
 constee=newevents.EventEmitter();
@@ -81,6 +78,7 @@ util.inherits(TestStream, events.EventEmitter);
 }
 
 {
+classTestStreamextendsevents.EventEmitter{}
 consts=newTestStream();
 assert.deepStrictEqual(s.listeners('foo'),[]);
 }

test/parallel/test-http-client-read-in-error.js

@@ -2,38 +2,34 @@
 require('../common');
 constnet=require('net');
 consthttp=require('http');
-constutil=require('util');
 
-functionAgent(){
-http.Agent.call(this);
-}
-util.inherits(Agent,http.Agent);
-
-Agent.prototype.createConnection=function(){
-constself=this;
-constsocket=newnet.Socket();
+classAgentextendshttp.Agent{
+createConnection(){
+constsocket=newnet.Socket();
 
-socket.on('error',function(){
-socket.push('HTTP/1.1 200\r\n\r\n');
-});
+socket.on('error',function(){
+socket.push('HTTP/1.1 200\r\n\r\n');
+});
 
-socket.on('newListener',functiononNewListener(name){
-if(name!=='error')
-return;
-socket.removeListener('newListener',onNewListener);
+letonNewListener;
+socket.on('newListener',onNewListener=(name)=>{
+if(name!=='error')
+return;
+socket.removeListener('newListener',onNewListener);
 
-// Let other listeners to be set up too
-process.nextTick(function(){
-self.breakSocket(socket);
+// Let other listeners to be set up too
+process.nextTick(()=>{
+this.breakSocket(socket);
+});
 });
-});
 
-returnsocket;
-};
+returnsocket;
+}
 
-Agent.prototype.breakSocket=functionbreakSocket(socket){
-socket.emit('error',newError('Intentional error'));
-};
+breakSocket(socket){
+socket.emit('error',newError('Intentional error'));
+}
+}
 
 constagent=newAgent();
 

test/parallel/test-http-client-readable.js

@@ -23,41 +23,37 @@
 constcommon=require('../common');
 constassert=require('assert');
 consthttp=require('http');
-constutil=require('util');
 
 constDuplex=require('stream').Duplex;
 
-functionFakeAgent(){
-http.Agent.call(this);
-}
-util.inherits(FakeAgent,http.Agent);
-
-FakeAgent.prototype.createConnection=function(){
-consts=newDuplex();
-letonce=false;
+classFakeAgentextendshttp.Agent{
+createConnection(){
+consts=newDuplex();
+letonce=false;
 
-s._read=function(){
-if(once)
-returnthis.push(null);
-once=true;
+s._read=function(){
+if(once)
+returnthis.push(null);
+once=true;
 
-this.push('HTTP/1.1 200 Ok\r\nTransfer-Encoding: chunked\r\n\r\n');
-this.push('b\r\nhello world\r\n');
-this.readable=false;
-this.push('0\r\n\r\n');
-};
+this.push('HTTP/1.1 200 Ok\r\nTransfer-Encoding: chunked\r\n\r\n');
+this.push('b\r\nhello world\r\n');
+this.readable=false;
+this.push('0\r\n\r\n');
+};
 
-// Blackhole
-s._write=function(data,enc,cb){
-cb();
-};
+// Blackhole
+s._write=function(data,enc,cb){
+cb();
+};
 
-s.destroy=s.destroySoon=function(){
-this.writable=false;
-};
+s.destroy=s.destroySoon=function(){
+this.writable=false;
+};
 
-returns;
-};
+returns;
+}
+}
 
 letreceived='';
 

test/parallel/test-pipe-outgoing-message-data-emitted-after-ended.js

@@ -2,17 +2,13 @@
 constcommon=require('../common');
 consthttp=require('http');
 constassert=require('assert');
-constutil=require('util');
 conststream=require('stream');
 
 // Verify that when piping a stream to an `OutgoingMessage` (or a type that
 // inherits from `OutgoingMessage`), if data is emitted after the
 // `OutgoingMessage` was closed - a `write after end` error is raised
 
-functionMyStream(){
-stream.call(this);
-}
-util.inherits(MyStream,stream);
+classMyStreamextendsstream{}
 
 constserver=http.createServer(common.mustCall(function(req,res){
 constmyStream=newMyStream();

test/parallel/test-readline-interface.js

@@ -27,17 +27,14 @@ const assert = require('assert');
 constreadline=require('readline');
 constinternalReadline=require('internal/readline');
 constEventEmitter=require('events').EventEmitter;
-constinherits=require('util').inherits;
 const{ Writable, Readable }=require('stream');
 
-functionFakeInput(){
-EventEmitter.call(this);
+classFakeInputextendsEventEmitter{
+resume(){}
+pause(){}
+write(){}
+end(){}
 }
-inherits(FakeInput,EventEmitter);
-FakeInput.prototype.resume=()=>{};
-FakeInput.prototype.pause=()=>{};
-FakeInput.prototype.write=()=>{};
-FakeInput.prototype.end=()=>{};
 
 functionisWarned(emitter){
 for(constnameinemitter){

test/parallel/test-readline-keys.js

@@ -2,14 +2,9 @@
 constcommon=require('../common');
 constPassThrough=require('stream').PassThrough;
 constassert=require('assert');
-constinherits=require('util').inherits;
 constInterface=require('readline').Interface;
 
-
-functionFakeInput(){
-PassThrough.call(this);
-}
-inherits(FakeInput,PassThrough);
+classFakeInputextendsPassThrough{}
 
 functionextend(k){
 returnObject.assign({ctrl: false,meta: false,shift: false},k);

test/parallel/test-stream-big-packet.js

@@ -22,31 +22,26 @@
 'use strict';
 require('../common');
 constassert=require('assert');
-constutil=require('util');
 conststream=require('stream');
 
 letpassed=false;
 
-functionPassThrough(){
-stream.Transform.call(this);
+classPassThroughextendsstream.Transform{
+_transform(chunk,encoding,done){
+this.push(chunk);
+done();
+}
 }
-util.inherits(PassThrough,stream.Transform);
-PassThrough.prototype._transform=function(chunk,encoding,done){
-this.push(chunk);
-done();
-};
 
-functionTestStream(){
-stream.Transform.call(this);
-}
-util.inherits(TestStream,stream.Transform);
-TestStream.prototype._transform=function(chunk,encoding,done){
-if(!passed){
-// Char 'a' only exists in the last write
-passed=chunk.toString().includes('a');
+classTestStreamextendsstream.Transform{
+_transform(chunk,encoding,done){
+if(!passed){
+// Char 'a' only exists in the last write
+passed=chunk.toString().includes('a');
+}
+done();
 }
-done();
-};
+}
 
 consts1=newPassThrough();
 consts2=newPassThrough();

test/parallel/test-stream-events-prepend.js

@@ -1,26 +1,23 @@
 'use strict';
 constcommon=require('../common');
 conststream=require('stream');
-constutil=require('util');
 
-functionWritable(){
-this.writable=true;
-stream.Writable.call(this);
-this.prependListener=undefined;
+classWritableextendsstream.Writable{
+constructor(){
+super();
+this.prependListener=undefined;
+}
+
+_write(chunk,end,cb){
+cb();
+}
 }
-util.inherits(Writable,stream.Writable);
-Writable.prototype._write=function(chunk,end,cb){
-cb();
-};
 
-functionReadable(){
-this.readable=true;
-stream.Readable.call(this);
+classReadableextendsstream.Readable{
+_read(){
+this.push(null);
+}
 }
-util.inherits(Readable,stream.Readable);
-Readable.prototype._read=function(){
-this.push(null);
-};
 
 constw=newWritable();
 w.on('pipe',common.mustCall());