text: /**
   * Module dependencies.
   */
  
  var fs = require('fs');
  var url = require('url');
  var net = require('net');
  var tls = require('tls');
  var http = require('http');
  var https = require('https');
  var WebSocket = require('ws');
  var assert = require('assert');
  var events = require('events');
  var inherits = require('util').inherits;
  var Agent = require('../');
  
  var PassthroughAgent = Agent(function(req, opts) {
    return opts.secureEndpoint ? https.globalAgent : http.globalAgent;
  });
  
  describe('Agent', function() {
    describe('subclass', function() {
      it('should be subclassable', function(done) {
        function MyAgent() {
          Agent.call(this);
        }
        inherits(MyAgent, Agent);
  
        MyAgent.prototype.callback = function(req, opts, fn) {
          assert.equal(req.path, '/foo');
          assert.equal(req.getHeader('host'), '127.0.0.1:1234');
          assert.equal(opts.secureEndpoint, true);
          done();
        };
  
        var info = url.parse('https://127.0.0.1:1234/foo');
        info.agent = new MyAgent();
        https.get(info);
      });
    });
    describe('options', function() {
      it('should support an options Object as first argument', function() {
        var agent = new Agent({ timeout: 1000 });
        assert.equal(1000, agent.timeout);
      });
      it('should support an options Object as second argument', function() {
        var agent = new Agent(function() {}, { timeout: 1000 });
        assert.equal(1000, agent.timeout);
      });
      it('should be mixed in with HTTP request options', function(done) {
        var agent = new Agent({
          host: 'my-proxy.com',
          port: 3128,
          foo: 'bar'
        });
        agent.callback = function(req, opts, fn) {
          assert.equal('bar', opts.foo);
          assert.equal('a', opts.b);
  
          // `host` and `port` are special-cases, and should always be
          // overwritten in the request `opts` inside the agent-base callback
          assert.equal('localhost', opts.host);
          assert.equal(80, opts.port);
          done();
        };
        var opts = {
          b: 'a',
          agent: agent
        };
        http.get(opts);
      });
    });
    describe('`this` context', function() {
      it('should be the Agent instance', function(done) {
        var called = false;
        var agent = new Agent();
        agent.callback = function() {
          called = true;
          assert.equal(this, agent);
        };
        var info = url.parse('http://127.0.0.1/foo');
        info.agent = agent;
        var req = http.get(info);
        req.on('error', function(err) {
          assert(/no Duplex stream was returned/.test(err.message));
          done();
        });
      });
      it('should be the Agent instance with callback signature', function(done) {
        var called = false;
        var agent = new Agent();
        agent.callback = function(req, opts, fn) {
          called = true;
          assert.equal(this, agent);
          fn();
        };
        var info = url.parse('http://127.0.0.1/foo');
        info.agent = agent;
        var req = http.get(info);
        req.on('error', function(err) {
          assert(/no Duplex stream was returned/.test(err.message));
          done();
        });
      });
    });
    describe('"error" event', function() {
      it('should be invoked on `http.ClientRequest` instance if `callback()` has not been defined', function(
        done
      ) {
        var agent = new Agent();
        var info = url.parse('http://127.0.0.1/foo');
        info.agent = agent;
        var req = http.get(info);
        req.on('error', function(err) {
          assert.equal(
            '"agent-base" has no default implementation, you must subclass and override `callback()`',
            err.message
          );
          done();
        });
      });
      it('should be invoked on `http.ClientRequest` instance if Error passed to callback function on the first tick', function(
        done
      ) {
        var agent = new Agent(function(req, opts, fn) {
          fn(new Error('is this caught?'));
        });
        var info = url.parse('http://127.0.0.1/foo');
        info.agent = agent;
        var req = http.get(info);
        req.on('error', function(err) {
          assert.equal('is this caught?', err.message);
          done();
        });
      });
      it('should be invoked on `http.ClientRequest` instance if Error passed to callback function after the first tick', function(
        done
      ) {
        var agent = new Agent(function(req, opts, fn) {
          setTimeout(function() {
            fn(new Error('is this caught?'));
          }, 10);
        });
        var info = url.parse('http://127.0.0.1/foo');
        info.agent = agent;
        var req = http.get(info);
        req.on('error', function(err) {
          assert.equal('is this caught?', err.message);
          done();
        });
      });
    });
    describe('artificial "streams"', function() {
      it('should send a GET request', function(done) {
        var stream = new events.EventEmitter();
  
        // needed for the `http` module to call .write() on the stream
        stream.writable = true;
  
        stream.write = function(str) {
          assert(0 == str.indexOf('GET / HTTP/1.1'));
          done();
        };
  
        // needed for `http` module in Node.js 4
        stream.cork = function() {};
  
        var opts = {
          method: 'GET',
          host: '127.0.0.1',
          path: '/',
          port: 80,
          agent: new Agent(function(req, opts, fn) {
            fn(null, stream);
          })
        };
        var req = http.request(opts);
        req.end();
      });
      it('should receive a GET response', function(done) {
        var stream = new events.EventEmitter();
        var opts = {
          method: 'GET',
          host: '127.0.0.1',
          path: '/',
          port: 80,
          agent: new Agent(function(req, opts, fn) {
            fn(null, stream);
          })
        };
        var req = http.request(opts, function(res) {
          assert.equal('1.0', res.httpVersion);
          assert.equal(200, res.statusCode);
          assert.equal('bar', res.headers.foo);
          assert.deepEqual(['1', '2'], res.headers['set-cookie']);
          done();
        });
  
        // have to wait for the "socket" event since `http.ClientRequest`
        // doesn't *actually* attach the listeners to the "stream" until
        // this happens
        req.once('socket', function() {
          var buf = Buffer.from(
            'HTTP/1.0 200\r\n' +
              'Foo: bar\r\n' +
              'Set-Cookie: 1\r\n' +
              'Set-Cookie: 2\r\n\r\n'
          );
          stream.emit('data', buf);
        });
  
        req.end();
      });
    });
  });
  
  describe('"http" module', function() {
    var server;
    var port;
  
    // setup test HTTP server
    before(function(done) {
      server = http.createServer();
      server.listen(0, function() {
        port = server.address().port;
        done();
      });
    });
  
    // shut down test HTTP server
    after(function(done) {
      server.once('close', function() {
        done();
      });
      server.close();
    });
  
    it('should work for basic HTTP requests', function(done) {
      var called = false;
      var agent = new Agent(function(req, opts, fn) {
        called = true;
        var socket = net.connect(opts);
        fn(null, socket);
      });
  
      // add HTTP server "request" listener
      var gotReq = false;
      server.once('request', function(req, res) {
        gotReq = true;
        res.setHeader('X-Foo', 'bar');
        res.setHeader('X-Url', req.url);
        res.end();
      });
  
      var info = url.parse('http://127.0.0.1:' + port + '/foo');
      info.agent = agent;
      http.get(info, function(res) {
        assert.equal('bar', res.headers['x-foo']);
        assert.equal('/foo', res.headers['x-url']);
        assert(gotReq);
        assert(called);
        done();
      });
    });
  
    it('should support direct return in `connect()`', function(done) {
      var called = false;
      var agent = new Agent(function(req, opts) {
        called = true;
        return net.connect(opts);
      });
  
      // add HTTP server "request" listener
      var gotReq = false;
      server.once('request', function(req, res) {
        gotReq = true;
        res.setHeader('X-Foo', 'bar');
        res.setHeader('X-Url', req.url);
        res.end();
      });
  
      var info = url.parse('http://127.0.0.1:' + port + '/foo');
      info.agent = agent;
      http.get(info, function(res) {
        assert.equal('bar', res.headers['x-foo']);
        assert.equal('/foo', res.headers['x-url']);
        assert(gotReq);
        assert(called);
        done();
      });
    });
  
    it('should support returning a Promise in `connect()`', function(done) {
      var called = false;
      var agent = new Agent(function(req, opts) {
        return new Promise(function(resolve, reject) {
          called = true;
          resolve(net.connect(opts));
        });
      });
  
      // add HTTP server "request" listener
      var gotReq = false;
      server.once('request', function(req, res) {
        gotReq = true;
        res.setHeader('X-Foo', 'bar');
        res.setHeader('X-Url', req.url);
        res.end();
      });
  
      var info = url.parse('http://127.0.0.1:' + port + '/foo');
      info.agent = agent;
      http.get(info, function(res) {
        assert.equal('bar', res.headers['x-foo']);
        assert.equal('/foo', res.headers['x-url']);
        assert(gotReq);
        assert(called);
        done();
      });
    });
  
    it('should set the `Connection: close` response header', function(done) {
      var called = false;
      var agent = new Agent(function(req, opts, fn) {
        called = true;
        var socket = net.connect(opts);
        fn(null, socket);
      });
  
      // add HTTP server "request" listener
      var gotReq = false;
      server.once('request', function(req, res) {
        gotReq = true;
        res.setHeader('X-Url', req.url);
        assert.equal('close', req.headers.connection);
        res.end();
      });
  
      var info = url.parse('http://127.0.0.1:' + port + '/bar');
      info.agent = agent;
      http.get(info, function(res) {
        assert.equal('/bar', res.headers['x-url']);
        assert.equal('close', res.headers.connection);
        assert(gotReq);
        assert(called);
        done();
      });
    });
  
    it('should pass through options from `http.request()`', function(done) {
      var agent = new Agent(function(req, opts, fn) {
        assert.equal('google.com', opts.host);
        assert.equal('bar', opts.foo);
        done();
      });
  
      http.get({
        host: 'google.com',
        foo: 'bar',
        agent: agent
      });
    });
  
    it('should default to port 80', function(done) {
      var agent = new Agent(function(req, opts, fn) {
        assert.equal(80, opts.port);
        done();
      });
  
      // (probably) not hitting a real HTTP server here,
      // so no need to add a httpServer request listener
      http.get({
        host: '127.0.0.1',
        path: '/foo',
        agent: agent
      });
    });
  
    it('should support the "timeout" option', function(done) {
      // ensure we timeout after the "error" event had a chance to trigger
      this.timeout(1000);
      this.slow(800);
  
      var agent = new Agent(
        function(req, opts, fn) {
          // this function will time out
        },
        { timeout: 100 }
      );
  
      var opts = url.parse('http://nodejs.org');
      opts.agent = agent;
  
      var req = http.get(opts);
      req.once('error', function(err) {
        assert.equal('ETIMEOUT', err.code);
        req.abort();
        done();
      });
    });
  
    it('should free sockets after use', function(done) {
      var agent = new Agent(function(req, opts, fn) {
        var socket = net.connect(opts);
        fn(null, socket);
      });
  
      // add HTTP server "request" listener
      var gotReq = false;
      server.once('request', function(req, res) {
        gotReq = true;
        res.end();
      });
  
      var info = url.parse('http://127.0.0.1:' + port + '/foo');
      info.agent = agent;
      http.get(info, function(res) {
        res.socket.emit('free');
        assert.equal(true, res.socket.destroyed);
        assert(gotReq);
        done();
      });
    });
  
  
    describe('PassthroughAgent', function() {
      it('should pass through to `http.globalAgent`', function(done) {
        // add HTTP server "request" listener
        var gotReq = false;
        server.once('request', function(req, res) {
          gotReq = true;
          res.setHeader('X-Foo', 'bar');
          res.setHeader('X-Url', req.url);
          res.end();
        });
  
        var info = url.parse('http://127.0.0.1:' + port + '/foo');
        info.agent = PassthroughAgent;
        http.get(info, function(res) {
          assert.equal('bar', res.headers['x-foo']);
          assert.equal('/foo', res.headers['x-url']);
          assert(gotReq);
          done();
        });
      });
    });
  });
  
  describe('"https" module', function() {
    var server;
    var port;
  
    // setup test HTTPS server
    before(function(done) {
      var options = {
        key: fs.readFileSync(__dirname + '/ssl-cert-snakeoil.key'),
        cert: fs.readFileSync(__dirname + '/ssl-cert-snakeoil.pem')
      };
      server = https.createServer(options);
      server.listen(0, function() {
        port = server.address().port;
        done();
      });
    });
  
    // shut down test HTTP server
    after(function(done) {
      server.once('close', function() {
        done();
      });
      server.close();
    });
  
    it('should not modify the passed in Options object', function(done) {
      var called = false;
      var agent = new Agent(function(req, opts, fn) {
        called = true;
        assert.equal(true, opts.secureEndpoint);
        assert.equal(443, opts.port);
        assert.equal('localhost', opts.host);
      });
      var opts = { agent: agent };
      var req = https.request(opts);
      assert.equal(true, called);
      assert.equal(false, 'secureEndpoint' in opts);
      assert.equal(false, 'port' in opts);
      done();
    });
  
    it('should work with a String URL', function(done) {
      var endpoint = 'https://127.0.0.1:' + port;
      var req = https.get(endpoint);
  
      // it's gonna error out since `rejectUnauthorized` is not being passed in
      req.on('error', function(err) {
        assert.equal(err.code, 'DEPTH_ZERO_SELF_SIGNED_CERT');
        done();
      });
    });
  
    it('should work for basic HTTPS requests', function(done) {
      var called = false;
      var agent = new Agent(function(req, opts, fn) {
        called = true;
        assert(opts.secureEndpoint);
        var socket = tls.connect(opts);
        fn(null, socket);
      });
  
      // add HTTPS server "request" listener
      var gotReq = false;
      server.once('request', function(req, res) {
        gotReq = true;
        res.setHeader('X-Foo', 'bar');
        res.setHeader('X-Url', req.url);
        res.end();
      });
  
      var info = url.parse('https://127.0.0.1:' + port + '/foo');
      info.agent = agent;
      info.rejectUnauthorized = false;
      https.get(info, function(res) {
        assert.equal('bar', res.headers['x-foo']);
        assert.equal('/foo', res.headers['x-url']);
        assert(gotReq);
        assert(called);
        done();
      });
    });
  
    it('should pass through options from `https.request()`', function(done) {
      var agent = new Agent(function(req, opts, fn) {
        assert.equal('google.com', opts.host);
        assert.equal('bar', opts.foo);
        done();
      });
  
      https.get({
        host: 'google.com',
        foo: 'bar',
        agent: agent
      });
    });
  
    it('should support the 3-argument `https.get()`', function(done) {
      var agent = new Agent(function(req, opts, fn) {
        assert.equal('google.com', opts.host);
        assert.equal('/q', opts.pathname || opts.path);
        assert.equal('881', opts.port);
        assert.equal('bar', opts.foo);
        done();
      });
  
      https.get(
        'https://google.com:881/q',
        {
          host: 'google.com',
          foo: 'bar',
          agent: agent
        }
      );
    });
  
    it('should default to port 443', function(done) {
      var agent = new Agent(function(req, opts, fn) {
        assert.equal(true, opts.secureEndpoint);
        assert.equal(false, opts.rejectUnauthorized);
        assert.equal(443, opts.port);
        done();
      });
  
      // (probably) not hitting a real HTTPS server here,
      // so no need to add a httpsServer request listener
      https.get({
        host: '127.0.0.1',
        path: '/foo',
        agent: agent,
        rejectUnauthorized: false
      });
    });
  
    it('should not re-patch https.request', () => {
      var patchModulePath = "../patch-core";
      var patchedRequest = https.request;
  
      delete require.cache[require.resolve(patchModulePath)];
      require(patchModulePath);
  
      assert.equal(patchedRequest, https.request);
      assert.equal(true, https.request.__agent_base_https_request_patched__);
    });
  
    describe('PassthroughAgent', function() {
      it('should pass through to `https.globalAgent`', function(done) {
        // add HTTP server "request" listener
        var gotReq = false;
        server.once('request', function(req, res) {
          gotReq = true;
          res.setHeader('X-Foo', 'bar');
          res.setHeader('X-Url', req.url);
          res.end();
        });
  
        var info = url.parse('https://127.0.0.1:' + port + '/foo');
        info.agent = PassthroughAgent;
        info.rejectUnauthorized = false;
        https.get(info, function(res) {
          assert.equal('bar', res.headers['x-foo']);
          assert.equal('/foo', res.headers['x-url']);
          assert(gotReq);
          done();
        });
      });
    });
  });
  
  describe('"ws" server', function() {
    var wss;
    var server;
    var port;
  
    // setup test HTTP server
    before(function(done) {
      server = http.createServer();
      wss = new WebSocket.Server({ server: server });
      server.listen(0, function() {
        port = server.address().port;
        done();
      });
    });
  
    // shut down test HTTP server
    after(function(done) {
      server.once('close', function() {
        done();
      });
      server.close();
    });
  
    it('should work for basic WebSocket connections', function(done) {
      function onconnection(ws) {
        ws.on('message', function(data) {
          assert.equal('ping', data);
          ws.send('pong');
        });
      }
      wss.on('connection', onconnection);
  
      var agent = new Agent(function(req, opts, fn) {
        var socket = net.connect(opts);
        fn(null, socket);
      });
  
      var client = new WebSocket('ws://127.0.0.1:' + port + '/', {
        agent: agent
      });
  
      client.on('open', function() {
        client.send('ping');
      });
  
      client.on('message', function(data) {
        assert.equal('pong', data);
        client.close();
        wss.removeListener('connection', onconnection);
        done();
      });
    });
  });
  
  describe('"wss" server', function() {
    var wss;
    var server;
    var port;
  
    // setup test HTTP server
    before(function(done) {
      var options = {
        key: fs.readFileSync(__dirname + '/ssl-cert-snakeoil.key'),
        cert: fs.readFileSync(__dirname + '/ssl-cert-snakeoil.pem')
      };
      server = https.createServer(options);
      wss = new WebSocket.Server({ server: server });
      server.listen(0, function() {
        port = server.address().port;
        done();
      });
    });
  
    // shut down test HTTP server
    after(function(done) {
      server.once('close', function() {
        done();
      });
      server.close();
    });
  
    it('should work for secure WebSocket connections', function(done) {
      function onconnection(ws) {
        ws.on('message', function(data) {
          assert.equal('ping', data);
          ws.send('pong');
        });
      }
      wss.on('connection', onconnection);
  
      var agent = new Agent(function(req, opts, fn) {
        var socket = tls.connect(opts);
        fn(null, socket);
      });
  
      var client = new WebSocket('wss://127.0.0.1:' + port + '/', {
        agent: agent,
        rejectUnauthorized: false
      });
  
      client.on('open', function() {
        client.send('ping');
      });
  
      client.on('message', function(data) {
        assert.equal('pong', data);
        client.close();
        wss.removeListener('connection', onconnection);
        done();
      });
    });
  });
  