Repository: mcollina/autocannon
Branch: master
Commit: 225e3a30a6ad
Files: 105
Total size: 335.6 KB

Directory structure:
gitextract_p81k9btq/

├── .github/
│   ├── dependabot.yml
│   ├── release-drafter.yml
│   ├── tests_checker.yml
│   └── workflows/
│       └── nodejs.yml
├── .gitignore
├── .npmignore
├── .taprc
├── LICENSE
├── README.md
├── autocannon.js
├── cluster.js
├── for-zero-x.js
├── help.txt
├── lib/
│   ├── aggregateResult.js
│   ├── defaultOptions.js
│   ├── format.js
│   ├── histUtil.js
│   ├── httpClient.js
│   ├── httpMethods.js
│   ├── httpRequestBuilder.js
│   ├── init.js
│   ├── manager.js
│   ├── multipart.js
│   ├── noop.js
│   ├── parseHAR.js
│   ├── pipelinedRequestsQueue.js
│   ├── preload/
│   │   └── autocannonDetectPort.js
│   ├── printResult.js
│   ├── progressTracker.js
│   ├── requestIterator.js
│   ├── run.js
│   ├── runTracker.js
│   ├── subargAliases.js
│   ├── url.js
│   ├── util.js
│   ├── validate.js
│   ├── worker.js
│   └── worker_threads.js
├── package.json
├── samples/
│   ├── bench-multi-url.js
│   ├── customise-individual-connection.js
│   ├── customise-verifyBody-workers.js
│   ├── customise-verifyBody.js
│   ├── helpers/
│   │   ├── on-response.js
│   │   ├── setup-request.js
│   │   └── verify-body.js
│   ├── init-context.js
│   ├── modifying-request.js
│   ├── request-context-workers.js
│   ├── request-context.js
│   ├── requests-sample.js
│   ├── track-run-workers.js
│   ├── track-run.js
│   └── using-id-replacement.js
├── server.js
└── test/
    ├── aggregateResult.test.js
    ├── argumentParsing.test.js
    ├── basic-auth.test.js
    ├── cert.pem
    ├── cli-ipc.test.js
    ├── cli.test.js
    ├── debug.test.js
    ├── envPort.test.js
    ├── fixtures/
    │   ├── example-result.json
    │   ├── httpbin-get.json
    │   ├── httpbin-post.json
    │   ├── httpbin-simple-get.json
    │   └── multi-domains.json
    ├── forever.test.js
    ├── format.test.js
    ├── helper.js
    ├── httpClient.test.js
    ├── httpRequestBuilder.test.js
    ├── key.pem
    ├── keystore.pkcs12
    ├── onPort.test.js
    ├── parseHAR.test.js
    ├── pipelinedRequestsQueue.test.js
    ├── printResult-process.js
    ├── printResult-renderStatusCodes.test.js
    ├── printResult.test.js
    ├── progressTracker.test.js
    ├── progressTracker.test.stub.js
    ├── requestIterator.test.js
    ├── run.test.js
    ├── runAmount.test.js
    ├── runMultiServer.test.js
    ├── runMultipart.test.js
    ├── runRate.test.js
    ├── sampleInt.test.js
    ├── serial/
    │   ├── autocannon.test.js
    │   ├── run.test.js
    │   ├── tap-parallel-not-ok
    │   └── wasm.test.js
    ├── subargAliases.test.js
    ├── tap-parallel-ok
    ├── targetProcess.js
    ├── url.test.js
    ├── utils/
    │   ├── has-worker-support.js
    │   ├── on-response.js
    │   ├── setup-client.js
    │   ├── setup-request.js
    │   └── verify-body.js
    ├── validate.test.js
    └── workers.test.js

================================================
FILE CONTENTS
================================================

================================================
FILE: .github/dependabot.yml
================================================
version: 2
updates:
  - package-ecosystem: github-actions
    directory: '/'
    schedule:
      interval: daily
    open-pull-requests-limit: 10
  - package-ecosystem: npm
    directory: '/'
    schedule:
      interval: daily
    open-pull-requests-limit: 10


================================================
FILE: .github/release-drafter.yml
================================================
template: |
    ## What’s Changed

    $CHANGES


================================================
FILE: .github/tests_checker.yml
================================================
comment: 'Could you please add tests to make sure this change works as expected?',
fileExtensions: ['.php', '.ts', '.js', '.c', '.cs', '.cpp', '.rb', '.java']
testDir: 'test'


================================================
FILE: .github/workflows/nodejs.yml
================================================
name: Node.js CI

on: [ push, pull_request ]

# This allows a subsequently queued workflow run to interrupt previous runs
concurrency:
  group: "${{ github.workflow }} @ ${{ github.event.pull_request.head.label || github.head_ref || github.ref }}"
  cancel-in-progress: true

jobs:
  test:
    runs-on: ${{ matrix.os }}
    permissions:
      contents: read
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]
        node-version: [20, 22]

    steps:
    - uses: actions/checkout@v3
      with:
        persist-credentials: false
    - name: Use Node.js ${{ matrix.node-version }}
      uses: actions/setup-node@v3
      with:
        node-version: ${{ matrix.node-version }}
    - run: node --version
    - run: npm --version
    - run: npm install
    - run: npm test
      env:
        CI: true

  automerge:
    if: >
        github.event_name == 'pull_request' &&
        github.event.pull_request.user.login == 'dependabot[bot]'
    needs: test
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write
      contents: write
    steps:
      - uses: fastify/github-action-merge-dependabot@v3
        with:
          exclude: 'chalk;pretty-bytes'
          github-token: ${{ secrets.github_token }}


================================================
FILE: .gitignore
================================================
# Logs
logs
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*
lerna-debug.log*

# Diagnostic reports (https://nodejs.org/api/report.html)
report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json

# Runtime data
pids
*.pid
*.seed
*.pid.lock

# Directory for instrumented libs generated by jscoverage/JSCover
lib-cov

# Coverage directory used by tools like istanbul
coverage
*.lcov

# nyc test coverage
.nyc_output

# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
.grunt

# Bower dependency directory (https://bower.io/)
bower_components

# node-waf configuration
.lock-wscript

# Compiled binary addons (https://nodejs.org/api/addons.html)
build/Release

# Dependency directories
node_modules/
jspm_packages/

# Snowpack dependency directory (https://snowpack.dev/)
web_modules/

# TypeScript cache
*.tsbuildinfo

# Optional npm cache directory
.npm

# Optional eslint cache
.eslintcache

# Microbundle cache
.rpt2_cache/
.rts2_cache_cjs/
.rts2_cache_es/
.rts2_cache_umd/

# Optional REPL history
.node_repl_history

# Output of 'npm pack'
*.tgz

# Yarn Integrity file
.yarn-integrity

# dotenv environment variables file
.env
.env.test

# parcel-bundler cache (https://parceljs.org/)
.cache
.parcel-cache

# Next.js build output
.next
out

# Nuxt.js build / generate output
.nuxt
dist

# Gatsby files
.cache/
# Comment in the public line in if your project uses Gatsby and not Next.js
# https://nextjs.org/blog/next-9-1#public-directory-support
# public

# vuepress build output
.vuepress/dist

# Serverless directories
.serverless/

# FuseBox cache
.fusebox/

# DynamoDB Local files
.dynamodb/

# TernJS port file
.tern-port

# Stores VSCode versions used for testing VSCode extensions
.vscode-test

# yarn v2
.yarn/cache
.yarn/unplugged
.yarn/build-state.yml
.yarn/install-state.gz
.pnp.*

# Vim swap files
*.swp

# macOS files
.DS_Store

# lock files
package-lock.json
yarn.lock

# editor files
.vscode
.idea

# Compiled binary addons (http://nodejs.org/api/addons.html)
build/Release

profile-*

.devcontainer
.history

================================================
FILE: .npmignore
================================================
# Logs
logs
*.log
npm-debug.log*

# Runtime data
pids
*.pid
*.seed

# Directory for instrumented libs generated by jscoverage/JSCover
lib-cov

# Coverage directory used by tools like istanbul
coverage

# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
.grunt

# node-waf configuration
.lock-wscript

# Compiled binary addons (http://nodejs.org/api/addons.html)
build/Release

# Dependency directory
node_modules

# Optional npm cache directory
.npm

# Optional REPL history
.node_repl_history

profile-*

demo.gif
server.js
*.png
appveyor.yml
.travis.yml
.github
.nyc_output


================================================
FILE: .taprc
================================================
ts: false
jsx: false
flow: false
timeout: 900
branches: 60
functions: 60
lines: 60
statements: 60


================================================
FILE: LICENSE
================================================
The MIT License (MIT)

Copyright (c) 2016 Matteo Collina

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


================================================
FILE: README.md
================================================
![banner](autocannon-banner.png)

# autocannon

![Node.js CI](https://github.com/mcollina/autocannon/workflows/Node.js%20CI/badge.svg)

![demo](https://raw.githubusercontent.com/mcollina/autocannon/master/demo.gif)

An HTTP/1.1 benchmarking tool written in node, greatly inspired by [wrk][wrk]
and [wrk2][wrk2], with support for HTTP pipelining and HTTPS.
On _my_ box, *autocannon* can produce more load than `wrk` and `wrk2`, see [limitations](#limitations) for more details.

* [Installation](#install)
* [Usage](#usage)
* [API](#api)
* [Acknowledgements](#acknowledgements)
* [License](#license)

## Install

```
npm i autocannon -g
```

or if you want to use the [API](#api) or as a dependency:

```
npm i autocannon --save
```

## Usage

### Command Line

```
Usage: autocannon [opts] URL

URL is any valid HTTP or HTTPS URL.
If the PORT environment variable is set, the URL can be a path. In that case 'http://localhost:$PORT/path' will be used as the URL.

Available options:

  -c/--connections NUM
        The number of concurrent connections to use. default: 10.
  -p/--pipelining NUM
        The number of pipelined requests to use. default: 1.
  -d/--duration SEC
        The number of seconds to run the autocannon. default: 10.
  -a/--amount NUM
        The number of requests to make before exiting the benchmark. If set, duration is ignored.
  -L NUM
        The number of milliseconds to elapse between taking samples. This controls the sample interval, & therefore the total number of samples, which affects statistical analyses. default: 1.
  -S/--socketPath
        A path to a Unix Domain Socket or a Windows Named Pipe. A URL is still required to send the correct Host header and path.
  -w/--workers
        Number of worker threads to use to fire requests.
  -W/--warmup
       Use a warm up interval before starting sampling.
       This enables startup processes to finish and traffic to normalize before sampling begins
       use -c and -d sub args e.g. `--warmup [ -c 1 -d 3 ]`
  --on-port
        Start the command listed after -- on the command line. When it starts listening on a port,
        start sending requests to that port. A URL is still required to send requests to
        the correct path. The hostname can be omitted, `localhost` will be used by default.
        If the command after -- is `node <script>`, this flag is optional and assumed to be `true`.
  -m/--method METHOD
        The HTTP method to use. default: 'GET'.
  -t/--timeout NUM
        The number of seconds before timing out and resetting a connection. default: 10
  -T/--title TITLE
        The title to place in the results for identification.
  -b/--body BODY
        The body of the request.
        NOTE: This option needs to be used with the '-H/--headers' option in some frameworks
  -F/--form FORM
        Upload a form (multipart/form-data). The form options can be a JSON string like
        '{ "field 1": { "type": "text", "value": "a text value"}, "field 2": { "type": "file", "path": "path to the file" } }'
        or a path to a JSON file containing the form options.
        When uploading a file the default filename value can be overridden by using the corresponding option:
        '{ "field name": { "type": "file", "path": "path to the file", "options": { "filename": "myfilename" } } }'
        Passing the filepath to the form can be done by using the corresponding option:
        '{ "field name": { "type": "file", "path": "path to the file", "options": { "filepath": "/some/path/myfilename" } } }'
  -i/--input FILE
        The body of the request. See '-b/body' for more details.
  -H/--headers K=V
        The request headers.
  --har FILE
        When provided, Autocannon will use requests from the HAR file.
        CAUTION: you have to specify one or more domains using URL option: only the HAR requests to the same domains will be considered.
        NOTE: you can still add extra headers with -H/--headers but -m/--method, -F/--form, -i/--input -b/--body will be ignored.
  -B/--bailout NUM
        The number of failures before initiating a bailout.
  -M/--maxConnectionRequests NUM
        The max number of requests to make per connection to the server.
  -O/--maxOverallRequests NUM
        The max number of requests to make overall to the server.
  -r/--connectionRate NUM
        The max number of requests to make per second from an individual connection.
  -R/--overallRate NUM
        The max number of requests to make per second from all connections.
        connection rate will take precedence if both are set.
        NOTE: if using rate limiting and a very large rate is entered which cannot be met, Autocannon will do as many requests as possible per second.
        Also, latency data will be corrected to compensate for the effects of the coordinated omission issue.
        If you are not familiar with the coordinated omission issue, you should probably read [this article](http://highscalability.com/blog/2015/10/5/your-load-generator-is-probably-lying-to-you-take-the-red-pi.html) or watch this [Gil Tene's talk](https://www.youtube.com/watch?v=lJ8ydIuPFeU) on the topic.
  -C/--ignoreCoordinatedOmission
        Ignore the coordinated omission issue when requests should be sent at a fixed rate using 'connectionRate' or 'overallRate'.
        NOTE: it is not recommended to enable this option.
        When the request rate cannot be met because the server is too slow, many request latencies might be missing and Autocannon might report a misleading latency distribution.
  -D/--reconnectRate NUM
        The number of requests to make before resetting a connections connection to the
        server.
  -n/--no-progress
        Don't render the progress bar. default: false.
  -l/--latency
        Print all the latency data. default: false.
  -I/--idReplacement
        Enable replacement of `[<id>]` with a randomly generated ID within the request body. e.g. `/items/[<id>]`. default: false.
  -j/--json
        Print the output as newline delimited JSON. This will cause the progress bar and results not to be rendered. default: false.
  -f/--forever
        Run the benchmark forever. Efficiently restarts the benchmark on completion. default: false.
  -s/--servername
        Server name for the SNI (Server Name Indication) TLS extension. Defaults to the hostname of the URL when it is not an IP address.
  -x/--excludeErrorStats
        Exclude error statistics (non-2xx HTTP responses) from the final latency and bytes per second averages. default: false.
  -E/--expectBody EXPECTED
        Ensure the body matches this value. If enabled, mismatches count towards bailout.
        Enabling this option will slow down the load testing.
  --renderStatusCodes
        Print status codes and their respective statistics.
  --cert
        Path to cert chain in pem format
  --key
        Path to private key for specified cert in pem format
  --ca
        Path to trusted ca certificates for the test. This argument accepts both a single file as well as a list of files
  --debug
        Print connection errors to stderr.
  -v/--version
        Print the version number.
  -V/--verbose
        Print the table with results. default: true.
  -h/--help
        Print this menu.
```

autocannon outputs data in tables like this:

```
Running 10s test @ http://localhost:3000
10 connections

┌─────────┬──────┬──────┬───────┬──────┬─────────┬─────────┬──────────┐
│ Stat    │ 2.5% │ 50%  │ 97.5% │ 99%  │ Avg     │ Stdev   │ Max      │
├─────────┼──────┼──────┼───────┼──────┼─────────┼─────────┼──────────┤
│ Latency │ 0 ms │ 0 ms │ 0 ms  │ 1 ms │ 0.02 ms │ 0.16 ms │ 16.45 ms │
└─────────┴──────┴──────┴───────┴──────┴─────────┴─────────┴──────────┘
┌───────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┐
│ Stat      │ 1%      │ 2.5%    │ 50%     │ 97.5%   │ Avg     │ Stdev   │ Min     │
├───────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┤
│ Req/Sec   │ 20623   │ 20623   │ 25583   │ 26271   │ 25131.2 │ 1540.94 │ 20615   │
├───────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┤
│ Bytes/Sec │ 2.29 MB │ 2.29 MB │ 2.84 MB │ 2.92 MB │ 2.79 MB │ 171 kB  │ 2.29 MB │
└───────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┘

Req/Bytes counts sampled once per second.

251k requests in 10.05s, 27.9 MB read
```

There are two tables: one for the request latency, and one for the request volume.

The latency table lists the request times at the 2.5% percentile, the fast outliers; at 50%, the median; at 97.5%, the slow outliers; at 99%, the very slowest outliers. Here, lower means faster.

The request volume table lists the number of requests sent and the number of bytes downloaded. These values are sampled once per second. Higher values mean more requests were processed. In the above example, 2.29 MB was downloaded in 1 second in the worst case (slowest 1%). Since we only ran for 10 seconds, there are just 10 samples, the Min value and the 1% and 2.5% percentiles are all the same sample. With longer durations these numbers will differ more.

When passing the `-l` flag, a third table lists all the latency percentiles recorded by autocannon:

```
┌────────────┬──────────────┐
│ Percentile │ Latency (ms) │
├────────────┼──────────────┤
│ 0.001      │ 0            │
├────────────┼──────────────┤
│ 0.01       │ 0            │
├────────────┼──────────────┤
│ 0.1        │ 0            │
├────────────┼──────────────┤
│ 1          │ 0            │
├────────────┼──────────────┤
│ 2.5        │ 0            │
├────────────┼──────────────┤
│ 10         │ 0            │
├────────────┼──────────────┤
│ 25         │ 0            │
├────────────┼──────────────┤
│ 50         │ 0            │
├────────────┼──────────────┤
│ 75         │ 0            │
├────────────┼──────────────┤
│ 90         │ 0            │
├────────────┼──────────────┤
│ 97.5       │ 0            │
├────────────┼──────────────┤
│ 99         │ 1            │
├────────────┼──────────────┤
│ 99.9       │ 1            │
├────────────┼──────────────┤
│ 99.99      │ 3            │
├────────────┼──────────────┤
│ 99.999     │ 15           │
└────────────┴──────────────┘
```

This can give some more insight if a lot (millions) of requests were sent.

### Programmatically

```js
'use strict'

const autocannon = require('autocannon')

autocannon({
  url: 'http://localhost:3000',
  connections: 10, //default
  pipelining: 1, // default
  duration: 10 // default
}, console.log)

// async/await
async function foo () {
  const result = await autocannon({
    url: 'http://localhost:3000',
    connections: 10, //default
    pipelining: 1, // default
    duration: 10 // default
  })
  console.log(result)
}

```

<a name="workers"></a>
#### Workers

In workers mode, `autocannon` uses instances of Node's [Worker](https://nodejs.org/dist/latest/docs/api/worker_threads.html#new-workerfilename-options) class to execute the load tests in multiple threads.

The `amount` and `connections` parameters are divided amongst the workers. If either parameter is not integer divisible by the number of `workers`, the per-worker value is rounded to the lowest integer, or set to `1`, whichever is the higher. All other parameters are applied per-worker as if the test were single-threaded.

**NOTE:** Unlike `amount` and `connections`, the "overall" parameters, `maxOverallRequests` and `overallRate`, are applied **_per worker_**. For example, if you set `connections` to `4`, `workers` to `2` and `maxOverallRequests` to `10`, each worker will receive `2` connections and a `maxOverallRequests` of `10`, resulting in `20` requests being sent.

```js
'use strict'

const autocannon = require('autocannon')

autocannon({
  url: 'http://localhost:3000',
  connections: 10, //default
  pipelining: 1, // default
  duration: 10, // default
  workers: 4
}, console.log)
```

**NOTE:** When in workers mode, you need to pass in an absolute file path to all the options that accept a `function`. This is because a function passed into the main process can not be cloned and passed to the worker. So instead, it needs a file that it can `require`. The options with this behaviour are shown in the below example

```js
'use strict'

const autocannon = require('autocannon')

autocannon({
  // ...
  workers: 4,
  setupClient: '/full/path/to/setup-client.js',
  verifyBody: '/full/path/to/verify-body.js'
  requests: [
    {
      // ...
      onResponse: '/full/path/to/on-response.js'
    },
    {
      // ...
      setupRequest: '/full/path/to/setup-request.js'
    }
  ]
}, console.log)
```

## API

### autocannon(opts[, cb])

Start autocannon against the given target.

* `opts`: Configuration options for the autocannon instance. This can have the following attributes. _REQUIRED_.
    * `url`: The given target. Can be HTTP or HTTPS. More than one URL is allowed, but it is recommended that the number of connections is an integer multiple of the URL. _REQUIRED_.
    * `socketPath`: A path to a Unix Domain Socket or a Windows Named Pipe. A `url` is still required to send the correct Host header and path. _OPTIONAL_.
    * `workers`: Number of worker threads to use to fire requests.
    * `connections`: The number of concurrent connections. _OPTIONAL_ default: `10`.
    * `duration`: The number of seconds to run the autocannon. Can be a [timestring](https://www.npmjs.com/package/timestring). _OPTIONAL_ default: `10`.
    * `amount`: A `Number` stating the number of requests to make before ending the test. This overrides duration and takes precedence, so the test won't end until the number of requests needed to be completed is completed. _OPTIONAL_.
    * `sampleInt`: The number of milliseconds to elapse between taking samples. This controls the sample interval, & therefore the total number of samples, which affects statistical analyses. default: 1.
    * `timeout`: The number of seconds to wait for a response before. _OPTIONAL_ default: `10`.
    * `pipelining`: The number of [pipelined requests](https://en.wikipedia.org/wiki/HTTP_pipelining) for each connection. Will cause the `Client` API to throw when greater than 1. _OPTIONAL_ default: `1`.
    * `bailout`: The threshold of the number of errors when making the requests to the server before this instance bail's out. This instance will take all existing results so far and aggregate them into the results. If none passed here, the instance will ignore errors and never bail out. _OPTIONAL_ default: `undefined`.
    * `method`: The HTTP method to use. _OPTIONAL_ `default: 'GET'`.
    * `title`: A `String` to be added to the results for identification. _OPTIONAL_ default: `undefined`.
    * `body`: A `String` or a `Buffer` containing the body of the request. Insert one or more randomly generated IDs into the body by including `[<id>]` where the randomly generated ID should be inserted (Must also set idReplacement to true). This can be useful in soak testing POST endpoints where one or more fields must be unique. Leave undefined for an empty body. _OPTIONAL_ default: `undefined`.
    * `form`: A `String` or an `Object` containing the multipart/form-data options or a path to the JSON file containing them
    * `headers`: An `Object` containing the headers of the request. _OPTIONAL_ default: `{}`.
    * `initialContext`: An object that you'd like to initialize your context with. Check out [an example of initializing context](./samples/init-context.js). _OPTIONAL_
    * `setupClient`: A `Function` which will be passed the `Client` object for each connection to be made. This can be used to customise each individual connection headers and body using the API shown below. The changes you make to the client in this function will take precedence over the default `body` and `headers` you pass in here. There is an example of this in the samples folder. _OPTIONAL_ default: `function noop () {}`. When using `workers`, you need to supply a file path that default exports a function instead (Check out the [workers](#workers) section for more details).
    * `verifyBody`: A `Function` which will be passed the response body for each completed request. Each request, whose `verifyBody` function does not return a truthy value, is counted in `mismatches`. This function will take precedence over the `expectBody`. There is an example of this in the samples folder. When using `workers`, you need to supply a file path that default exports a function (Check out the [workers](#workers) section for more details).
    * `maxConnectionRequests`: A `Number` stating the max requests to make per connection. `amount` takes precedence if both are set. _OPTIONAL_
    * `maxOverallRequests`: A `Number` stating the max requests to make overall. Can't be less than `connections`. `maxConnectionRequests` takes precedence if both are set. _OPTIONAL_
    * `connectionRate`: A `Number` stating the rate of requests to make per second from each individual connection. No rate limiting by default. _OPTIONAL_
    * `overallRate`: A `Number` stating the rate of requests to make per second from all connections. `connectionRate` takes precedence if both are set. No rate limiting by default. _OPTIONAL_
    * `ignoreCoordinatedOmission`: A `Boolean` which disables the correction of latencies to compensate for the coordinated omission issue. Does not make sense when no rate of requests has been specified (`connectionRate` or `overallRate`). _OPTIONAL_ default: `false`.
    * `reconnectRate`: A `Number` that makes the individual connections disconnect and reconnect to the server whenever it has sent that number of requests. _OPTIONAL_
    * `requests`: An `Array` of `Object`s which represents the sequence of requests to make while benchmarking. Can be used in conjunction with the `body`, `headers` and `method` params above. Check the samples folder for an example of how this might be used. _OPTIONAL_. Contained objects can have these attributes:
       * `body`: When present, will override `opts.body`. _OPTIONAL_
       * `headers`: When present, will override `opts.headers`. _OPTIONAL_
       * `method`: When present, will override `opts.method`. _OPTIONAL_
       * `path`: When present, will override `opts.path`. _OPTIONAL_
       * `setupRequest`: A `Function` you may provide to mutate the raw `request` object, e.g. `request.method = 'GET'`. It takes `request` (Object) and `context` (Object) parameters, and must return the modified request. When it returns a falsey value, autocannon will restart from first request. When using `workers`, you need to supply a file path that default exports a function instead (Check out [workers](#workers) section for more details) _OPTIONAL_
       * `onResponse`: A `Function` you may provide to process the received response. It takes `status` (Number), `body` (String) `context` (Object) parameters and `headers` (Key-Value Object). When using `workers`, you need to supply a file path that default exports a function instead (Check out [workers](#workers) section for more details) _OPTIONAL_
    * `har`: an `Object` of parsed [HAR](https://w3c.github.io/web-performance/specs/HAR/Overview.html) content. Autocannon will extra and use `entries.request`: `requests`, `method`, `form` and `body` options will be ignored. _NOTE_: you must ensure that entries are targeting the same domain as `url` option. _OPTIONAL_
    * `idReplacement`: A `Boolean` which enables the replacement of `[<id>]` tags within the request body with a randomly generated ID, allowing for unique fields to be sent with requests. Check out [an example of programmatic usage](./samples/using-id-replacement.js) that can be found in the samples. _OPTIONAL_ default: `false`
    * `forever`: A `Boolean` which allows you to setup an instance of autocannon that restarts indefinitely after emitting results with the `done` event. Useful for efficiently restarting your instance. To stop running forever, you must cause a `SIGINT` or call the `.stop()` function on your instance. _OPTIONAL_ default: `false`
    * `servername`: A `String` identifying the server name for the SNI (Server Name Indication) TLS extension. _OPTIONAL_ default: Defaults to the hostname of the URL when it is not an IP address.
    * `excludeErrorStats`: A `Boolean` which allows you to disable tracking non-2xx code responses in latency and bytes per second calculations. _OPTIONAL_ default: `false`.
    * `expectBody`: A `String` representing the expected response body. Each request whose response body is not equal to `expectBody`is counted in `mismatches`. If enabled, mismatches count towards bailout. _OPTIONAL_
    * `tlsOptions`: An `Object` that is passed into `tls.connect` call ([Full list of options](https://nodejs.org/api/tls.html#tls_tls_connect_port_host_options_callback)). Note: this only applies if your URL is secure.
    * `skipAggregateResult`: A `Boolean` which allows you to disable the aggregate result phase of an instance run. See [autocannon.aggregateResult](<#autocannon.aggregateResult(results[, opts])>)
* `cb`: The callback which is called on completion of a benchmark. Takes the following params. _OPTIONAL_.
    * `err`: If there was an error encountered with the run.
    * `results`: The results of the run.

**Returns** an instance/event emitter for tracking progress, etc. If `cb` is omitted, the return value can also be used as a Promise.

### Customizing sent requests

When running, autocannon will create as many `Client` objects as desired connections. They will run in parallel until the benchmark is over (duration or total number of requests).
Each client will loop over the `requests` array, would it contain one or several requests.

While going through available requests, the client will maintain a `context`: an object you can use in `onResponse` and `setupRequest` functions, to store and read some contextual data.
Please check the `request-context.js` file in samples.

Note that `context` object will be reset to `initialContext` (or `{}` it is not provided) when restarting to the first available request, ensuring similar runs.

### Combining connections, overallRate and amount

When combining a fixed `amount` of requests with concurrent `connections` and an `overallRate` limit, autocannon will distribute the requests and the intended rate over all connections. If the `overallRate` is not integer divisible, autocannon will configure some connection clients with a higher and some with a lower number of requests/second rate. If now the `amount` *is* integer divisible, all connection clients get the same number of requests. This means that the clients with a higher request rate will finish earlier, than the others, leading to a drop in the perceived request rate.

Example: `connections = 10, overallRate = 17, amount = 5000`


### autocannon.track(instance[, opts])

Track the progress of your autocannon, programmatically.

* `instance`: The instance of autocannon. _REQUIRED_.
* `opts`: Configuration options for tracking. This can have the following attributes. _OPTIONAL_.
    * `outputStream`: The stream to output to. default: `process.stderr`.
    * `renderProgressBar`: A truthy value to enable the rendering of the progress bar. default: `true`.
    * `renderResultsTable`: A truthy value to enable the rendering of the results table. default: `true`.
    * `renderLatencyTable`: A truthy value to enable the rendering of the advanced latency table. default: `false`.
    * `progressBarString`: A `string` defining the format of the progress display output. Must be valid input for the [progress bar module](http://npm.im/progress). default: `'running [:bar] :percent'`.

Example that just prints the table of results on completion:

```js
'use strict'

const autocannon = require('autocannon')

const instance = autocannon({
  url: 'http://localhost:3000'
}, console.log)

// this is used to kill the instance on CTRL-C
process.once('SIGINT', () => {
  instance.stop()
})

// just render results
autocannon.track(instance, {renderProgressBar: false})
```

Check out [this example](./samples/track-run.js) to see it in use, as well.

### autocannon.printResult(resultObject[, opts])

Returns a text string containing the result tables.

* `resultObject`: The result object of autocannon. _REQUIRED_.
* `opts`: Configuration options for generating the tables. These may include the following attributes. _OPTIONAL_.
    * `outputStream`: The stream to which output is directed. It is primarily used to check if the terminal supports color. default: `process.stderr`.
    * `renderResultsTable`: A truthy value to enable the creation of the results table. default: `true`.
    * `renderLatencyTable`: A truthy value to enable the creation of the latency table. default: `false`.

Example:

```js
"use strict";

const { stdout } = require("node:process");
const autocannon = require("autocannon");

function print(result) {
  stdout.write(autocannon.printResult(result));
}

autocannon({ url: "http://localhost:3000" }, (err, result) => print(result));
```

### autocannon.aggregateResult(results[, opts])

Aggregate the results of one or more autocannon instance runs, where the instances of autocannon have been run with the `skipAggregateResult` option.

This is an advanced use case, where you might be running a load test using autocannon across multiple machines and therefore need to defer aggregating the results to a later time.

* `results`: An array of autocannon instance results, where the instances have been run with the `skipAggregateResult` option set to true. _REQUIRED_.
* `opts`: This is a subset of the options you would pass to the main autocannon API, so you could use the same options object as the one used to run the instances. See [autocannon](<#autocannon(opts[, cb])>) for full descriptions of the options. _REQUIRED_.
    * `url`: _REQUIRED_
    * `title`: _OPTIONAL_ default: `undefined`
    * `socketPath`: _OPTIONAL_
    * `connections`: _OPTIONAL_ default: `10`.
    * `sampleInt`: _OPTIONAL_ default: `1`
    * `pipelining`: _OPTIONAL_ default: `1`
    * `workers`: _OPTIONAL_ default: `undefined`

### Autocannon events

Because an autocannon instance is an `EventEmitter`, it emits several events. these are below:

* `start`: Emitted once everything has been setup in your autocannon instance and it has started. Useful for if running the instance forever.
* `tick`: Emitted every second this autocannon is running a benchmark. Useful for displaying stats, etc. Used by the `track` function. The `tick` event propagates  an object containing the `counter` and `bytes` values, which can be used for extended reports.
* `done`: Emitted when the autocannon finishes a benchmark. passes the `results` as an argument to the callback.
* `response`: Emitted when the autocannons http-client gets an HTTP response from the server. This passes the following arguments to the callback:
    * `client`: The `http-client` itself. Can be used to modify the headers and body the client will send to the server. API below.
    * `statusCode`: The HTTP status code of the response.
    * `resBytes`: The response byte length.
    * `responseTime`: The time taken to get a response after initiating the request.
* `reqError`: Emitted in the case of a request error e.g. a timeout.
* `error`: Emitted if there is an error during the setup phase of autocannon.

### Results

The results object emitted by `done` and passed to the `autocannon()` callback has these properties:

* `title`: Value of the `title` option passed to `autocannon()`.
* `url`: The URL that was targeted.
* `socketPath`: The UNIX Domain Socket or Windows Named Pipe that was targeted, or `undefined`.
* `requests`: A histogram object containing statistics about the number of requests that were sent per second.
* `latency`: A histogram object containing statistics about response latency.
* `throughput`: A histogram object containing statistics about the response data throughput per second.
* `duration`: The amount of time the test took, **in seconds**.
* `errors`: The number of connection errors (including timeouts) that occurred.
* `timeouts`: The number of connection timeouts that occurred.
* `mismatches`: The number of requests with a mismatched body.
* `start`: A Date object representing when the test started.
* `finish`: A Date object representing when the test ended.
* `connections`: The amount of connections used (value of `opts.connections`).
* `pipelining`: The number of pipelined requests used per connection (value of `opts.pipelining`).
* `non2xx`: The number of non-2xx response status codes received.
* `resets`: How many times the requests pipeline was reset due to `setupRequest` returning a falsey value.
* `statusCodeStats`: Requests counter per status code (e.g. `{ "200": { "count": "500" } }`)

The histogram objects for `requests`, `latency` and `throughput` are [hdr-histogram-percentiles-obj](https://github.com/thekemkid/hdr-histogram-percentiles-obj) objects and have this shape:

* `min`: The lowest value for this statistic.
* `max`: The highest value for this statistic.
* `average`: The average (mean) value.
* `stddev`: The standard deviation.
* `p*`: The XXth percentile value for this statistic. The percentile properties are: `p2_5`, `p50`, `p75`, `p90`, `p97_5`, `p99`, `p99_9`, `p99_99`, `p99_999`.

### `Client` API

This object is passed as the first parameter of both the `setupClient` function and the `response` event from an autocannon instance. You can use this to modify the requests you are sending while benchmarking. This is also an `EventEmitter`, with the events and their params listed below.

* `client.setHeaders(headers)`: Used to modify the headers of the request this client iterator is currently on. `headers` should be an `Object`, or `undefined` if you want to remove your headers.
* `client.setBody(body)`: Used to modify the body of the request this client iterator is currently on. `body` should be a `String` or `Buffer`, or `undefined` if you want to remove the body.
* `client.setHeadersAndBody(headers, body)`: Used to modify both the headers and body this client iterator is currently on. `headers` and `body` should take the same form as above.
* `client.setRequest(request)`: Used to modify the entire request that this client iterator is currently on. Can have `headers`, `body`, `method`, or `path` as attributes. Defaults to the values passed into the autocannon instance when it was created. `Note: call this when modifying multiple request values for faster encoding`
* `client.setRequests(newRequests)`: Used to overwrite the entire requests array that was passed into the instance on initiation. `Note: call this when modifying multiple requests for faster encoding`

### `Client` events

The events a `Client` can emit are listed here:

* `headers`: Emitted when a request sent from this client has received the headers of its reply. This received an `Object` as the parameter.
* `body`: Emitted when a request sent from this client has received the body of a reply. This receives a `Buffer` as the parameter.
* `response`: Emitted when the client has received a completed response for a request it made. This is passed the following arguments:
    * `statusCode`: The HTTP status code of the response.
    * `resBytes`: The response byte length.
    * `responseTime`: The time taken to get a response after initiating the request.
* `reset`: Emitted when the requests pipeline was reset due to `setupRequest` returning a falsey value.

Example using the autocannon events and the client API and events:

```js
'use strict'

const autocannon = require('autocannon')

const instance = autocannon({
  url: 'http://localhost:3000',
  setupClient: setupClient
}, (err, result) => handleResults(result))
// results passed to the callback are the same as those emitted from the done events
instance.on('done', handleResults)

instance.on('tick', () => console.log('ticking'))

instance.on('response', handleResponse)

function setupClient (client) {
  client.on('body', console.log) // console.log a response body when its received
}

function handleResponse (client, statusCode, resBytes, responseTime) {
  console.log(`Got response with code ${statusCode} in ${responseTime} milliseconds`)
  console.log(`response: ${resBytes.toString()}`)

  //update the body or headers
  client.setHeaders({new: 'header'})
  client.setBody('new body')
  client.setHeadersAndBody({new: 'header'}, 'new body')
}

function handleResults(result) {
  // ...
}
```

<a name="limitations"></a>
## Limitations

Autocannon is written in JavaScript for the Node.js runtime and it is CPU-bound.
We have verified that it yields comparable results with `wrk` when benchmarking Node.js
applications using the `http` module.
Nevertheless, it uses significantly more CPU than other tools that compiles to a binary such as `wrk`.
Autocannon can saturate the CPU, e.g. the autocannon process reaches 100%: in those cases,
we recommend using `wrk2`.

As an example, let's consider a run with 1000 connections on a server
with 4 cores with hyperthreading:

* `wrk` uses 2 threads (by default) and an auxiliary one to collect the
  metrics with a total load of the CPU of 20% + 20% + 40%.
* `autocannon` uses a single thread at 80% CPU load.

Both saturates a Node.js process at around 41k req/sec, however,
`autocannon` can saturate sooner because it is single-threaded.

Note that `wrk` does not support HTTP/1.1 pipelining. As a result, `autocannon` can create
more load on the server than wrk for each open connection.

<a name="acknowledgements"></a>
## Acknowledgements

This project was kindly sponsored by [nearForm](http://nearform.com).

Logo and identity designed by Cosmic Fox Design: https://www.behance.net/cosmicfox.

[wrk][wrk] and [wrk2][wrk2] provided great inspiration.

### Chat on Gitter

If you are using autocannon or you have any questions, let us know: [Gitter](https://gitter.im/mcollina/autocannon)

### Contributors

- [Glen Keane](mailto:glenkeane.94@gmail.com) | [Github](https://github.com/GlenTiki)
- [Salman Mitha](mailto:salmanmitha@gmail.com) | [Github](https://github.com/salmanm) | [NPM](https://www.npmjs.com/~salmanm)

## License

Copyright [Matteo Collina](https://github.com/mcollina) and other contributors, Licensed under [MIT](./LICENSE).

[node-gyp]: https://github.com/nodejs/node-gyp#installation
[wrk]: https://github.com/wg/wrk
[wrk2]: https://github.com/giltene/wrk2


================================================
FILE: autocannon.js
================================================
#! /usr/bin/env node

'use strict'

const crossArgv = require('cross-argv')
const fs = require('fs')
const os = require('os')
const net = require('net')
const path = require('path')
const URL = require('url').URL
const spawn = require('child_process').spawn
const managePath = require('manage-path')
const hasAsyncHooks = require('has-async-hooks')
const subarg = require('@minimistjs/subarg')
const printResult = require('./lib/printResult')
const initJob = require('./lib/init')
const track = require('./lib/progressTracker')
const generateSubArgAliases = require('./lib/subargAliases')
const { checkURL, ofURL } = require('./lib/url')
const { parseHAR } = require('./lib/parseHAR')
const _aggregateResult = require('./lib/aggregateResult')
const validateOpts = require('./lib/validate')

if (typeof URL !== 'function') {
  console.error('autocannon requires the WHATWG URL API, but it is not available. Please upgrade to Node 6.13+.')
  process.exit(1)
}

module.exports = initJob
module.exports.track = track

module.exports.start = start
module.exports.printResult = printResult
module.exports.parseArguments = parseArguments
module.exports.aggregateResult = function aggregateResult (results, opts = {}) {
  if (!Array.isArray(results)) {
    throw new Error('"results" must be an array of results')
  }

  opts = validateOpts(opts, false)

  if (opts instanceof Error) {
    throw opts
  }

  return _aggregateResult(results, opts)
}
const alias = {
  connections: 'c',
  pipelining: 'p',
  timeout: 't',
  duration: 'd',
  sampleInt: 'L',
  amount: 'a',
  json: 'j',
  renderLatencyTable: ['l', 'latency'],
  onPort: 'on-port',
  method: 'm',
  headers: ['H', 'header'],
  body: 'b',
  form: 'F',
  servername: 's',
  bailout: 'B',
  input: 'i',
  maxConnectionRequests: 'M',
  maxOverallRequests: 'O',
  connectionRate: 'r',
  overallRate: 'R',
  ignoreCoordinatedOmission: 'C',
  reconnectRate: 'D',
  renderProgressBar: 'progress',
  renderStatusCodes: 'statusCodes',
  title: 'T',
  verbose: 'V',
  version: 'v',
  forever: 'f',
  idReplacement: 'I',
  socketPath: 'S',
  excludeErrorStats: 'x',
  expectBody: 'E',
  workers: 'w',
  warmup: 'W',
  help: 'h'
}

const defaults = {
  connections: 10,
  timeout: 10,
  pipelining: 1,
  duration: 10,
  sampleInt: 1000,
  reconnectRate: 0,
  renderLatencyTable: false,
  renderProgressBar: true,
  renderStatusCodes: false,
  json: false,
  forever: false,
  method: 'GET',
  idReplacement: false,
  excludeErrorStats: false,
  debug: false,
  workers: 0,
  verbose: true
}

function parseArguments (argvs) {
  let argv = subarg(argvs, {
    boolean: ['json', 'n', 'help', 'renderLatencyTable', 'renderProgressBar', 'renderStatusCodes', 'forever', 'idReplacement', 'excludeErrorStats', 'onPort', 'debug', 'ignoreCoordinatedOmission', 'verbose'],
    alias,
    default: defaults,
    '--': true
  })
  // subarg does not convert aliases in sub arguments
  argv = generateSubArgAliases(argv)

  argv.url = argv._.length > 1 ? argv._ : argv._[0]

  // Assume onPort if `-- node` is provided
  if (argv['--'][0] === 'node') {
    argv.onPort = true
  }

  if (argv.onPort) {
    argv.spawn = argv['--']
  }

  // support -n to disable the progress bar and results table
  if (argv.n) {
    argv.renderProgressBar = false
    argv.renderResultsTable = false
    argv.renderStatusCodes = false
  }

  if (argv.version) {
    console.log('autocannon', 'v' + require('./package').version)
    console.log('node', process.version)
    return
  }

  if (!checkURL(argv.url) || argv.help) {
    const help = fs.readFileSync(path.join(__dirname, 'help.txt'), 'utf8')
    console.error(help)
    return
  }

  // if PORT is set (like by `0x`), target `localhost:PORT/path` by default.
  // this allows doing:
  //     0x --on-port 'autocannon /path' -- node server.js
  if (process.env.PORT) {
    argv.url = ofURL(argv.url).map(url => new URL(url, `http://localhost:${process.env.PORT}`).href)
  }
  // Add http:// if it's not there and this is not a /path
  argv.url = ofURL(argv.url).map(url => {
    if (url.indexOf('http') !== 0 && url[0] !== '/') {
      url = `http://${url}`
    }
    return url
  })

  // check that the URL is valid.
  ofURL(argv.url).map(url => {
    try {
      // If --on-port is given, it's acceptable to not have a hostname
      if (argv.onPort) {
        new URL(url, 'http://localhost') // eslint-disable-line no-new
      } else {
        new URL(url) // eslint-disable-line no-new
      }
    } catch (err) {
      console.error(err.message)
      console.error('')
      console.error('When targeting a path without a hostname, the PORT environment variable must be available.')
      console.error('Use a full URL or set the PORT variable.')
      process.exit(1)
    }

    return null // to make linter happy
  })

  if (argv.input) {
    argv.body = fs.readFileSync(argv.input, 'utf8')
  }

  if (argv.headers) {
    if (!Array.isArray(argv.headers)) {
      argv.headers = [argv.headers]
    }

    argv.headers = argv.headers.reduce((obj, header) => {
      const colonIndex = header.indexOf(':')
      const equalIndex = header.indexOf('=')
      const index = Math.min(colonIndex < 0 ? Infinity : colonIndex, equalIndex < 0 ? Infinity : equalIndex)
      if (Number.isFinite(index) && index > 0) {
        obj[header.slice(0, index)] = header.slice(index + 1)
        return obj
      } else throw new Error(`An HTTP header was not correctly formatted: ${header}`)
    }, {})
  }

  if (argv.har) {
    try {
      argv.har = JSON.parse(fs.readFileSync(argv.har))
      // warn users about skipped HAR requests
      const requestsByOrigin = parseHAR(argv.har)
      const allowed = ofURL(argv.url, true).map(url => new URL(url).origin)
      for (const [origin] of requestsByOrigin) {
        if (!allowed.includes(origin)) {
          console.error(`Warning: skipping requests to '${origin}' as the target is ${allowed.join(', ')}`)
        }
      }
    } catch (err) {
      throw new Error(`Failed to load HAR file content: ${err.message}`)
    }
  }

  argv.tlsOptions = {}

  if (argv.cert) {
    try {
      argv.tlsOptions.cert = fs.readFileSync(argv.cert)
    } catch (err) {
      throw new Error(`Failed to load cert file: ${err.message}`)
    }
  }

  if (argv.key) {
    try {
      argv.tlsOptions.key = fs.readFileSync(argv.key)
    } catch (err) {
      throw new Error(`Failed to load key file: ${err.message}`)
    }
  }

  if (argv.ca) {
    if (typeof argv.ca === 'string') {
      argv.ca = [argv.ca]
    } else if (Array.isArray(argv.ca._)) {
      argv.ca = argv.ca._
    }

    try {
      argv.tlsOptions.ca = argv.ca.map(caPath => fs.readFileSync(caPath))
    } catch (err) {
      throw new Error(`Failed to load ca file: ${err.message}`)
    }
  }

  // This is to distinguish down the line whether it is
  // run via command-line or programmatically
  argv[Symbol.for('internal')] = true

  return argv
}

function start (argv) {
  if (!argv) {
    // we are printing the help
    return
  }

  if (argv.onPort) {
    if (!hasAsyncHooks()) {
      console.error('The --on-port flag requires the async_hooks builtin module, but it is not available. Please upgrade to Node 8.1+.')
      process.exit(1)
    }

    const { socketPath, server } = createChannel((port) => {
      const url = new URL(argv.url, `http://localhost:${port}`).href
      const opts = Object.assign({}, argv, {
        onPort: false,
        url
      })
      const tracker = initJob(opts, () => {
        proc.kill('SIGINT')
        server.close()
      })

      process.once('SIGINT', () => {
        tracker.stop()
      })
    })

    // manage-path always uses the $PATH variable, but we can pretend
    // that it is equal to $NODE_PATH
    const alterPath = managePath({ PATH: process.env.NODE_PATH })
    alterPath.unshift(path.join(__dirname, 'lib/preload'))

    const proc = spawn(argv.spawn[0], argv.spawn.slice(1), {
      stdio: ['ignore', 'inherit', 'inherit'],
      env: Object.assign({}, process.env, {
        NODE_OPTIONS: ['-r', 'autocannonDetectPort'].join(' ') +
          (process.env.NODE_OPTIONS ? ` ${process.env.NODE_OPTIONS}` : ''),
        NODE_PATH: alterPath.get(),
        AUTOCANNON_SOCKET: socketPath
      })
    })
  } else {
    // if forever is true then a promise is not returned and we need to try ... catch errors
    try {
      const tracker = initJob(argv)
      if (tracker.then) {
        tracker.catch((err) => {
          console.error(err.message)
        })
      }
    } catch (err) {
      console.error(err.message)
    }
  }
}

function createChannel (onport) {
  const pipeName = `${process.pid}.autocannon`
  const socketPath = process.platform === 'win32'
    ? `\\\\?\\pipe\\${pipeName}`
    : path.join(os.tmpdir(), pipeName)
  const server = net.createServer((socket) => {
    socket.once('data', (chunk) => {
      const port = chunk.toString()
      onport(port)
    })
  })
  server.listen(socketPath)
  server.on('close', () => {
    try {
      fs.unlinkSync(socketPath)
    } catch (err) {}
  })

  return { socketPath, server }
}

if (require.main === module) {
  const argv = crossArgv(process.argv.slice(2))
  start(parseArguments(argv))
}


================================================
FILE: cluster.js
================================================
'use strict'

const cluster = require('cluster')
const http = require('http')
const numCPUs = Math.floor(require('os').cpus().length / 2) || 1

if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`)

  for (let i = 0; i < numCPUs; i++) {
    cluster.fork()
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`worker ${worker.process.pid} died`)
  })
} else {
  // Workers can share any TCP connection
  // In this case it is an HTTP server
  http.createServer((req, res) => {
    res.writeHead(200)
    res.end('hello world\n')
  }).listen(3000)

  console.log(`Worker ${process.pid} started`)
}


================================================
FILE: for-zero-x.js
================================================
'use strict'

const autocannon = require('.')

autocannon({
  url: 'http://localhost:3000',
  connections: 10,
  duration: 10
}, console.log)


================================================
FILE: help.txt
================================================
Usage: autocannon [opts] URL

URL is any valid HTTP or HTTPS URL.
If the PORT environment variable is set, the URL can be a path. In that case 'http://localhost:$PORT/path' will be used as the URL.

Available options:

  -c/--connections NUM
        The number of concurrent connections to use. default: 10.
  -p/--pipelining NUM
        The number of pipelined requests to use. default: 1.
  -d/--duration SEC
        The number of seconds to run the autocannon. default: 10.
  -a/--amount NUM
        The number of requests to make before exiting the benchmark. If set, duration is ignored.
  -L NUM
        The number of milliseconds to elapse between taking samples. This controls the sample interval, & therefore the total number of samples, which affects statistical analyses. default: 1.
  -S/--socketPath
        A path to a Unix Domain Socket or a Windows Named Pipe. A URL is still required to send the correct Host header and path.
  -w/--workers
        Number of worker threads to use to fire requests.
  -W/--warmup
       Use a warm up interval before starting sampling.
       This enables startup processes to finish and traffic to normalize before sampling begins
       use -c and -d sub args e.g. `--warmup [ -c 1 -d 3 ]`
  --on-port
        Start the command listed after -- on the command line. When it starts listening on a port,
        start sending requests to that port. A URL is still required to send requests to
        the correct path. The hostname can be omitted, `localhost` will be used by default.
  -m/--method METHOD
        The HTTP method to use. default: 'GET'.
  -t/--timeout NUM
        The number of seconds before timing out and resetting a connection. default: 10
  -T/--title TITLE
        The title to place in the results for identification.
  -b/--body BODY
        The body of the request.
        NOTE: This option needs to be used with the '-H/--headers' option in some frameworks
  -F/--form FORM
        Upload a form (multipart/form-data). The form options can be a JSON string like
        '{ "field 1": { "type": "text", "value": "a text value"}, "field 2": { "type": "file", "path": "path to the file" } }'
        or a path to a JSON file containing the form options.
        When uploading a file the default filename value can be overridden by using the corresponding option:
        '{ "field name": { "type": "file", "path": "path to the file", "options": { "filename": "myfilename" } } }'
        Passing the filepath to the form can be done by using the corresponding option:
        '{ "field name": { "type": "file", "path": "path to the file", "options": { "filepath": "/some/path/myfilename" } } }'
  -i/--input FILE
        The body of the request. See '-b/body' for more details.
  -H/--headers K=V
        The request headers.
  --har FILE
        When provided, Autocannon will use requests from the HAR file.
        CAUTION: you have to specify one or more domains using URL option: only the HAR requests to the same domains will be considered.
        NOTE: you can still add extra headers with -H/--headers but -m/--method, -F/--form, -i/--input -b/--body will be ignored.
  -B/--bailout NUM
        The number of failures before initiating a bailout.
  -M/--maxConnectionRequests NUM
        The max number of requests to make per connection to the server.
  -O/--maxOverallRequests NUM
        The max number of requests to make overall to the server.
  -r/--connectionRate NUM
        The max number of requests to make per second from an individual connection.
  -R/--overallRate NUM
        The max number of requests to make per second from all connections.
        connection rate will take precedence if both are set.
        NOTE: if using rate limiting and a very large rate is entered which cannot be met,
              Autocannon will do as many requests as possible per second. Also, latency data will be corrected to compensate for the effects of the coordinated omission issue. If you are not familiar with the coordinated omission issue, you should probably read [this article](http://highscalability.com/blog/2015/10/5/your-load-generator-is-probably-lying-to-you-take-the-red-pi.html) or watch this [Gil Tene's talk](https://www.youtube.com/watch?v=lJ8ydIuPFeU) on the topic.
  -C/--ignoreCoordinatedOmission
        Ignore the coordinated omission issue when requests should be sent at a fixed rate using 'connectionRate' or 'overallRate'.
        NOTE: it is not recommended to enable this option.
              When the request rate cannot be met because the server is too slow, many request latencies might be missing and Autocannon might report a misleading latency distribution.
  -D/--reconnectRate NUM
        The number of requests to make before resetting a connections connection to the
        server.
  -n/--no-progress
        Don't render the progress bar. default: false.
  -l/--latency
        Print all the latency data. default: false.
  -I/--idReplacement
        Enable replacement of [<id>] with a randomly generated ID within the request body. default: false.
  -j/--json
        Print the output as newline delimited JSON. This will cause the progress bar and results not to be rendered. default: false.
  -f/--forever
        Run the benchmark forever. Efficiently restarts the benchmark on completion. default: false.
  -s/--servername
        Server name for the SNI (Server Name Indication) TLS extension. Defaults to the hostname of the URL when it is not an IP address.
  -x/--excludeErrorStats
        Exclude error statistics (non-2xx HTTP responses) from the final latency and bytes per second averages. default: false.
  -E/--expectBody EXPECTED
        Ensure the body matches this value. If enabled, mismatches count towards bailout.
        Enabling this option will slow down the load testing.
  --renderStatusCodes
        Print status codes and their respective statistics.
  --cert
        Path to cert chain in pem format
  --key
        Path to private key for specified cert in pem format
  --ca
        Path to trusted ca certificates for the test. This argument accepts both a single file as well as a list of files
  --debug
        Print connection errors to stderr.
  -v/--version
        Print the version number.
  -h/--help
        Print this menu.


================================================
FILE: lib/aggregateResult.js
================================================
'use strict'

const { decodeHist, getHistograms, histAsObj, addPercentiles } = require('./histUtil')

function aggregateResult (results, opts, histograms) {
  results = Array.isArray(results) ? results : [results]
  histograms = getHistograms(histograms)

  const aggregated = results.map(r => ({
    ...r,
    latencies: decodeHist(r.latencies),
    requests: decodeHist(r.requests),
    throughput: decodeHist(r.throughput)
  })).reduce((acc, r) => {
    acc.latencies.add(r.latencies)

    acc.totalCompletedRequests += r.totalCompletedRequests
    acc.totalRequests += r.totalRequests
    acc.totalBytes += r.totalBytes
    acc.samples += r.samples

    acc.errors += r.errors
    acc.timeouts += r.timeouts
    acc.mismatches += r.mismatches
    acc.non2xx += r.non2xx
    acc.resets += r.resets
    acc['1xx'] += r['1xx']
    acc['2xx'] += r['2xx']
    acc['3xx'] += r['3xx']
    acc['4xx'] += r['4xx']
    acc['5xx'] += r['5xx']

    Object.keys(r.statusCodeStats).forEach(statusCode => {
      if (!acc.statusCodeStats[statusCode]) {
        acc.statusCodeStats[statusCode] = r.statusCodeStats[statusCode]
      } else {
        acc.statusCodeStats[statusCode].count += r.statusCodeStats[statusCode].count
      }
    })

    return acc
  })

  const result = {
    title: opts.title,
    url: opts.url,
    socketPath: opts.socketPath,
    connections: opts.connections,
    sampleInt: opts.sampleInt,
    pipelining: opts.pipelining,
    workers: opts.workers,

    duration: aggregated.duration,
    samples: aggregated.samples,
    start: aggregated.start,
    finish: aggregated.finish,
    errors: aggregated.errors,
    timeouts: aggregated.timeouts,
    mismatches: aggregated.mismatches,
    non2xx: aggregated.non2xx,
    resets: aggregated.resets,
    '1xx': aggregated['1xx'],
    '2xx': aggregated['2xx'],
    '3xx': aggregated['3xx'],
    '4xx': aggregated['4xx'],
    '5xx': aggregated['5xx'],
    statusCodeStats: aggregated.statusCodeStats,

    latency: addPercentiles(aggregated.latencies, histAsObj(aggregated.latencies)),
    requests: addPercentiles(histograms.requests, histAsObj(histograms.requests, aggregated.totalCompletedRequests)),
    throughput: addPercentiles(histograms.throughput, histAsObj(histograms.throughput, aggregated.totalBytes))
  }

  result.latency.totalCount = aggregated.latencies.totalCount
  result.requests.sent = aggregated.totalRequests

  if (result.requests.min >= Number.MAX_SAFE_INTEGER) result.requests.min = 0
  if (result.throughput.min >= Number.MAX_SAFE_INTEGER) result.throughput.min = 0
  if (result.latency.min >= Number.MAX_SAFE_INTEGER) result.latency.min = 0

  return result
}

module.exports = aggregateResult


================================================
FILE: lib/defaultOptions.js
================================================
'use strict'

const defaultOptions = {
  headers: {},
  method: 'GET',
  duration: 10,
  connections: 10,
  sampleInt: 1000,
  pipelining: 1,
  timeout: 10,
  maxConnectionRequests: 0,
  maxOverallRequests: 0,
  connectionRate: 0,
  overallRate: 0,
  amount: 0,
  reconnectRate: 0,
  forever: false,
  idReplacement: false,
  requests: [{}],
  servername: undefined,
  excludeErrorStats: false
}

module.exports = defaultOptions


================================================
FILE: lib/format.js
================================================
'use strict'

function format (num) {
  if (num < 1000) {
    return '' + num
  } else {
    return '' + Math.round(num / 1000) + 'k'
  }
}

module.exports = format


================================================
FILE: lib/histUtil.js
================================================
const hdr = require('hdr-histogram-js')
const histUtil = require('hdr-histogram-percentiles-obj')

hdr.initWebAssemblySync()

const getHistograms = ({
  latencies = hdr.build({
    useWebAssembly: true,
    bitBucketSize: 64,
    autoResize: true,
    lowestDiscernibleValue: 1,
    highestTrackableValue: 10000,
    numberOfSignificantValueDigits: 5
  }),
  requests = hdr.build({
    useWebAssembly: true,
    bitBucketSize: 64,
    autoResize: true,
    lowestDiscernibleValue: 1,
    highestTrackableValue: 1000000,
    numberOfSignificantValueDigits: 3
  }),
  throughput = hdr.build({
    useWebAssembly: true,
    bitBucketSize: 64,
    autoResize: true,
    lowestDiscernibleValue: 1,
    highestTrackableValue: 100000000000,
    numberOfSignificantValueDigits: 3
  })
} = {}) => ({
  latencies,
  requests,
  throughput
})

function encodeHist (h) {
  if (h.__custom) return null

  return hdr.encodeIntoCompressedBase64(h)
}

function decodeHist (str) {
  if (!str) return null

  return hdr.decodeFromCompressedBase64(str)
}

exports.getHistograms = getHistograms
exports.encodeHist = encodeHist
exports.decodeHist = decodeHist
exports.histAsObj = histUtil.histAsObj
exports.addPercentiles = histUtil.addPercentiles
exports.percentiles = histUtil.percentiles


================================================
FILE: lib/httpClient.js
================================================
'use strict'

const inherits = require('util').inherits
const EE = require('events').EventEmitter
const net = require('net')
const tls = require('tls')
const retimer = require('retimer')
const HTTPParser = require('http-parser-js').HTTPParser
const RequestIterator = require('./requestIterator')
const noop = require('./noop')
const clone = require('lodash.clonedeep')
const PipelinedRequestsQueue = require('./pipelinedRequestsQueue')

function Client (opts) {
  if (!(this instanceof Client)) {
    return new Client(opts)
  }

  this.opts = clone(opts)

  this.opts.setupClient = this.opts.setupClient || noop
  this.opts.pipelining = this.opts.pipelining || 1
  this.opts.port = this.opts.port || 80
  this.opts.expectBody = this.opts.expectBody || null
  this.opts.tlsOptions = this.opts.tlsOptions || {}
  this.timeout = (this.opts.timeout || 10) * 1000
  this.ipc = !!this.opts.socketPath
  this.secure = this.opts.protocol === 'https:'
  this.auth = this.opts.auth || null

  if (this.secure && this.opts.port === 80) {
    this.opts.port = 443
  }

  this.parser = new HTTPParser(HTTPParser.RESPONSE)
  this.requestIterator = new RequestIterator(this.opts)

  this.reqsMade = 0

  // used for request limiting
  this.responseMax = this.opts.responseMax

  // used for rate limiting
  this.reqsMadeThisSecond = 0
  this.rate = this.opts.rate

  // used for forcing reconnects
  this.reconnectRate = this.opts.reconnectRate

  this.pipelinedRequests = new PipelinedRequestsQueue()
  this.destroyed = false

  this.opts.setupClient(this)

  const handleTimeout = () => {
    this._destroyConnection()

    this.timeoutTicker.reschedule(this.timeout)

    this._connect()

    for (let i = 0; i < this.opts.pipelining; i++) {
      this.emit('timeout')
    }
  }

  if (this.rate) {
    this.rateInterval = setInterval(() => {
      this.reqsMadeThisSecond = 0
      if (this.paused) this._doRequest(this.cer)
      this.paused = false
    }, 1000)
  }

  this.timeoutTicker = retimer(handleTimeout, this.timeout)
  this.parser[HTTPParser.kOnHeaders] = () => {}
  this.parser[HTTPParser.kOnHeadersComplete] = (opts) => {
    this.emit('headers', opts)
    this.pipelinedRequests.setHeaders(opts)
  }

  this.parser[HTTPParser.kOnBody] = (body, start, len) => {
    this.pipelinedRequests.addBody(body.slice(start, start + len))
    this.emit('body', body)
  }

  this.parser[HTTPParser.kOnMessageComplete] = () => {
    const resp = this.pipelinedRequests.terminateRequest()

    if (!this.destroyed && this.reconnectRate && this.reqsMade % this.reconnectRate === 0) {
      return this._resetConnection()
    }
    if (!this.destroyed) {
      this.requestIterator.recordBody(resp.req, resp.headers.statusCode, resp.body, resp.headers.headers)

      this.emit('response', resp.headers.statusCode, resp.bytes, resp.duration, this.rate)

      this._doRequest()

      const isFn = typeof this.opts.verifyBody === 'function'
      if (isFn && !this.opts.verifyBody(resp.body)) {
        return this.emit('mismatch', resp.body)
      } else if (!isFn && this.opts.expectBody && this.opts.expectBody !== resp.body) {
        return this.emit('mismatch', resp.body)
      }
    }
  }

  this._connect()
}

inherits(Client, EE)

Client.prototype._connect = function () {
  if (this.secure) {
    let servername
    if (this.opts.servername) {
      servername = this.opts.servername
    } else if (!net.isIP(this.opts.hostname)) {
      servername = this.opts.hostname
    }

    if (this.ipc) {
      this.conn = tls.connect(this.opts.socketPath, { ...this.opts.tlsOptions, rejectUnauthorized: false })
    } else {
      this.conn = tls.connect(this.opts.port, this.opts.hostname, { ...this.opts.tlsOptions, rejectUnauthorized: false, servername })
    }
  } else {
    if (this.ipc) {
      this.conn = net.connect(this.opts.socketPath)
    } else {
      this.conn = net.connect(this.opts.port, this.opts.hostname)
    }
  }

  this.conn.on('error', (error) => {
    this.emit('connError', error)
    if (!this.destroyed) this._connect()
  })

  this.conn.on('data', (chunk) => {
    this.pipelinedRequests.addByteCount(chunk.length)
    this.parser.execute(chunk)
  })

  this.conn.on('end', () => {
    if (!this.destroyed) this._connect()
  })

  for (let i = 0; i < this.opts.pipelining; i++) {
    this._doRequest()
  }
}

Client.prototype._doRequest = function () {
  if (!this.rate || (this.rate && this.reqsMadeThisSecond++ < this.rate)) {
    if (!this.destroyed && this.responseMax && this.reqsMade >= this.responseMax) {
      return this.destroy()
    }
    this.emit('request')
    if (this.reqsMade > 0) {
      this.requestIterator.nextRequest()
      if (this.requestIterator.resetted) {
        this.emit('reset')
      }
    }
    this.pipelinedRequests.insertRequest(this.requestIterator.currentRequest)
    this.conn.write(this.getRequestBuffer())
    this.timeoutTicker.reschedule(this.timeout)
    this.reqsMade++
  } else {
    this.paused = true
  }
}

Client.prototype._resetConnection = function () {
  this._destroyConnection()
  this._connect()
}

Client.prototype._destroyConnection = function () {
  this.conn.removeAllListeners('error')
  this.conn.removeAllListeners('end')
  this.conn.on('error', () => {})
  this.conn.destroy()
  this.pipelinedRequests.clear()
}

Client.prototype.destroy = function () {
  if (!this.destroyed) {
    this.destroyed = true
    this.timeoutTicker.clear()
    if (this.rate) clearInterval(this.rateInterval)
    this.emit('done')
    this._destroyConnection()
  }
}

Client.prototype.getRequestBuffer = function () {
  return this.requestIterator.currentRequest.requestBuffer
}

Client.prototype.setHeaders = function (newHeaders) {
  this._okayToUpdateCheck()
  this.requestIterator.setHeaders(newHeaders)
}

Client.prototype.setBody = function (newBody) {
  this._okayToUpdateCheck()
  this.requestIterator.setBody(newBody)
}

Client.prototype.setHeadersAndBody = function (newHeaders, newBody) {
  this._okayToUpdateCheck()
  this.requestIterator.setHeadersAndBody(newHeaders, newBody)
}

Client.prototype.setRequest = function (newRequest) {
  this._okayToUpdateCheck()
  this.requestIterator.setRequest(newRequest)
}

Client.prototype.setRequests = function (newRequests) {
  this._okayToUpdateCheck()
  this.requestIterator.setRequests(newRequests)
}

Client.prototype._okayToUpdateCheck = function () {
  if (this.opts.pipelining > 1) {
    throw new Error('cannot update requests when the piplining factor is greater than 1')
  }
}

module.exports = Client


================================================
FILE: lib/httpMethods.js
================================================
// most http methods taken from RFC 7231
// PATCH is defined in RFC 5789
module.exports = [
  'GET',
  'HEAD',
  'POST',
  'PUT',
  'DELETE',
  'CONNECT',
  'OPTIONS',
  'TRACE',
  'PATCH'
]


================================================
FILE: lib/httpRequestBuilder.js
================================================
'use strict'

const methods = require('./httpMethods')
const { getPropertyCaseInsensitive } = require('./util')

// this is a build request factory, that curries the build request function
// and sets the default for it
function requestBuilder (defaults) {
  // these need to be defined per request builder creation, because of the way
  // headers don't get deep copied
  const builderDefaults = {
    method: 'GET',
    path: '/',
    headers: {},
    body: Buffer.alloc(0),
    hostname: 'localhost',
    setupRequest: reqData => reqData,
    port: 80
  }

  defaults = Object.assign(builderDefaults, defaults)

  // buildRequest takes an object, and turns it into a buffer representing the
  // http request.
  // second parameter is passed to setupRequest, when relevant
  // will return null if setupRequest returns falsey result
  return function buildRequest (reqData, context) {
    // below is a hack to enable deep extending of the headers so the default
    // headers object isn't overwritten by accident
    reqData = reqData || {}
    reqData.headers = Object.assign({}, defaults.headers, reqData.headers)

    reqData = Object.assign({}, defaults, reqData)

    reqData = reqData.setupRequest(reqData, context)
    if (!reqData) {
      return null
    }

    // for some reason some tests fail with method === undefined
    // the reqData.method should be set to SOMETHING in this case
    // cannot find reason for failure if `|| 'GET'` is taken out
    const method = reqData.method
    const path = reqData.path
    const headers = reqData.headers
    const body = reqData.body

    const headersDefinedHost = getPropertyCaseInsensitive(reqData.headers, 'host')
    let host = headersDefinedHost || reqData.host

    if (!host) {
      const hostname = reqData.hostname
      const port = reqData.port
      host = hostname + ':' + port
    }
    const baseReq = [
      `${method} ${path} HTTP/1.1`
    ]
    if (!headersDefinedHost) {
      baseReq.push(`Host: ${host}`)
    }
    baseReq.push('Connection: keep-alive')
    if (reqData.auth) {
      const encodedAuth = Buffer.from(reqData.auth).toString('base64')
      headers.Authorization = `Basic ${encodedAuth}`
    }

    if (methods.indexOf(method) < 0) {
      throw new Error(`${method} HTTP method is not supported`)
    }

    let bodyBuf

    if (typeof body === 'string') {
      bodyBuf = Buffer.from(body)
    } else if (typeof body === 'number') {
      bodyBuf = Buffer.from(body + '')
    } else if (Buffer.isBuffer(body)) {
      bodyBuf = body
    } else if (body && Array.isArray(body._)) {
      // when the request body passed on the CLI includes brackets like for
      // a JSON array, the subarg parser will oddly provide the contents as
      // `body._`. Work around this specific issue.
      bodyBuf = Buffer.from(`[${body._}]`)
    } else if (body) {
      throw new Error('body must be either a string or a buffer')
    }

    if (bodyBuf && bodyBuf.length > 0) {
      const idCount = reqData.idReplacement
        ? (bodyBuf.toString().match(/\[<id>\]/g) || []).length
        : 0
      headers['Content-Length'] = `${bodyBuf.length + (idCount * 27)}`
    }

    for (const [key, header] of Object.entries(headers)) {
      baseReq.push(`${key}: ${header}`)
    }

    let req = Buffer.from(baseReq.join('\r\n') + '\r\n\r\n', 'utf8')

    if (bodyBuf && bodyBuf.length > 0) {
      req = Buffer.concat([req, bodyBuf])
    }

    return req
  }
}

module.exports = requestBuilder


================================================
FILE: lib/init.js
================================================
'use strict'

const EE = require('events').EventEmitter
const { isMainThread } = require('./worker_threads')

const initWorkers = require('./manager')
const validateOpts = require('./validate')
const noop = require('./noop')
const runTracker = require('./runTracker')
const track = require('./progressTracker')

function init (opts, cb) {
  const cbPassedIn = (typeof cb === 'function')
  if (!cbPassedIn && !opts.forever) {
    if (opts.warmup) {
      return runWithWarmup(opts)
    } else {
      return run(opts)
    }
  } else {
    return _init(opts, null, cb)
  }
}

function run (opts) {
  const tracker = new EE()
  const promise = new Promise((resolve, reject) => {
    _init(opts, tracker, (err, results) => {
      if (err) return reject(err)
      resolve(results)
    })
  })
  tracker.then = promise.then.bind(promise)
  tracker.catch = promise.catch.bind(promise)

  return tracker
}

function runWithWarmup (opts) {
  const warmupOpts = {
    ...opts,
    ...opts.warmup,
    warmupRunning: true,
    renderResultsTable: false
  }
  const mainTracker = new EE()
  const warmUpTracker = new EE()
  const promise = new Promise((resolve, reject) => {
    _init(warmupOpts, warmUpTracker, (err, warmupResults) => {
      if (err) return reject(err)
      _init(opts, mainTracker, (err, results) => {
        if (err) return reject(err)
        results.warmup = warmupResults
        resolve(results)
      })
    })
  })
  mainTracker.then = promise.then.bind(promise)
  mainTracker.catch = promise.catch.bind(promise)
  return mainTracker
}

function _init (opts, tracker, cb) {
  const cbPassedIn = (typeof cb === 'function')
  cb = cb || noop

  tracker = tracker || new EE()

  opts = validateOpts(opts, cbPassedIn)

  function _cb (err, result) {
    if (err) {
      return cbPassedIn ? cb(err) : setImmediate(() => tracker.emit('error', err))
    }

    tracker.emit('done', result)
    cb(null, result)

    if (!err && opts.json) {
      console.log(JSON.stringify(result))
    }
  }

  if (opts instanceof Error) {
    _cb(opts)
    return tracker
  }

  tracker.opts = opts

  if (opts.workers && isMainThread) {
    initWorkers(opts, tracker, _cb)
  } else {
    runTracker(opts, tracker, _cb)
  }

  // if not running via command-line and
  // not rendering json, or if std isn't a tty, track progress
  if (opts[Symbol.for('internal')] && (!opts.json || !process.stdout.isTTY)) track(tracker, opts)

  return tracker
}

module.exports = init


================================================
FILE: lib/manager.js
================================================
'use strict'

const path = require('path')
const EE = require('events').EventEmitter
const aggregateResult = require('./aggregateResult')
const { getHistograms } = require('./histUtil')
const { Worker } = require('./worker_threads')

function initWorkers (opts, tracker, cb) {
  tracker = tracker || new EE()

  const workers = []
  const results = []
  const numWorkers = +opts.workers
  const histograms = getHistograms()
  const histData = {
    requests: [],
    throughput: []
  }
  let restart = true

  function reset () {
    workers.length = 0
    results.length = 0
    histograms.requests.reset()
    histograms.throughput.reset()
    histData.requests.length = 0
    histData.throughput.length = 0
  }

  function startAll () {
    for (const w of workers) {
      w.postMessage({ cmd: 'START' })
    }

    setImmediate(() => { tracker.emit('start') })
  }

  function handleFinish () {
    const result = aggregateResult(results, opts, histograms)
    cb(null, result)
    reset()

    if (opts.forever && restart) {
      setImmediate(() => {
        init()
        startAll()
      })
    }
  }

  function stopAll () {
    for (const w of workers) {
      w.postMessage({ cmd: 'STOP' })
    }
    reset()
  }

  const workerOpts = {
    ...opts,
    ...(opts.amount ? { amount: Math.max(Math.floor(opts.amount / numWorkers), 1) } : undefined),
    ...(opts.connections ? { connections: Math.max(Math.floor(opts.connections / numWorkers), 1) } : undefined)
  }
  workerOpts.a = workerOpts.amount
  workerOpts.c = workerOpts.connections

  function init () {
    for (let i = 0; i < numWorkers; i++) {
      const worker = new Worker(path.resolve(__dirname, './worker.js'), { workerData: { opts: workerOpts } })

      worker.on('message', (msg) => {
        const { cmd, data, error } = msg

        if (cmd === 'RESULT') {
          results.push(data)

          if (results.length === workers.length) {
            handleFinish()
          }
        } else if (cmd === 'UPDATE_HIST') {
          const { name, value } = data
          histData[name].push(value)

          if (histData[name].length === workers.length) {
            const total = histData[name].reduce((acc, v) => acc + v, 0)
            histData[name].length = 0
            histograms[name].recordValue(total)
          }
        } else if (cmd === 'RESET_HIST') {
          const { name } = data
          histograms[name].reset()
        } else if (cmd === 'ERROR') {
          tracker.emit('error', error)
        }
      })

      worker.on('error', (err) => {
        console.log('Worker error:', err)
        stopAll()
        cb(err)
      })

      workers.push(worker)
    }
  }

  init()
  startAll()

  tracker.stop = () => {
    restart = false
    stopAll()
  }

  return tracker
}

module.exports = initWorkers


================================================
FILE: lib/multipart.js
================================================
'use strict'

const { resolve, basename } = require('path')
const { readFileSync } = require('fs')
const FormData = require('form-data')

function getFormData (string) {
  try {
    return JSON.parse(string)
  } catch (error) {
    try {
      const path = resolve(string)
      const data = readFileSync(path, 'utf8')
      return JSON.parse(data)
    } catch (error) {
      throw new Error('Invalid JSON or file where to get form data')
    }
  }
}

module.exports = (options) => {
  const obj = typeof options === 'string' ? getFormData(options) : options
  const form = new FormData()
  for (const key in obj) {
    const type = obj[key] && obj[key].type
    switch (type) {
      case 'file': {
        const path = obj[key] && obj[key].path
        if (!path) {
          throw new Error(`Missing key 'path' in form object for key '${key}'`)
        }
        const opts = obj[key] && obj[key].options
        const buffer = readFileSync(path)
        form.append(key, buffer, Object.assign({}, {
          filename: basename(path)
        }, opts))
        break
      }
      case 'text': {
        const value = obj[key] && obj[key].value
        if (!value) {
          throw new Error(`Missing key 'value' in form object for key '${key}'`)
        }
        form.append(key, value)
        break
      }
      default:
        throw new Error('A \'type\' key with value \'text\' or \'file\' should be specified')
    }
  }
  return form
}


================================================
FILE: lib/noop.js
================================================
/* istanbul ignore next */
module.exports = function noop () {}


================================================
FILE: lib/parseHAR.js
================================================
'use strict'

// given we support node v8
// eslint-disable-next-line n/no-deprecated-api
const { parse } = require('url')

function parseHAR (har) {
  const requestsPerOrigin = new Map()
  try {
    if (!har || typeof har !== 'object' || typeof har.log !== 'object' || !Array.isArray(har.log.entries) || !har.log.entries.length) {
      throw new Error('no entries found')
    }
    let i = 0
    for (const entry of har.log.entries) {
      i++
      if (!entry || typeof entry !== 'object' || !entry.request || typeof entry.request !== 'object') {
        throw new Error(`invalid request in entry #${i}`)
      }
      const { request: { method, url, headers: headerArray, postData } } = entry
      // turn headers array to headers object
      const headers = {}
      if (!Array.isArray(headerArray)) {
        throw new Error(`invalid headers array in entry #${i}`)
      }
      let j = 0
      for (const header of headerArray) {
        j++
        if (!header || typeof header !== 'object' || typeof header.name !== 'string' || typeof header.value !== 'string') {
          throw new Error(`invalid name or value in header #${j} of entry #${i}`)
        }
        const { name, value } = header
        headers[name] = value
      }
      const { path, hash, host, protocol } = parse(url)
      const origin = `${protocol}//${host}`

      let requests = requestsPerOrigin.get(origin)
      if (!requests) {
        requests = []
        requestsPerOrigin.set(origin, requests)
      }
      const request = {
        origin,
        method,
        // only keep path & hash as our HttpClient will handle origin
        path: `${path}${hash || ''}`,
        headers
      }
      if (typeof postData === 'object' && typeof postData.text === 'string') {
        request.body = postData.text
      }
      requests.push(request)
    }
  } catch (err) {
    throw new Error(`Could not parse HAR content: ${err.message}`)
  }
  return requestsPerOrigin
}

exports.parseHAR = parseHAR


================================================
FILE: lib/pipelinedRequestsQueue.js
================================================
'use strict'

/**
 * A queue (FIFO) to hold pipelined requests and link metadata to them as the response is received from the server.
 * This facilitates the handling of responses when the HTTP requests are pipelined.
 * A queue is the best structure for this because the sever reponses are provided in the same order as the requests
 * Cf. https://en.wikipedia.org/wiki/HTTP_pipelining
 *
 * /!\ it's up to you as a user to ensure that the queue is populated if using
 * the functionality. This implementation will fail silently if e.g. you try to
 * call any function accessing the queue while it's empty.
 */
class PipelinedRequestsQueue {
  constructor () {
    this.pendingRequests = []
  }

  insertRequest (req) {
    this.pendingRequests.push({
      req,
      bytes: 0,
      body: '',
      headers: {},
      startTime: process.hrtime()
    })
  }

  peek () {
    if (this.pendingRequests.length > 0) {
      return this.pendingRequests[0]
    }
  }

  addByteCount (count) {
    const req = this.peek()
    if (req) {
      req.bytes += count
    }
  }

  addBody (data) {
    const req = this.peek()
    if (req) {
      req.body += data
    }
  }

  setHeaders (headers) {
    const req = this.peek()
    if (req) {
      req.headers = headers
    }
  }

  size () {
    return this.pendingRequests.length
  }

  /** Terminates the first-in request
   * This will calculate the request duration, remove it from the queue and return its data
   **/
  terminateRequest () {
    if (this.pendingRequests.length > 0) {
      const data = this.pendingRequests.shift()
      const hrduration = process.hrtime(data.startTime)
      data.duration = hrduration[0] * 1e3 + hrduration[1] / 1e6
      return data
    }
  }

  clear () {
    this.pendingRequests = []
  }

  toArray () {
    return this.pendingRequests
  }
}

module.exports = PipelinedRequestsQueue


================================================
FILE: lib/preload/autocannonDetectPort.js
================================================
'use strict'

const onListen = require('on-net-listen')
const net = require('net')

const socket = net.connect(process.env.AUTOCANNON_SOCKET)

onListen(function (addr) {
  this.destroy()
  const port = Buffer.from(addr.port + '')
  socket.write(port)
})

socket.unref()


================================================
FILE: lib/printResult.js
================================================
'use strict'

const Table = require('cli-table3')
const Chalk = require('chalk')
const testColorSupport = require('color-support')
const prettyBytes = require('pretty-bytes')
const { percentiles } = require('./histUtil')
const format = require('./format')

const defaults = {
  // use stderr as its progressBar's default
  outputStream: process.stderr,
  renderResultsTable: true,
  renderLatencyTable: false,
  verbose: true
}

class TableWithoutColor extends Table {
  constructor (opts = {}) {
    super({ ...opts, style: { head: [], border: [] } })
  }
}

const printResult = (result, opts) => {
  opts = Object.assign({}, defaults, opts)
  let strResult = ''

  if (opts.verbose) {
    const chalk = new Chalk.Instance(testColorSupport({ stream: opts.outputStream, alwaysReturn: true }))
    const ColorSafeTable = chalk.level === 0 ? TableWithoutColor : Table

    const shortLatency = new ColorSafeTable({
      head: asColor(chalk.cyan, ['Stat', '2.5%', '50%', '97.5%', '99%', 'Avg', 'Stdev', 'Max'])
    })
    shortLatency.push(asLowRow(chalk.bold('Latency'), asMs(result.latency)))
    logToLocalStr('\n' + shortLatency.toString())

    const requests = new ColorSafeTable({
      head: asColor(chalk.cyan, ['Stat', '1%', '2.5%', '50%', '97.5%', 'Avg', 'Stdev', 'Min'])
    })

    requests.push(asHighRow(chalk.bold('Req/Sec'), asNumber(result.requests)))
    requests.push(asHighRow(chalk.bold('Bytes/Sec'), asBytes(result.throughput)))
    logToLocalStr(requests.toString())

    if (opts.renderStatusCodes === true) {
      const statusCodeStats = new ColorSafeTable({
        head: asColor(chalk.cyan, ['Code', 'Count'])
      })
      Object.keys(result.statusCodeStats).forEach(statusCode => {
        const stats = result.statusCodeStats[statusCode]
        const colorize = colorizeByStatusCode(chalk, statusCode)
        statusCodeStats.push([colorize(statusCode), stats.count])
      })
      logToLocalStr(statusCodeStats.toString())
    }
    logToLocalStr('')
    if (result.sampleInt === 1000) {
      logToLocalStr('Req/Bytes counts sampled once per second.')
    } else {
      logToLocalStr('Req/Bytes counts sampled every ' + result.sampleInt / 1000 + ' seconds.')
    }
    logToLocalStr('# of samples: ' + result.samples)
    logToLocalStr('')

    if (opts.renderLatencyTable) {
      const latencies = new ColorSafeTable({
        head: asColor(chalk.cyan, ['Percentile', 'Latency (ms)'])
      })
      percentiles.map((perc) => {
        const key = `p${perc}`.replace('.', '_')
        return [
          chalk.bold('' + perc),
          result.latency[key]
        ]
      }).forEach(row => {
        latencies.push(row)
      })
      logToLocalStr(latencies.toString())
      logToLocalStr('')
    }
  }

  if (result.non2xx) {
    logToLocalStr(`${result['2xx']} 2xx responses, ${result.non2xx} non 2xx responses`)
  }
  logToLocalStr(`${format(result.requests.sent)} requests in ${result.duration}s, ${prettyBytes(result.throughput.total)} read`)
  if (result.errors) {
    logToLocalStr(`${format(result.errors)} errors (${format(result.timeouts)} timeouts)`)
  }
  if (result.mismatches) {
    logToLocalStr(`${format(result.mismatches)} requests with mismatched body`)
  }
  if (result.resets) {
    logToLocalStr(`request pipeline was reset ${format(result.resets)} ${result.resets === 1 ? 'time' : 'times'}`)
  }

  function logToLocalStr (msg) {
    strResult += msg + '\n'
  }

  return strResult
}

// create a table row for stats where low values is better
function asLowRow (name, stat) {
  return [
    name,
    stat.p2_5,
    stat.p50,
    stat.p97_5,
    stat.p99,
    stat.average,
    stat.stddev,
    typeof stat.max === 'string' ? stat.max : Math.floor(stat.max * 100) / 100
  ]
}

// create a table row for stats where high values is better
function asHighRow (name, stat) {
  return [
    name,
    stat.p1,
    stat.p2_5,
    stat.p50,
    stat.p97_5,
    stat.average,
    stat.stddev,
    typeof stat.min === 'string' ? stat.min : Math.floor(stat.min * 100) / 100
  ]
}

function asColor (colorise, row) {
  return row.map((entry) => colorise(entry))
}

function asMs (stat) {
  const result = Object.create(null)
  for (const k of Object.keys(stat)) {
    result[k] = `${stat[k]} ms`
  }
  result.max = typeof stat.max === 'string' ? stat.max : `${Math.floor(stat.max * 100) / 100} ms`

  return result
}

function asNumber (stat) {
  const result = Object.create(null)
  for (const k of Object.keys(stat)) {
    result[k] = stat[k].toLocaleString(undefined, {
      // to show all digits
      maximumFractionDigits: 20
    })
  }

  return result
}

function asBytes (stat) {
  const result = Object.create(stat)

  for (const p of percentiles) {
    const key = `p${p}`.replace('.', '_')
    result[key] = prettyBytes(stat[key])
  }

  result.average = prettyBytes(stat.average)
  result.stddev = prettyBytes(stat.stddev)
  result.max = prettyBytes(stat.max)
  result.min = prettyBytes(stat.min)
  return result
}

function colorizeByStatusCode (chalk, statusCode) {
  const codeClass = Math.floor(parseInt(statusCode) / 100) - 1
  return [chalk.cyan, chalk.cyan, chalk.cyan, chalk.redBright, chalk.redBright][codeClass]
}

module.exports = printResult


================================================
FILE: lib/progressTracker.js
================================================
/**
 * Prints out the test result details. It doesn't have not much business logic.
 * We skip test coverage for this file
 */
/* istanbul ignore file */
'use strict'

const ProgressBar = require('progress')
const Chalk = require('chalk')
const testColorSupport = require('color-support')
const charSpinner = require('char-spinner')
const printResult = require('./printResult')
const { isMainThread } = require('./worker_threads')
const defaults = {
  // use stderr as its progressBar's default
  outputStream: process.stderr,
  renderProgressBar: true,
  renderResultsTable: true,
  renderLatencyTable: false
}

function track (instance, opts) {
  if (!instance) {
    throw new Error('instance required for tracking')
  }

  opts = Object.assign({}, defaults, opts)

  const chalk = new Chalk.Instance(testColorSupport({ stream: opts.outputStream, alwaysReturn: true }))
  // this default needs to be set after chalk is setup, because chalk is now local to this func
  const runningDescription = opts.warmupRunning ? 'warmup' : 'running'
  opts.progressBarString = opts.progressBarString || `${chalk.green(runningDescription)} [:bar] :percent`

  const iOpts = instance.opts
  let durationProgressBar
  let amountProgressBar
  let addedListeners = false
  let spinner

  instance.on('start', () => {
    if (opts.renderProgressBar && isMainThread) {
      const socketPath = iOpts.socketPath ? ` (${iOpts.socketPath})` : ''
      let msg = `${iOpts.connections} connections`

      if (iOpts.pipelining > 1) {
        msg += ` with ${iOpts.pipelining} pipelining factor`
      }

      if (iOpts.workers) {
        msg += `\n${iOpts.workers} workers`
      }

      const runningType = opts.warmupRunning ? 'warmup' : 'test'
      const message = iOpts.amount
        ? `Running ${iOpts.amount} requests ${runningType} @ ${iOpts.url}${socketPath}\n${msg}\n`
        : `Running ${iOpts.duration}s ${runningType} @ ${iOpts.url}${socketPath}\n${msg}\n`

      logToStream(message)

      if (iOpts.workers) {
        showSpinner()
      } else {
        if (iOpts.amount) {
          amountProgressBar = trackAmount(instance, opts, iOpts)
        } else {
          durationProgressBar = trackDuration(instance, opts, iOpts)
        }
      }

      addListener()
    }
  })

  instance.on('done', (result) => {
    // the code below this `if` just renders the results table...
    // if the user doesn't want to render the table, we can just return early
    if (opts.renderResultsTable === false) return

    const tableStrResult = printResult(result, opts)
    opts.outputStream.write(tableStrResult)
  })

  function showSpinner () {
    spinner = charSpinner()
  }

  function hideSpinner () {
    if (spinner) {
      clearInterval(spinner)
      spinner = null
    }
  }

  function addListener () {
    // add listeners for progress bar to instance here so they aren't
    // added on restarting, causing listener leaks
    if (addedListeners) {
      return
    }

    addedListeners = true

    // TODO: think about if workers can report progress every second, that
    // way we could have a progress bar per worker.
    if (iOpts.workers) {
      // using `prependOnceListener` to make sure that we hide the spinner
      // before writing anything else.
      // if we print anything else to the output, the stale spinner text
      // is left uncleared and clutters the output.
      instance.prependOnceListener('done', hideSpinner)
      return
    }

    // note: Attempted to curry the functions below, but that breaks the functionality
    // as they use the scope/closure of the progress bar variables to allow them to be reset
    if (opts.outputStream.isTTY) {
      if (!iOpts.amount) { // duration progress bar
        instance.on('tick', () => { durationProgressBar.tick() })
        instance.on('done', () => { durationProgressBar.tick(iOpts.duration - 1) })
        process.once('SIGINT', () => { durationProgressBar.tick(iOpts.duration - 1) })
      } else { // amount progress bar
        instance.on('response', () => { amountProgressBar.tick() })
        instance.on('reqError', () => { amountProgressBar.tick() })
        instance.on('done', () => { amountProgressBar.tick(iOpts.amount - 1) })
        process.once('SIGINT', () => { amountProgressBar.tick(iOpts.amount - 1) })
      }
    }
  }

  function logToStream (msg) {
    if (!isMainThread) return

    opts.outputStream.write(msg + '\n')
  }
}

function trackDuration (instance, opts, iOpts) {
  // if switch needed needed to avoid
  // https://github.com/mcollina/autocannon/issues/60
  if (!opts.outputStream.isTTY) return

  const progressBar = new ProgressBar(opts.progressBarString, {
    width: 20,
    incomplete: ' ',
    total: iOpts.duration,
    clear: true,
    stream: opts.outputStream
  })

  progressBar.tick(0)
  return progressBar
}

function trackAmount (instance, opts, iOpts) {
  // if switch needed needed to avoid
  // https://github.com/mcollina/autocannon/issues/60
  if (!opts.outputStream.isTTY) return

  const progressBar = new ProgressBar(opts.progressBarString, {
    width: 20,
    incomplete: ' ',
    total: iOpts.amount,
    clear: true,
    stream: opts.outputStream
  })

  progressBar.tick(0)
  return progressBar
}

module.exports = track


================================================
FILE: lib/requestIterator.js
================================================
'use strict'

const hyperid = require('hyperid')
const inherits = require('util').inherits
const requestBuilder = require('./httpRequestBuilder')
const clone = require('lodash.clonedeep')
const chunk = require('lodash.chunk')
const flatten = require('lodash.flatten')

const toHeaderKeyValue = (rawHeaders) => {
  const tupleHeaders = chunk(rawHeaders, 2)
  const headers = {}
  tupleHeaders.forEach((val) => {
    const currentValue = headers[val[0]]
    if (!currentValue) {
      headers[val[0]] = val[1]
    } else {
      headers[val[0]] = flatten([currentValue, val[1]])
    }
  })
  return headers
}

function RequestIterator (opts) {
  if (!(this instanceof RequestIterator)) {
    return new RequestIterator(opts)
  }

  this.hyperid = hyperid({ urlSafe: true })
  this.resetted = false
  this.headers = {}
  this.initialContext = opts.initialContext || {}
  this.resetContext()
  this.reqDefaults = opts
  this.requestBuilder = requestBuilder(opts)
  this.setRequests(opts.requests)
}

inherits(RequestIterator, Object)

RequestIterator.prototype.resetContext = function () {
  this.context = clone(this.initialContext)
}

RequestIterator.prototype.nextRequest = function () {
  this.resetted = false
  ++this.currentRequestIndex
  // when looping over available request, clear context for a fresh start
  if (this.currentRequestIndex === this.requests.length) {
    this.resetContext()
    this.currentRequestIndex = 0
  }
  this.currentRequest = this.requests[this.currentRequestIndex]
  // only builds if it has dynamic setup
  if (this.reqDefaults.idReplacement || typeof this.currentRequest.setupRequest === 'function') {
    this.rebuildRequest()
  }
  return this.currentRequest
}

RequestIterator.prototype.nextRequestBuffer = function () {
  // get next request
  this.nextRequest()
  return this.currentRequest.requestBuffer
}

RequestIterator.prototype.setRequests = function (newRequests) {
  this.resetted = false
  this.requests = newRequests || [{}]
  this.currentRequestIndex = 0
  // build all request which don't have dynamic setup, except if it's the first one
  this.requests.forEach((request, i) => {
    this.currentRequest = request
    if (i === 0 || typeof request.setupRequest !== 'function') {
      this.rebuildRequest()
    }
  })
  this.currentRequest = this.requests[0]
}

RequestIterator.prototype.setHeaders = function (newHeaders) {
  this.headers = newHeaders || {}
  this.currentRequest.headers = this.headers
  this.rebuildRequest()
}

RequestIterator.prototype.setBody = function (newBody) {
  this.currentRequest.body = newBody || Buffer.alloc(0)
  this.rebuildRequest()
}

RequestIterator.prototype.setHeadersAndBody = function (newHeaders, newBody) {
  this.headers = newHeaders || {}
  this.currentRequest.headers = this.headers
  this.currentRequest.body = newBody || Buffer.alloc(0)
  this.rebuildRequest()
}

RequestIterator.prototype.setRequest = function (newRequest) {
  this.currentRequest = newRequest || {}
  this.rebuildRequest()
}

RequestIterator.prototype.rebuildRequest = function () {
  let data
  this.resetted = false
  if (this.currentRequest) {
    this.currentRequest.headers = this.currentRequest.headers || this.headers
    data = this.requestBuilder(this.currentRequest, this.context)
    if (data) {
      const hyperid = this.hyperid()
      this.currentRequest.requestBuffer = this.reqDefaults.idReplacement
        ? Buffer.from(data.toString()
          .replace(/\[<id>\]/g, hyperid)
          // in the first line only (the url), replace encoded id placeholders
          .replace(/^.+/, m => m.replace(/\[%3Cid%3E]/g, hyperid)))
        : data
    } else if (this.currentRequestIndex === 0) {
      // when first request fails to build, we can not reset pipeline, or it'll never end
      throw new Error('First setupRequest() failed did not returned valid request. Stopping')
    } else {
      this.currentRequestIndex = this.requests.length - 1
      this.nextRequest()
      this.resetted = true
    }
  }
  return data
}

RequestIterator.prototype.recordBody = function (request, status, body, headers) {
  if (request && typeof request.onResponse === 'function') {
    request.onResponse(status, body, this.context, toHeaderKeyValue(headers || []))
  }
}

module.exports = RequestIterator


================================================
FILE: lib/run.js
================================================
'use strict'

const URL = require('url')
const reInterval = require('reinterval')
const EE = require('events').EventEmitter
const Client = require('./httpClient')
const { isMainThread } = require('./worker_threads')
const { ofURL } = require('./url')
const aggregateResult = require('./aggregateResult')
const { getHistograms, encodeHist } = require('./histUtil')

const defaults = {
  harRequests: new Map()
}

function run (opts, tracker, cb) {
  opts = Object.assign({}, defaults, opts)
  tracker = tracker || new EE()

  const histograms = getHistograms(opts.histograms)
  const { latencies, requests, throughput } = histograms

  const statusCodes = [
    0, // 1xx
    0, // 2xx
    0, // 3xx
    0, // 4xx
    0 // 5xx
  ]

  const statusCodeStats = {}

  if (opts.overallRate && (opts.overallRate < opts.connections)) opts.connections = opts.overallRate

  let counter = 0
  let bytes = 0
  let errors = 0
  let timeouts = 0
  let mismatches = 0
  let totalBytes = 0
  let totalRequests = 0
  let totalCompletedRequests = 0
  let samples = 0
  let resets = 0
  const amount = opts.amount
  let stop = false
  let restart = true
  let numRunning = opts.connections
  let startTime = Date.now()
  const includeErrorStats = !opts.excludeErrorStats

  opts.url = ofURL(opts.url).map((url) => {
    if (url.indexOf('http') !== 0) return 'http://' + url
    return url
  })

  const urls = ofURL(opts.url, true).map(url => {
    if (url.indexOf('http') !== 0) url = 'http://' + url
    url = URL.parse(url) // eslint-disable-line n/no-deprecated-api

    // copy over fields so that the client
    // performs the right HTTP requests
    url.pipelining = opts.pipelining
    url.method = opts.method
    url.body = opts.form ? opts.form.getBuffer() : opts.body
    url.headers = opts.form ? Object.assign({}, opts.headers, opts.form.getHeaders()) : opts.headers
    url.setupClient = opts.setupClient
    url.verifyBody = opts.verifyBody
    url.timeout = opts.timeout
    url.origin = `${url.protocol}//${url.host}`
    // only keep requests for that origin, or default to requests from options
    url.requests = opts.harRequests.get(url.origin) || opts.requests
    url.reconnectRate = opts.reconnectRate
    url.responseMax = amount || opts.maxConnectionRequests || opts.maxOverallRequests
    url.rate = opts.connectionRate || opts.overallRate
    url.idReplacement = opts.idReplacement
    url.socketPath = opts.socketPath
    url.servername = opts.servername
    url.expectBody = opts.expectBody

    return url
  })

  let stopTimer
  let clients = []
  initialiseClients(clients)

  if (!amount) {
    stopTimer = setTimeout(() => {
      stop = true
    }, opts.duration * 1000)
  }

  const second = reInterval(tickProgressBar, 1000)
  const interval = reInterval(tickInterval, opts.sampleInt)

  // put the start emit in a setImmediate so trackers can be added, etc.
  setImmediate(() => { tracker.emit('start') })

  function tickProgressBar () {
    tracker.emit('tick', { counter, bytes })
  }

  function tickInterval () {
    totalBytes += bytes
    totalCompletedRequests += counter
    samples += 1
    requests.recordValue(counter)
    throughput.recordValue(bytes)
    counter = 0
    bytes = 0

    if (stop) {
      if (stopTimer) clearTimeout(stopTimer)
      tracker.emit('tick', { counter, bytes })
      second.clear()
      interval.clear()
      clients.forEach((client) => client.destroy())
      const result = {
        latencies: encodeHist(latencies),
        requests: encodeHist(requests),
        throughput: encodeHist(throughput),
        totalCompletedRequests,
        totalRequests,
        totalBytes,
        samples,
        errors,
        timeouts,
        mismatches,
        non2xx: statusCodes[0] + statusCodes[2] + statusCodes[3] + statusCodes[4],
        statusCodeStats,
        resets,
        duration: Math.round((Date.now() - startTime) / 10) / 100,
        start: new Date(startTime),
        finish: new Date()
      }

      statusCodes.forEach((code, index) => { result[(index + 1) + 'xx'] = code })

      const resultObj = isMainThread && !opts.skipAggregateResult ? aggregateResult(result, opts, histograms) : result

      if (opts.forever) {
        // we don't call callback when in forever mode, so this is the
        // only place we could notify user when each round finishes
        tracker.emit('done', resultObj)
      } else {
        latencies.destroy()
        requests.destroy()
        throughput.destroy()
        cb(null, resultObj)
      }

      const restartFn = () => {
        stop = false
        stopTimer = setTimeout(() => {
          stop = true
        }, opts.duration * 1000)
        errors = 0
        timeouts = 0
        mismatches = 0
        totalBytes = 0
        totalRequests = 0
        totalCompletedRequests = 0
        resets = 0
        statusCodes.fill(0)
        requests.reset()
        latencies.reset()
        throughput.reset()
        startTime = Date.now()

        // reinitialise clients
        if (opts.overallRate && (opts.overallRate < opts.connections)) opts.connections = opts.overallRate
        clients = []
        initialiseClients(clients)

        interval.reschedule(1000)
        tracker.emit('start')
      }

      // the restart function
      setImmediate(() => {
        if (opts.forever && restart && isMainThread) restartFn()
      })
    }
  }

  function initialiseClients (clients) {
    for (let i = 0; i < opts.connections; i++) {
      const url = urls[i % urls.length]
      if (!amount && !opts.maxConnectionRequests && opts.maxOverallRequests) {
        url.responseMax = distributeNums(opts.maxOverallRequests, i)
      }
      if (amount) {
        url.responseMax = distributeNums(amount, i)
        if (url.responseMax === 0) {
          throw Error('connections cannot be greater than amount')
        }
      }
      if (!opts.connectionRate && opts.overallRate) {
        url.rate = distributeNums(opts.overallRate, i)
      }
      if (opts.initialContext) {
        url.initialContext = opts.initialContext
      }

      if (opts.tlsOptions) {
        url.tlsOptions = opts.tlsOptions
      }

      const client = new Client(url)
      client.on('response', onResponse)
      client.on('connError', onError)
      client.on('mismatch', onExpectMismatch)
      client.on('reset', () => { resets++ })
      client.on('timeout', onTimeout)
      client.on('request', () => { totalRequests++ })
      client.on('done', onDone)
      clients.push(client)

      // we will miss the initial request emits because the client emits request on construction
      totalRequests += url.pipelining < url.rate ? url.rate : url.pipelining
    }

    function distributeNums (x, i) {
      return (Math.floor(x / opts.connections) + (((i + 1) <= (x % opts.connections)) ? 1 : 0))
    }

    function onResponse (statusCode, resBytes, responseTime, rate) {
      tracker.emit('response', this, statusCode, resBytes, responseTime)
      const codeIndex = Math.floor(parseInt(statusCode) / 100) - 1
      statusCodes[codeIndex] += 1

      if (!statusCodeStats[statusCode]) {
        statusCodeStats[statusCode] = { count: 1 }
      } else {
        statusCodeStats[statusCode].count++
      }

      // only recordValue 2xx latencies
      if (codeIndex === 1 || includeErrorStats) {
        if (rate && !opts.ignoreCoordinatedOmission) {
          latencies.recordValueWithExpectedInterval(responseTime, Math.ceil(1 / rate))
        } else {
          latencies.recordValue(responseTime)
        }
      }
      if (codeIndex === 1 || includeErrorStats) bytes += resBytes
      counter++
    }

    function onError (error) {
      for (let i = 0; i < opts.pipelining; i++) tracker.emit('reqError', error)
      errors++
      if (opts.debug) console.error(error)
      if (opts.bailout && errors >= opts.bailout) stop = true
    }

    function onExpectMismatch (bpdyStr) {
      for (let i = 0; i < opts.pipelining; i++) {
        tracker.emit('reqMismatch', bpdyStr)
      }

      mismatches++
      if (opts.bailout && mismatches >= opts.bailout) stop = true
    }

    // treat a timeout as a special type of error
    function onTimeout () {
      const error = new Error('request timed out')
      for (let i = 0; i < opts.pipelining; i++) tracker.emit('reqError', error)
      errors++
      timeouts++
      if (opts.bailout && errors >= opts.bailout) stop = true
    }

    function onDone () {
      if (!--numRunning) stop = true
    }
  }

  tracker.stop = () => {
    stop = true
    restart = false
  }

  return tracker
} // run

module.exports = run


================================================
FILE: lib/runTracker.js
================================================
'use strict'

const EE = require('events').EventEmitter
const run = require('./run')
const noop = require('./noop')

function runTracker (opts, tracker, cb) {
  cb = cb || noop
  tracker = tracker || new EE()

  run(opts, tracker, cb)

  return tracker
}

module.exports = runTracker


================================================
FILE: lib/subargAliases.js
================================================
'use strict'

const clone = require('lodash.clonedeep')

const subArgAlias = {
  warmup: {
    c: 'connections',
    d: 'duration'
  }
}

// Expects args to have already been processed by subarg
function generateSubargAliases (args) {
  const aliasedArgs = clone(args)

  function isParentAliasInArgs (argKey) {
    return aliasedArgs[argKey]
  }

  function isSubargAnAlias (parentAlias, subArg) {
    return parentAlias[subArg]
  }

  function mapAliasForSubarg (parentAlias, parentKey) {
    const parentArgs = aliasedArgs[parentKey]
    for (const subArg in parentArgs) {
      if (isSubargAnAlias(parentAlias, subArg)) {
        parentArgs[parentAlias[subArg]] = parentArgs[subArg]
      }
    }
  }

  for (const parentKey in subArgAlias) {
    const parentAlias = subArgAlias[parentKey]
    if (isParentAliasInArgs(parentKey)) {
      mapAliasForSubarg(parentAlias, parentKey)
    }
  }

  return aliasedArgs
}

module.exports = generateSubargAliases


================================================
FILE: lib/url.js
================================================
'use strict'

/**
 * check the url is not an empty string or empty array
 * @param url
 */
function checkURL (url) {
  return (typeof url === 'string' && url) ||
    (Array.isArray(url) && url.length > 0)
}

/**
 *
 * @param url
 * @param asArray
 * @returns
 */
function ofURL (url, asArray) {
  if (Array.isArray(url)) return url

  if (typeof url === 'string') {
    return {
      map (fn) {
        if (asArray) return [fn(url)]
        return fn(url)
      }
    }
  }

  throw new Error('url should only be a string or an array of string')
}

exports.checkURL = checkURL
exports.ofURL = ofURL


================================================
FILE: lib/util.js
================================================
'use strict'

const semver = require('semver')
const hasWorkerSupport = semver.gte(process.versions.node, '11.7.0')

function getPropertyCaseInsensitive (obj, key) {
  for (const objKey of Object.keys(obj)) {
    if (objKey.toLowerCase() === key.toLowerCase()) return obj[objKey]
  }
}

module.exports = { hasWorkerSupport, getPropertyCaseInsensitive }


================================================
FILE: lib/validate.js
================================================
'use strict'

const defaultOptions = require('./defaultOptions')
const timestring = require('timestring')
const { checkURL } = require('./url')
const multipart = require('./multipart')
const { parseHAR } = require('./parseHAR')
const { hasWorkerSupport } = require('./util')

const isValidFn = (opt) => (!opt || typeof opt === 'function' || typeof opt === 'string')

const lessThanOneError = (label) => new Error(`${label} can not be less than 1`)
const greaterThanZeroError = (label) => new Error(`${label} must be greater than 0`)
const minIfPresent = (val, min) => val !== null && val < min

function safeRequire (path) {
  if (typeof path === 'string') {
    try {
      return require(path)
    } catch (err) {}
  }

  return path
}

function defaultOpts (opts) {
  const setupClient = opts.workers ? opts.setupClient : safeRequire(opts.setupClient)
  const verifyBody = opts.workers ? opts.verifyBody : safeRequire(opts.verifyBody)

  const requests = opts.requests
    ? opts.requests.map((r) => {
      const setupRequest = opts.workers ? r.setupRequest : safeRequire(r.setupRequest)
      const onResponse = opts.workers ? r.onResponse : safeRequire(r.onResponse)

      return {
        ...r,
        ...(setupRequest ? { setupRequest } : undefined),
        ...(onResponse ? { onResponse } : undefined)
      }
    })
    : undefined

  return {
    ...defaultOptions,
    ...opts,
    ...(setupClient ? { setupClient } : undefined),
    ...(verifyBody ? { verifyBody } : undefined),
    ...(requests ? { requests } : undefined)
  }
}

module.exports = function validateOpts (opts, cbPassedIn) {
  if (opts.workers && !hasWorkerSupport) return new Error('Please use node >= 11.7.0 for workers support')
  // these need to be validated before defaulting
  if (minIfPresent(opts.bailout, 1)) return lessThanOneError('bailout threshold')
  if (minIfPresent(opts.connectionRate, 1)) return lessThanOneError('connectionRate')
  if (minIfPresent(opts.overallRate, 1)) return lessThanOneError('bailout overallRate')
  if (minIfPresent(opts.amount, 1)) return lessThanOneError('amount')
  if (minIfPresent(opts.maxConnectionRequests, 1)) return lessThanOneError('maxConnectionRequests')
  if (minIfPresent(opts.maxOverallRequests, 1)) return lessThanOneError('maxOverallRequests')

  if (opts.form) {
    opts.method = opts.method || 'POST'
  }

  // fill in defaults after
  opts = defaultOpts(opts)

  if (opts.json === true) {
    opts.renderProgressBar = opts.renderResultsTable = opts.renderLatencyTable = false
  }

  if (opts.requests) {
    if (opts.requests.some(r => !isValidFn(r.setupRequest))) {
      return new Error('Invalid option setupRequest, please provide a function (or file path when in workers mode)')
    }

    if (opts.requests.some(r => !isValidFn(r.onResponse))) {
      return new Error('Invalid option onResponse, please provide a function (or file path when in workers mode)')
    }
  }

  if (!isValidFn(opts.setupClient)) {
    return new Error('Invalid option setupClient, please provide a function (or file path when in workers mode)')
  }

  if (!isValidFn(opts.verifyBody)) {
    return new Error('Invalid option verifyBody, please provide a function (or file path when in workers mode)')
  }

  if (!checkURL(opts.url) && !opts.socketPath) {
    return new Error('url or socketPath option required')
  }

  if (typeof opts.duration === 'string') {
    if (/[a-zA-Z]/.exec(opts.duration)) {
      try {
        opts.duration = timestring(opts.duration)
      } catch (error) {
        return error
      }
    } else {
      opts.duration = Number(opts.duration.trim())
    }
  }

  if (typeof opts.duration !== 'number') {
    return new Error('duration entered was in an invalid format')
  }

  if (opts.duration < 0) {
    return new Error('duration can not be less than 0')
  }

  opts.sampleInt = parseFloat(opts.sampleInt)

  if (isNaN(opts.sampleInt)) {
    return new Error('sample interval entered was in an invalid format')
  }

  if (opts.sampleInt < 0) {
    return new Error('sample interval can not be less than 0')
  }

  if (opts.expectBody && opts.requests !== defaultOptions.requests) {
    return new Error('expectBody cannot be used in conjunction with requests')
  }

  if (opts.form) {
    try {
      // Parse multipart upfront to make sure there's no errors
      const data = multipart(opts.form)
      opts.form = opts.workers ? opts.form : data // but use parsed data only if not in workers mode
    } catch (error) {
      return error
    }
  }

  opts.harRequests = new Map()
  if (opts.har) {
    try {
      opts.harRequests = parseHAR(opts.har)
    } catch (error) {
      return error
    }
  }

  if (opts.connections < 1) return lessThanOneError('connections')
  if (opts.pipelining < 1) return lessThanOneError('pipelining factor')
  if (opts.timeout < 1) return greaterThanZeroError('timeout')

  if (opts.ignoreCoordinatedOmission && !opts.connectionRate && !opts.overallRate) {
    return new Error('ignoreCoordinatedOmission makes no sense without connectionRate or overallRate')
  }

  if (opts.forever && cbPassedIn) {
    return new Error('should not use the callback parameter when the `forever` option is set to true. Use the `done` event on this event emitter')
  }

  if (opts.forever && opts.workers) {
    return new Error('Using `forever` option isn\'t currently supported with workers')
  }

  return opts
}


================================================
FILE: lib/worker.js
================================================
'use strict'

const { isMainThread, parentPort, workerData } = require('worker_threads')
const multipart = require('./multipart')
const run = require('./run')

const createHist = (name) => ({
  __custom: true,
  recordValue: v => updateHist(name, v),
  destroy: () => {},
  reset: () => resetHist(name)
})

const updateHist = (name, value) => {
  parentPort.postMessage({
    cmd: 'UPDATE_HIST',
    data: { name, value }
  })
}

const resetHist = (name) => {
  parentPort.postMessage({
    cmd: 'RESET_HIST',
    data: { name }
  })
}

function runTracker (opts, cb) {
  const tracker = run({
    ...opts,
    ...(opts.form ? { form: multipart(opts.form) } : undefined),
    ...(opts.setupClient ? { setupClient: require(opts.setupClient) } : undefined),
    ...(opts.verifyBody ? { verifyBody: require(opts.verifyBody) } : undefined),
    requests: opts.requests
      ? opts.requests.map(r => ({
        ...r,
        ...(r.setupRequest ? { setupRequest: require(r.setupRequest) } : undefined),
        ...(r.onResponse ? { onResponse: require(r.onResponse) } : undefined)
      }))
      : undefined,
    histograms: {
      requests: createHist('requests'),
      throughput: createHist('throughput')
    }
  }, null, cb)

  tracker.on('tick', (data) => {
    parentPort.postMessage({ cmd: 'TICK', data })
  })

  return {
    stop: tracker.stop
  }
}

if (!isMainThread) {
  const { opts } = workerData
  let tracker

  parentPort.on('message', (msg) => {
    const { cmd } = msg

    if (cmd === 'START') {
      tracker = runTracker(opts, (error, data) => {
        parentPort.postMessage({ cmd: error ? 'ERROR' : 'RESULT', error, data })
        parentPort.close()
      })
    } else if (cmd === 'STOP') {
      tracker.stop()
      parentPort.close()
    }
  })
}


================================================
FILE: lib/worker_threads.js
================================================
'use strict'

let workerThreads = {}

try {
  workerThreads = require('worker_threads')
} catch (err) {
  if (err) {
    // we don't need the error but can't have catch block
    // without err as node 8 doesn't support that
  }

  workerThreads = {
    isMainThread: true
  }
}

module.exports = workerThreads


================================================
FILE: package.json
================================================
{
  "name": "autocannon",
  "version": "8.0.0",
  "description": "Fast HTTP benchmarking tool written in Node.js",
  "main": "autocannon.js",
  "bin": {
    "autocannon": "autocannon.js"
  },
  "scripts": {
    "test": "standard && tap test/serial/*.test.js test/*.test.js",
    "standard:fix": "standard --fix"
  },
  "pre-commit": [
    "test"
  ],
  "repository": {
    "type": "git",
    "url": "git+https://github.com/mcollina/autocannon.git"
  },
  "keywords": [
    "http",
    "soak",
    "load",
    "fast",
    "wrk",
    "ab",
    "test"
  ],
  "author": "Matteo Collina <hello@matteocollina.com>",
  "contributors": [
    "Glen Keane <glenkeane.94@gmail.com>",
    "Donald Robertson <donaldarobertson89@gmail.com",
    "Salman Mitha <SalmanMitha@gmail.com>"
  ],
  "license": "MIT",
  "bugs": {
    "url": "https://github.com/mcollina/autocannon/issues"
  },
  "homepage": "https://github.com/mcollina/autocannon#readme",
  "devDependencies": {
    "ansi-regex": "^5.0.1",
    "bl": "^6.0.0",
    "busboy": "^0.3.1",
    "pre-commit": "^1.1.2",
    "proxyquire": "^2.1.3",
    "sinon": "^15.0.0",
    "split2": "^4.0.0",
    "standard": "^17.0.0",
    "tap": "^16.0.0",
    "why-is-node-running": "^2.3.0"
  },
  "dependencies": {
    "@minimistjs/subarg": "^1.0.0",
    "chalk": "^4.1.0",
    "char-spinner": "^1.0.1",
    "cli-table3": "^0.6.0",
    "color-support": "^1.1.1",
    "cross-argv": "^2.0.0",
    "form-data": "^4.0.0",
    "has-async-hooks": "^1.0.0",
    "hdr-histogram-js": "^3.0.0",
    "hdr-histogram-percentiles-obj": "^3.0.0",
    "http-parser-js": "^0.5.2",
    "hyperid": "^3.0.0",
    "lodash.chunk": "^4.2.0",
    "lodash.clonedeep": "^4.5.0",
    "lodash.flatten": "^4.4.0",
    "manage-path": "^2.0.0",
    "on-net-listen": "^1.1.1",
    "pretty-bytes": "^5.4.1",
    "progress": "^2.0.3",
    "reinterval": "^1.1.0",
    "retimer": "^3.0.0",
    "semver": "^7.3.2",
    "timestring": "^6.0.0"
  }
}


================================================
FILE: samples/bench-multi-url.js
================================================
'use strict'

const http = require('http')
const autocannon = require('../autocannon')

function createHandler (serverName) {
  return function (req, res) {
    console.log(serverName + ' received request')
    res.end('hello world')
  }
}

const server1 = http.createServer(createHandler('server1'))
const server2 = http.createServer(createHandler('server2'))

server1.listen(0, startBench)
server2.listen(0, startBench)

function startBench () {
  const url = [
    'http://localhost:' + server1.address().port,
    'http://localhost:' + server2.address().port
  ]

  // same with run the follow command in cli
  // autocannon -d 10 -c 2 http://localhost:xxxx http://localhost:yyyy
  autocannon({
    url,
    // connection number should n times of the number of server
    connections: 2,
    duration: 10,
    requests: [
      {
        method: 'GET',
        path: '/'
      }
    ]
  }, finishedBench)

  function finishedBench (err, res) {
    console.log('finished bench', err, res)
    process.exit(1)
  }
}


================================================
FILE: samples/customise-individual-connection.js
================================================
'use strict'

const http = require('http')
const autocannon = require('../autocannon')

const server = http.createServer(handle)

server.listen(0, startBench)

let connection = 0

function handle (req, res) {
  res.end('hello world')
}

function startBench () {
  const url = 'http://localhost:' + server.address().port

  autocannon({
    url,
    connections: 1000,
    duration: 10,
    setupClient
  }, finishedBench)

  function setupClient (client) {
    client.setBody('connection number', connection++)
  }

  function finishedBench (err, res) {
    console.log('finished bench', err, res)
  }
}


================================================
FILE: samples/customise-verifyBody-workers.js
================================================
'use strict'

const http = require('http')
const path = require('path')
const autocannon = require('../autocannon')

const server = http.createServer(handle)

server.listen(0, startBench)

function handle (req, res) {
  res.end('hello world')
}

function startBench () {
  const url = 'http://localhost:' + server.address().port

  autocannon({
    url,
    connections: 1000,
    duration: 10,
    workers: 2,
    verifyBody: path.join(__dirname, 'helpers', 'verify-body')
  }, finishedBench)

  function finishedBench (err, res) {
    console.log('finished bench', err, res)
  }
}


================================================
FILE: samples/customise-verifyBody.js
================================================
'use strict'

const http = require('http')
const autocannon = require('../autocannon')

const server = http.createServer(handle)

server.listen(0, startBench)

function handle (req, res) {
  res.end('hello world')
}

function startBench () {
  const url = 'http://localhost:' + server.address().port

  autocannon({
    url,
    connections: 1000,
    duration: 10,
    verifyBody
  }, finishedBench)

  function verifyBody (body) {
    return body.indexOf('<html>') > -1
  }

  function finishedBench (err, res) {
    console.log('finished bench', err, res)
  }
}


================================================
FILE: samples/helpers/on-response.js
================================================
'use strict'

module.exports = (status, body, context) => {
  if (status === 200) {
    context.user = JSON.parse(body)
  } // on error, you may abort the benchmark
}


================================================
FILE: samples/helpers/setup-request.js
================================================
'use strict'

module.exports = (req, context) => ({
  ...req,
  path: `/user/${context.user.id}`,
  body: JSON.stringify({
    ...context.user,
    lastName: 'Doe'
  })
})


================================================
FILE: samples/helpers/verify-body.js
================================================
'use strict'

module.exports = (body) => {
  return true
}


================================================
FILE: samples/init-context.js
================================================
'use strict'

const http = require('http')
const autocannon = require('../autocannon')

const server = http.createServer(handle)

server.listen(0, startBench)

function handle (req, res) {
  const body = []
  // this route handler simply returns whatever it gets from response
  req
    .on('data', chunk => body.push(chunk))
    .on('end', () => res.end(Buffer.concat(body)))
}

function startBench () {
  const url = 'http://localhost:' + server.address().port

  autocannon({
    url,
    connections: 1,
    amount: 1,
    initialContext: { user: { firstName: 'Salman' } },
    requests: [
      {
        // use data from context
        method: 'PUT',
        setupRequest: (req, context) => ({
          ...req,
          path: `/user/${context.user.id}`,
          body: JSON.stringify({
            ...context.user,
            lastName: 'Mitha'
          })
        })
      }
    ]
  }, finishedBench)

  function finishedBench (err, res) {
    console.log('finished bench', err, res)
  }
}


================================================
FILE: samples/modifying-request.js
================================================
'use strict'

const http = require('http')
const autocannon = require('../autocannon')

const server = http.createServer(handle)

server.listen(0, startBench)

function handle (req, res) {
  res.end('hello world')
}

function startBench () {
  const url = 'http://localhost:' + server.address().port

  const instance = autocannon({
    url,
    connections: 1000,
    duration: 10
  }, finishedBench)

  let message = 0
  // modify the body on future requests
  instance.on('response', function (client, statusCode, returnBytes, responseTime) {
    client.setBody('message ' + message++)
  })

  let headers = 0
  // modify the headers on future requests
  // this wipes any existing headers out with the new ones
  instance.on('response', function (client, statusCode, returnBytes, responseTime) {
    const newHeaders = {}
    newHeaders[`header${headers++}`] = `headerValue${headers++}`
    client.setHeaders(newHeaders)
  })

  function finishedBench (err, res) {
    console.log('finished bench', err, res)
  }
}


================================================
FILE: samples/request-context-workers.js
================================================
'use strict'

const http = require('http')
const path = require('path')
const autocannon = require('../autocannon')

const server = http.createServer(handle)

server.listen(0, startBench)

function handle (req, res) {
  const body = []
  // this route handler simply returns whatever it gets from response
  req
    .on('data', chunk => body.push(chunk))
    .on('end', () => res.end(Buffer.concat(body)))
}

function startBench () {
  const url = 'http://localhost:' + server.address().port

  autocannon({
    url,
    duration: 2,
    workers: 2,
    requests: [
      {
        // let's create a new user
        method: 'POST',
        path: '/users',
        body: JSON.stringify({ firstName: 'Jane', id: 10 }),
        onResponse: path.join(__dirname, 'helpers', 'on-response')
      },
      {
        // now we'll give them a last name
        method: 'PUT',
        setupRequest: path.join(__dirname, 'helpers', 'setup-request')
      }
    ]
  }, finishedBench)

  function finishedBench (err, res) {
    console.log('finished bench', err, res)
  }
}


================================================
FILE: samples/request-context.js
================================================
'use strict'

const http = require('http')
const autocannon = require('../autocannon')

const server = http.createServer(handle)

server.listen(0, startBench)

function handle (req, res) {
  const body = []
  // this route handler simply returns whatever it gets from response
  req
    .on('data', chunk => body.push(chunk))
    .on('end', () => res.end(Buffer.concat(body)))
}

function startBench () {
  const url = 'http://localhost:' + server.address().port

  autocannon({
    url,
    requests: [
      {
        // let's create a new user
        method: 'POST',
        path: '/users',
        body: JSON.stringify({ firstName: 'Jane', id: 10 }),
        onResponse: (status, body, context) => {
          if (status === 200) {
            context.user = JSON.parse(body)
          } // on error, you may abort the benchmark
        }
      },
      {
        // now we'll give them a last name
        method: 'PUT',
        setupRequest: (req, context) => ({
          ...req,
          path: `/user/${context.user.id}`,
          body: JSON.stringify({
            ...context.user,
            lastName: 'Doe'
          })
        })
      }
    ]
  }, finishedBench)

  function finishedBench (err, res) {
    console.log('finished bench', err, res)
  }
}


================================================
FILE: samples/requests-sample.js
================================================
'use strict'

const http = require('http')
const autocannon = require('../autocannon')

const server = http.createServer(handle)

server.listen(0, startBench)

function handle (req, res) {
  res.end('hello world')
}

function startBench () {
  const url = 'http://localhost:' + server.address().port

  autocannon({
    url,
    connections: 1000,
    duration: 10,
    headers: {
      // by default we add an auth token to all requests
      auth: 'A Pregenerated auth token'
    },
    requests: [
      {
        method: 'POST', // this should be a post for logging in
        path: '/login',
        body: 'valid login details',
        // overwrite our default headers,
        // so we don't add an auth token
        // for this request
        headers: {}
      },
      {
        path: '/mySecretDetails'
        // this will automatically add the pregenerated auth token
      },
      {
        method: 'GET', // this should be a put for modifying secret details
        path: '/mySecretDetails',
        headers: { // let submit some json?
          'Content-type': 'application/json; charset=utf-8'
        },
        // we need to stringify the json first
        body: JSON.stringify({
          name: 'my new name'
        }),
        setupRequest: reqData => {
          reqData.method = 'PUT' // we are overriding the method 'GET' to 'PUT' here
          return reqData
        }
      }
    ]
  }, finishedBench)

  function finishedBench (err, res) {
    console.log('finished bench', err, res)
  }
}


================================================
FILE: samples/track-run-workers.js
================================================
'use strict'

const http = require('http')
const autocannon = require('../autocannon')

const server = http.createServer(handle)

server.listen(0, startBench)

function handle (req, res) {
  res.end('hello world')
}

function startBench () {
  const instance = autocannon({
    connections: 100,
    duration: 2,
    url: 'http://localhost:' + server.address().port,
    workers: 2
  }, finishedBench)

  autocannon.track(instance)

  // this is used to kill the instance on CTRL-C
  process.once('SIGINT', () => {
    instance.stop()
  })

  function finishedBench (err, res) {
    console.log('finished bench', err, res)
  }
}


================================================
FILE: samples/track-run.js
================================================
'use strict'

const http = require('http')
const autocannon = require('../autocannon')

const server = http.createServer(handle)

server.listen(0, startBench)

function handle (req, res) {
  res.end('hello world')
}

function startBench () {
  const instance = autocannon({
    url: 'http://localhost:' + server.address().port
  }, finishedBench)

  autocannon.track(instance)

  // this is used to kill the instance on CTRL-C
  process.once('SIGINT', () => {
    instance.stop()
  })

  function finishedBench (err, res) {
    console.log('finished bench', err, res)
  }
}


================================================
FILE: samples/using-id-replacement.js
================================================
'use strict'

const http = require('http')
const autocannon = require('../autocannon')

const server = http.createServer(handle)

server.listen(0, startBench)

function handle (req, res) {
  res.end('hello world')
}

function startBench () {
  const url = 'http://localhost:' + server.address().port

  autocannon({
    url,
    connections: 1000,
    duration: 10,
    requests: [
      {
        method: 'POST',
        path: '/register',
        headers: {
          'Content-type': 'application/json; charset=utf-8'
        },
        body: JSON.stringify({
          name: 'New User',
          email: 'new-[<id>]@user.com' // [<id>] will be replaced with generated HyperID at run time
        })
      }
    ],
    idReplacement: true
  }, finishedBench)

  function finishedBench (err, res) {
    console.log('finished bench', err, res)
  }
}


================================================
FILE: server.js
================================================
'use strict'

const http = require('http')
const https = require('https')
const fs = require('fs')
const path = require('path')

const options = {
  key: fs.readFileSync(path.join(__dirname, 'test', '/key.pem')),
  cert: fs.readFileSync(path.join(__dirname, 'test', '/cert.pem')),
  passphrase: 'test'
}
const server = http.createServer(handle)
const server2 = https.createServer(options, handle)

server.listen(3000)
server2.listen(3001)

function handle (req, res) {
  res.end('hello world')
}


================================================
FILE: test/aggregateResult.test.js
================================================
const { test } = require('tap')
const { startServer } = require('./helper')
const autocannon = require('../autocannon')
const aggregateResult = autocannon.aggregateResult
const server = startServer()
const url = 'http://localhost:' + server.address().port

test('exec separate autocannon instances with skipAggregateResult, then aggregateResult afterwards', async (t) => {
  t.plan(2)

  const opts = {
    url,
    connections: 1,
    maxOverallRequests: 10,
    skipAggregateResult: true
  }

  const results = await Promise.all([
    autocannon(opts),
    autocannon(opts)
  ])

  const aggregateResults = aggregateResult(results, opts)

  t.equal(aggregateResults['2xx'], 20)
  t.equal(aggregateResults.requests.total, 20)
})

test('aggregateResult must be passed opts with at least a URL or socketPath property', async (t) => {
  t.plan(2)
  t.throws(() => aggregateResult([]), 'url or socketPath option required')
  t.throws(() => aggregateResult([], {}), 'url or socketPath option required')
})


================================================
FILE: test/argumentParsing.test.js
================================================
'use strict'

const test = require('tap').test
const Autocannon = require('../autocannon')
const fs = require('fs')

test('parse argument', (t) => {
  t.plan(4)

  const args = Autocannon.parseArguments([
    '-H', 'X-Http-Method-Override=GET',
    '-m', 'POST',
    '-b', 'the body',
    'http://localhost/foo/bar'
  ])

  t.equal(args.url, 'http://localhost/foo/bar')
  t.strictSame(args.headers, { 'X-Http-Method-Override': 'GET' })
  t.equal(args.method, 'POST')
  t.equal(args.body, 'the body')
})

test('parse argument with multiple headers', (t) => {
  t.plan(3)

  const args = Autocannon.parseArguments([
    '-H', 'header1=value1',
    '-H', 'header2=value2',
    '-H', 'header3=value3',
    '-H', 'header4=value4',
    '-H', 'header5=value5',
    'http://localhost/foo/bar'
  ])

  t.equal(args.url, 'http://localhost/foo/bar')
  t.strictSame(args.headers, {
    header1: 'value1',
    header2: 'value2',
    header3: 'value3',
    header4: 'value4',
    header5: 'value5'
  })
  t.equal(args.method, 'GET')
})

test('parse argument with multiple complex headers', (t) => {
  t.plan(3)

  const args = Autocannon.parseArguments([
    '-H', 'header1=value1;data=asd',
    '-H', 'header2=value2;data=asd',
    '-H', 'header3=value3;data=asd',
    '-H', 'header4=value4;data=asd',
    '-H', 'header5=value5;data=asd',
    'http://localhost/foo/bar'
  ])

  t.equal(args.url, 'http://localhost/foo/bar')
  t.strictSame(args.headers, {
    header1: 'value1;data=asd',
    header2: 'value2;data=asd',
    header3: 'value3;data=asd',
    header4: 'value4;data=asd',
    header5: 'value5;data=asd'
  })
  t.equal(args.method, 'GET')
})

test('parse argument with multiple headers in standard notation', (t) => {
  t.plan(3)

  const args = Autocannon.parseArguments([
    '-H', 'header1: value1',
    '-H', 'header2: value2',
    '-H', 'header3: value3',
    '-H', 'header4: value4',
    '-H', 'header5: value5',
    'http://localhost/foo/bar'
  ])

  t.equal(args.url, 'http://localhost/foo/bar')
  t.strictSame(args.headers, {
    header1: ' value1',
    header2: ' value2',
    header3: ' value3',
    header4: ' value4',
    header5: ' value5'
  })
  t.equal(args.method, 'GET')
})

test('parse argument with multiple complex headers in standard notation', (t) => {
  t.plan(3)

  const args = Autocannon.parseArguments([
    '-H', 'header1:value1;data=asd',
    '-H', 'header2:value2;data=asd',
    '-H', 'header3:value3;data=asd',
    '-H', 'header4:value4;data=asd',
    '-H', 'header5:value5;data=asd',
    'http://localhost/foo/bar'
  ])

  t.equal(args.url, 'http://localhost/foo/bar')
  t.strictSame(args.headers, {
    header1: 'value1;data=asd',
    header2: 'value2;data=asd',
    header3: 'value3;data=asd',
    header4: 'value4;data=asd',
    header5: 'value5;data=asd'
  })
  t.equal(args.method, 'GET')
})

test('parse argument with "=" in value header', (t) => {
  t.plan(1)

  const args = Autocannon.parseArguments([
    '-H', 'header1=foo=bar',
    'http://localhost/foo/bar'
  ])

  t.strictSame(args.headers, {
    header1: 'foo=bar'
  })
})

test('parse argument ending space in value header', (t) => {
  t.plan(1)

  const args = Autocannon.parseArguments([
    '-H', 'header1=foo=bar ',
    'http://localhost/foo/bar'
  ])

  t.strictSame(args.headers, {
    header1: 'foo=bar '
  })
})

test('parse argument with ":" in value header', (t) => {
  t.plan(1)

  const args = Autocannon.parseArguments([
    '-H', 'header1=foo:bar',
    'http://localhost/foo/bar'
  ])

  t.strictSame(args.headers, {
    header1: 'foo:bar'
  })
})

test('parse argument not correctly formatted header', (t) => {
  t.plan(1)

  t.throws(() => {
    Autocannon.parseArguments([
      '-H', 'header1',
      'http://localhost/foo/bar'
    ])
  }, /An HTTP header was not correctly formatted/)
})

test('parse argument with multiple url', (t) => {
  t.plan(2)
  const args = Autocannon.parseArguments([
    'localhost/foo/bar',
    'http://localhost/baz/qux'
  ])

  t.equal(args.url[0], 'http://localhost/foo/bar')
  t.equal(args.url[1], 'http://localhost/baz/qux')
})

test('parse argument with input file and multiple workers', (t) => {
  t.plan(3)

  const inputPath = 'help.txt'
  const args = Autocannon.parseArguments([
    '-m', 'POST',
    '-w', '2',
    '-a', 10,
    '-i', inputPath,
    '-H', 'Content-Type=application/json',
    'http://localhost/foo/bar'
  ])

  t.equal(args.url, 'http://localhost/foo/bar')
  t.equal(args.method, 'POST')
  t.equal(args.body, fs.readFileSync(inputPath, 'utf8'))
})

test('parse argument with cert, key and multiple ca paths', (t) => {
  t.plan(5)

  const certPath = 'test/cert.pem'
  const keyPath = 'test/key.pem'
  const caPath1 = 'help.txt'
  const caPath2 = 'package.json'
  const args = Autocannon.parseArguments([
    '-m', 'POST',
    '--cert', certPath,
    '--key', keyPath,
    '--ca', '[', caPath1, caPath2, ']',
    'http://localhost/foo/bar'
  ])

  t.equal(args.url, 'http://localhost/foo/bar')
  t.equal(args.method, 'POST')
  t.same(args.tlsOptions.cert, fs.readFileSync(certPath))
  t.same(args.tlsOptions.key, fs.readFileSync(keyPath))
  t.same(args.tlsOptions.ca, [fs.readFileSync(caPath1), fs.readFileSync(caPath2)])
})

test('parse argument with cert, key and single ca path', (t) => {
  t.plan(5)

  const certPath = 'test/cert.pem'
  const keyPath = 'test/key.pem'
  const caPath = 'help.txt'
  const args = Autocannon.parseArguments([
    '-m', 'POST',
    '--cert', certPath,
    '--key', keyPath,
    '--ca', caPath,
    'http://localhost/foo/bar'
  ])

  t.equal(args.url, 'http://localhost/foo/bar')
  t.equal(args.method, 'POST')
  t.same(args.tlsOptions.cert, fs.readFileSync(certPath))
  t.same(args.tlsOptions.key, fs.readFileSync(keyPath))
  t.same(args.tlsOptions.ca, [fs.readFileSync(caPath)])
})


================================================
FILE: test/basic-auth.test.js
================================================
'use strict'

const t = require('tap')
const split = require('split2')
const path = require('path')
const childProcess = require('child_process')
const helper = require('./helper')

const lines = [
  /Running 1s test @ .*$/,
  /10 connections.*$/,
  /$/,
  /.*/,
  /$/,
  /Stat.*2\.5%.*50%.*97\.5%.*99%.*Avg.*Stdev.*Max.*$/,
  /.*/,
  /Latency.*$/,
  /$/,
  /.*/,
  /Stat.*1%.*2\.5%.*50%.*97\.5%.*Avg.*Stdev.*Min.*$/,
  /.*/,
  /Req\/Sec.*$/,
  /.*/,
  /Bytes\/Sec.*$/,
  /.*/,
  /$/,
  /Req\/Bytes counts sampled once per second.*$/,
  /# of samples: 10*$/,
  /$/,
  /.* requests in ([0-9]|\.)+s, .* read/
]

t.plan(lines.length * 2)

const server = helper.startBasicAuthServer()
const url = 'http://foo:bar@localhost:' + server.address().port

const child = childProcess.spawn(process.execPath, [path.join(__dirname, '..'), '-d', '1', url], {
  cwd: __dirname,
  env: process.env,
  stdio: ['ignore', 'pipe', 'pipe'],
  detached: false
})

t.teardown(() => {
  child.kill()
})

child
  .stderr
  .pipe(split())
  .on('data', (line) => {
    const regexp = lines.shift()
    t.ok(regexp, 'we are expecting this line')
    t.ok(regexp.test(line), 'line matches ' + regexp)
  })


================================================
FILE: test/cert.pem
================================================
-----BEGIN CERTIFICATE-----
MIIEVzCCAz+gAwIBAgIJAJn02lrTTFjxMA0GCSqGSIb3DQEBBQUAMHoxCzAJBgNV
BAYTAklFMRIwEAYDVQQIEwl3YXRlcmZvcmQxDTALBgNVBAcTBHRlc3QxDTALBgNV
BAoTBHRlc3QxDTALBgNVBAsTBHRlc3QxDTALBgNVBAMTBHRlc3QxGzAZBgkqhkiG
9w0BCQEWDHRlc0B0ZXN0LmNvbTAeFw0xNjA2MjcxNDE4MDdaFw0xOTAzMjMxNDE4
MDdaMHoxCzAJBgNVBAYTAklFMRIwEAYDVQQIEwl3YXRlcmZvcmQxDTALBgNVBAcT
BHRlc3QxDTALBgNVBAoTBHRlc3QxDTALBgNVBAsTBHRlc3QxDTALBgNVBAMTBHRl
c3QxGzAZBgkqhkiG9w0BCQEWDHRlc0B0ZXN0LmNvbTCCASIwDQYJKoZIhvcNAQEB
BQADggEPADCCAQoCggEBAK0PhkEuPPEQNc1/96rapuEazVaa5p74QAn4PNOPIKaz
XWyLheBF78N320w6jB4eqAe3o6XMtt28iK+q+HejLZt7v+m6c7lHDtfcLSG8CEJ3
dfwR/iOfCLRlDeZyWvxouf9/s3FSAM5VqKb9kmc/Pt2+opWlX1cZvdfkg/lzSHUu
FwmuxOAONKt2dPiEvDSiSs99Kv0+jSgMmy+4D8LGyvxFCQu67bh6a2zGEEYAcAib
Rpw+Fb/AK8VYPW528SaWHRT7CcDgzdXaMfos3EWOQ/Cc0Q+MgqVfSmqTEUPXAc41
Y4Lvvl5GSHQ4lve3jIR05xenxcMIZ8BP7fJ3BfjXCxsCAwEAAaOB3zCB3DAdBgNV
HQ4EFgQUYtl9YCe7XZ4F0MvA627f+BOJoVYwgawGA1UdIwSBpDCBoYAUYtl9YCe7
XZ4F0MvA627f+BOJoVahfqR8MHoxCzAJBgNVBAYTAklFMRIwEAYDVQQIEwl3YXRl
cmZvcmQxDTALBgNVBAcTBHRlc3QxDTALBgNVBAoTBHRlc3QxDTALBgNVBAsTBHRl
c3QxDTALBgNVBAMTBHRlc3QxGzAZBgkqhkiG9w0BCQEWDHRlc0B0ZXN0LmNvbYIJ
AJn02lrTTFjxMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEBAJN7pnlv
SascD2V0I+9wirpuuNnfUP5YCFaAjky4DREV+DRPXEL2tzTQqsEeFts8BHBH+Jz3
ytYP5NZSjuToF9czu8v3+mPCSqzdOFKruJbl/lAokLJWan8Z3qfXWZQL79C2I7Ih
hSBnH/O+jZz9FPRJ2ydR8DB0LdGVKkQFvZynPZOh7D4NKvrEgFad4p6EBFshO+8N
1ALfR/2mrJOkBHfHPVWMmy6DoXWyVijPuLaa+l2TzdQJycl6CAJw6F7tPoO75qKY
MAcIKOW5F9Zv7I3aqmoLDOaOh43FeT2JLvODe2TIaytWckoFesGadEgvAzCAXC4r
ArqQX2nVUdasOnQ=
-----END CERTIFICATE-----


================================================
FILE: test/cli-ipc.test.js
================================================
'use strict'

const t = require('tap')
const split = require('split2')
const os = require('os')
const path = require('path')
const childProcess = require('child_process')
const helper = require('./helper')

const win = process.platform === 'win32'

const lines = [
  /Running 1s test @ http:\/\/example.com\/foo \([^)]*\)$/,
  /10 connections.*$/,
  /$/,
  /.*/,
  /$/,
  /Stat.*2\.5%.*50%.*97\.5%.*99%.*Avg.*Stdev.*Max.*$/,
  /.*/,
  /Latency.*$/,
  /$/,
  /.*/,
  /Stat.*1%.*2\.5%.*50%.*97\.5%.*Avg.*Stdev.*Min.*$/,
  /.*/,
  /Req\/Sec.*$/,
  /.*/,
  /Bytes\/Sec.*$/,
  /.*/,
  /$/,
  /Req\/Bytes counts sampled once per second.*$/,
  /# of samples: 10*$/,
  /$/,
  /.* requests in ([0-9]|\.)+s, .* read/
]

if (!win) {
  // If not Windows we can predict exactly how many lines there will be. On
  // Windows we rely on t.end() being called.
  t.plan(lines.length)
}

t.autoend(false)
t.teardown(function () {
  child.kill()
})

const socketPath = win
  ? path.join('\\\\?\\pipe', process.cwd(), 'autocannon-' + Date.now())
  : path.join(os.tmpdir(), 'autocannon-' + Date.now() + '.sock')

helper.startServer({ socketPath })

const child = childProcess.spawn(process.execPath, [path.join(__dirname, '..'), '-d', '1', '-S', socketPath, 'example.com/foo'], {
  cwd: __dirname,
  env: process.env,
  stdio: ['ignore', 'pipe', 'pipe'],
  detached: false
})

// For handling the last line on Windows
let errorLine = false
let failsafeTimer

child
  .stderr
  .pipe(split())
  .on('data', (line) => {
    let regexp = lines.shift()
    const lastLine = lines.length === 0

    if (regexp) {
      t.ok(regexp.test(line), 'line matches ' + regexp)

      if (lastLine && win) {
        // We can't be sure the error line is outputted on Windows, so in case
        // this really is the last line, we'll set a timer to auto-end the test
        // in case there are no more lines.
        failsafeTimer = setTimeout(function () {
          t.end()
        }, 1000)
      }
    } else if (!errorLine && win) {
      // On Windows a few errors are expected. We'll accept a 1% error rate on
      // the pipe.
      errorLine = true
      clearTimeout(failsafeTimer)
      regexp = /^(\d+) errors \(0 timeouts\)$/
      const match = line.match(regexp)
      t.ok(match, 'line matches ' + regexp)
      const errors = Number(match[1])
      t.ok(errors / 15000 < 0.01, `should have less than 1% errors on Windows (had ${errors} errors)`)
      t.end()
    } else {
      throw new Error('Unexpected line: ' + JSON.stringify(line))
    }
  })


================================================
FILE: test/cli.test.js
================================================
'use strict'

const test = require('tap').test
const split = require('split2')
const path = require('path')
const fs = require('fs')
const os = require('os')
const childProcess = require('child_process')
const helper = require('./helper')
const { hasWorkerSupport } = require('../lib/util')

test('should run benchmark against server', (t) => {
  const lines = [
    /Running 1s test @ .*$/,
    /10 connections.*$/,
    /$/,
    /.*/,
    /$/,
    /Stat.*2\.5%.*50%.*97\.5%.*99%.*Avg.*Stdev.*Max.*$/,
    /.*/,
    /Latency.*$/,
    /$/,
    /.*/,
    /Stat.*1%.*2\.5%.*50%.*97\.5%.*Avg.*Stdev.*Min.*$/,
    /.*/,
    /Req\/Sec.*$/,
    /.*/,
    /Bytes\/Sec.*$/,
    /.*/,
    /$/,
    /Req\/Bytes counts sampled once per second.*$/,
    /# of samples: 1.*$/,
    /$/,
    /.* requests in ([0-9]|\.)+s, .* read/
  ]

  t.plan(lines.length * 2)

  const server = helper.startServer()
  const url = 'http://localhost:' + server.address().port

  const child = childProcess.spawn(process.execPath, [path.join(__dirname, '..'), '-d', '1', url], {
    cwd: __dirname,
    env: process.env,
    stdio: ['ignore', 'pipe', 'pipe'],
    detached: false
  })

  t.teardown(() => {
    try {
      child.kill()
    } catch {}
  })

  child
    .stderr
    .pipe(split())
    .on('data', (line) => {
      const regexp = lines.shift()
      t.ok(regexp, 'we are expecting this line')
      t.ok(regexp.test(line), 'line matches ' + regexp)
    })
    .on('end', t.end)
})

test('should parse HAR file and run requests', (t) => {
  const lines = [
    /Running \d+ requests test @ .*$/,
    /1 connections.*$/,
    /$/,
    /.*/,
    /$/,
    /Stat.*2\.5%.*50%.*97\.5%.*99%.*Avg.*Stdev.*Max.*$/,
    /.*/,
    /Latency.*$/,
    /$/,
    /.*/,
    /Stat.*1%.*2\.5%.*50%.*97\.5%.*Avg.*Stdev.*Min.*$/,
    /.*/,
    /Req\/Sec.*$/,
    /.*/,
    /Bytes\/Sec.*$/,
    /.*/,
    /$/,
    /Req\/Bytes counts sampled once per second.*$/,
    /# of samples: 1.*$/,
    /$/,
    /.* requests in ([0-9]|\.)+s, .* read/
  ]

  t.plan(lines.length)

  const server = helper.startServer()
  const url = `http://localhost:${server.address().port}`
  const harPath = path.join(os.tmpdir(), 'autocannon-test.har')
  const har = helper.customizeHAR('./fixtures/httpbin-simple-get.json', 'https://httpbin.org', url)
  fs.writeFileSync(harPath, JSON.stringify(har))

  const child = childProcess.spawn(process.execPath, [path.join(__dirname, '..'), '-a', 4, '-c', 1, '--har', harPath, url], {
    cwd: __dirname,
    env: process.env,
    stdio: ['ignore', 'pipe', 'pipe'],
    detached: false
  })

  t.teardown(() => {
    try {
      child.kill()
    } catch {}
  })

  child
    .stderr
    .pipe(split())
    .on('data', (line) => {
      const regexp = lines.shift()
      t.ok(regexp.test(line), `"${line}" matches ${regexp}`)
    })
    .on('end', t.end)
})

test('should throw on unknown HAR file', (t) => {
  t.plan(1)

  const child = childProcess.spawn(process.execPath, [path.join(__dirname, '..'), '-a', 4, '-c', 1, '--har', 'does not exist', 'http://localhost'], {
    cwd: __dirname,
    env: process.env,
    stdio: ['ignore', 'pipe', 'pipe'],
    detached: false
  })

  t.teardown(() => {
    try {
      child.kill()
    } catch {}
  })

  const lines = []
  child
    .stderr
    .pipe(split())
    .on('data', line => lines.push(line))
    .on('end', () => {
      const output = lines.join('\n')
      t.ok(output.includes('Error: Failed to load HAR file content: ENOENT'), `Unexpected output:\n${output}`)
      t.end()
    })
})

test('should throw on invalid HAR file', (t) => {
  t.plan(1)

  const harPath = path.join(os.tmpdir(), 'autocannon-test.har')
  fs.writeFileSync(harPath, 'not valid JSON content')

  const child = childProcess.spawn(process.execPath, [path.join(__dirname, '..'), '-a', 4, '-c', 1, '--har', harPath, 'http://localhost'], {
    cwd: __dirname,
    env: process.env,
    stdio: ['ignore', 'pipe', 'pipe'],
    detached: false
  })

  t.teardown(() => {
    try {
      child.kill()
    } catch {}
  })

  const lines = []
  child
    .stderr
    .pipe(split())
    .on('data', line => lines.push(line))
    .on('end', () => {
      const output = lines.join('\n')
      t.ok(output.includes('Error: Failed to load HAR file content: Unexpected token'), `Unexpected output:\n${output}`)
      t.end()
    })
})

test('should write warning about unused HAR requests', (t) => {
  t.plan(1)

  const server = helper.startServer()
  const url = `http://localhost:${server.address().port}`
  const harPath = path.join(os.tmpdir(), 'autocannon-test.har')
  const har = helper.customizeHAR('./fixtures/multi-domains.json', 'https://httpbin.org', url)
  fs.writeFileSync(harPath, JSON.stringify(har))

  const child = childProcess.spawn(process.execPath, [path.join(__dirname, '..'), '-a', 4, '-c', 1, '--har', harPath, url], {
    cwd: __dirname,
    env: process.env,
    stdio: ['ignore', 'pipe', 'pipe'],
    detached: false
  })

  t.teardown(() => {
    try {
      child.kill()
    } catch {}
  })

  const lines = []
  child
    .stderr
    .pipe(split())
    .on('data', line => lines.push(line))
    .on('end', () => {
      const output = lines.join('\n')
      t.ok(output.includes(`Warning: skipping requests to 'https://github.com' as the target is ${url}`), `Unexpected output:\n${output}`)
      t.end()
    })
})

test('run with workers', { skip: !hasWorkerSupport }, (t) => {
  const lines = [
    /Running 1s test @ .*$/,
    /10 connections.*$/,
    /4 workers.*$/,
    /$/,
    /.*/,
    /$/,
    /Stat.*2\.5%.*50%.*97\.5%.*99%.*Avg.*Stdev.*Max.*$/,
    /.*/,
    /Latency.*$/,
    /$/,
    /.*/,
    /Stat.*1%.*2\.5%.*50%.*97\.5%.*Avg.*Stdev.*Min.*$/,
    /.*/,
    /Req\/Sec.*$/,
    /.*/,
    /Bytes\/Sec.*$/,
    /.*/,
    /$/,
    /Req\/Bytes counts sampled once per second.*$/,
    /.*$/,
    /$/,
    /.* requests in ([0-9]|\.)+s, .* read/
  ]

  t.plan(lines.length * 2)

  const server = helper.startServer()
  const url = 'http://localhost:' + server.address().port

  const child = childProcess.spawn(process.execPath, [path.join(__dirname, '..'), '-d', '1', url, '--workers', '4'], {
    cwd: __dirname,
    env: process.env,
    stdio: ['ignore', 'pipe', 'pipe'],
    detached: false
  })

  t.teardown(() => {
    try {
      child.kill()
    } catch {}
  })

  child
    .stderr
    .pipe(split())
    .on('data', (line) => {
      const regexp = lines.shift()
      t.ok(regexp, 'we are expecting this line')
      t.ok(regexp.test(line), 'line matches ' + regexp)
    })
    .on('end', t.end)
})

test('should run handle PUT bodies', (t) => {
  t.test('"number" bodies work', t => {
    t.plan(2)

    const server = helper.startServer()
    const url = 'http://localhost:' + server.address().port

    const cmd = [
      path.join(__dirname, '..'),
      '-d', '1',
      '-m', 'PUT',
      '-H', 'content-type="application/x-www-form-urlencoded"',
      '-b', '1',
      url
    ]
    const child = childProcess.spawn(process.execPath, cmd, {
      cwd: __dirname,
      env: process.env,
      stdio: ['ignore', 'pipe', 'pipe'],
      detached: false
    })

    t.teardown(() => {
      try {
        child.kill()
      } catch {}
    })

    const outputLines = []
    child
      .stderr
      .pipe(split())
      .on('data', (line) => {
        outputLines.push(line)
      })
      .on('end', () => {
        t.equal(
          outputLines.some(l => l === 'body must be either a string or a buffer'),
          false
        )
        t.equal(
          /.* requests in ([0-9]|\.)+s, .* read/.test(outputLines.pop()),
          true
        )
        t.end()
      })
  })

  t.test('"string" bodies work', t => {
    t.plan(2)

    const server = helper.startServer()
    const url = 'http://localhost:' + server.address().port

    const cmd = [
      path.join(__dirname, '..'),
      '-d', '1',
      '-m', 'PUT',
      '-H', 'content-type="application/x-www-form-urlencoded"',
      '-b', '"1"',
      url
    ]
    const child = childProcess.spawn(process.execPath, cmd, {
      cwd: __dirname,
      env: process.env,
      stdio: ['ignore', 'pipe', 'pipe'],
      detached: false
    })

    t.teardown(() => {
      try {
        child.kill()
      } catch {}
    })

    const outputLines = []
    child
      .stderr
      .pipe(split())
      .on('data', (line) => {
        outputLines.push(line)
      })
      .on('end', () => {
        t.equal(
          outputLines.some(l => l === 'body must be either a string or a buffer'),
          false
        )
        t.equal(
          /.* requests in ([0-9]|\.)+s, .* read/.test(outputLines.pop()),
          true
        )
        t.end()
      })
  })

  t.end()
})


================================================
FILE: test/debug.test.js
================================================
'use strict'

const test = require('tap').test
const Autocannon = require('../autocannon')

test('debug works', (t) => {
  t.plan(5)

  const args = Autocannon.parseArguments([
    '-H', 'X-Http-Method-Override=GET',
    '-m', 'POST',
    '-b', 'the body',
    '--debug',
    'http://localhost/foo/bar'
  ])

  t.equal(args.url, 'http://localhost/foo/bar')
  t.strictSame(args.headers, { 'X-Http-Method-Override': 'GET' })
  t.equal(args.method, 'POST')
  t.equal(args.body, 'the body')
  t.equal(args.debug, true)
})


================================================
FILE: test/envPort.test.js
================================================
'use strict'

const why = require('why-is-node-running')
const t = require('tap')
const split = require('split2')
const path = require('path')
const childProcess = require('child_process')
const helper = require('./helper')

setInterval(function () {
  console.log(why())
}, 30000).unref()

const lines = [
  /Running 1s test @ .*$/,
  /10 connections.*$/,
  /$/,
  /.*/,
  /$/,
  /Stat.*2\.5%.*50%.*97\.5%.*99%.*Avg.*Stdev.*Max.*$/,
  /.*/,
  /Latency.*$/,
  /$/,
  /.*/,
  /Stat.*1%.*2\.5%.*50%.*97\.5%.*Avg.*Stdev.*Min.*$/,
  /.*/,
  /Req\/Sec.*$/,
  /$/,
  /Bytes\/Sec.*$/,
  /.*/,
  /$/,
  /Req\/Bytes counts sampled once per second.*$/,
  /# of samples: 10*$/,
  /$/,
  /.* requests in ([0-9]|\.)+s, .* read/
]

t.plan(lines.length * 2 + 2)

const server = helper.startServer()
const port = server.address().port
const url = '/path' // no hostname

const child = childProcess.spawn(process.execPath, [path.join(__dirname, '..'), '-d', '1', url], {
  cwd: __dirname,
  env: Object.assign({}, process.env, {
    PORT: port
  }),
  stdio: ['ignore', 'pipe', 'pipe'],
  detached: false
})

t.teardown(() => {
  try {
    child.kill()
  } catch {}
})

child
  .stderr
  .pipe(split())
  .on('data', (line) => {
    const regexp = lines.shift()
    t.ok(regexp, 'we are expecting this line')
    t.ok(regexp.test(line), 'line matches ' + regexp)
  })
  .on('end', () => {
    t.ok(server.autocannonConnects > 0, 'targeted the correct port')
  })

const noPortChild = childProcess.spawn(process.execPath, [path.join(__dirname, '..'), url], {
  cwd: __dirname,
  env: process.env,
  stdio: ['ignore', 'pipe', 'pipe'],
  detached: false
})

noPortChild.on('exit', (code) => {
  t.equal(code, 1, 'should exit with error when a hostless URL is passed and no PORT var is available')
})


================================================
FILE: test/fixtures/example-result.json
================================================
{
    "title": "example result",
    "url": "https://httpbin.org/get",
    "requests": {
      "average": 250,
      "mean": 250,
      "stddev": 117,
      "min": 133,
      "max": 367,
      "total": 500,
      "p0_001": 133,
      "p0_01": 133,
      "p0_1": 133,
      "p1": 133,
      "p2_5": 133,
      "p10": 133,
      "p25": 133,
      "p50": 133,
      "p75": 367,
      "p90": 367,
      "p97_5": 367,
      "p99": 367,
      "p99_9": 367,
      "p99_99": 367,
      "p99_999": 367,
      "sent": 500
    },
    "latency": {
      "average": 100.1,
      "mean": 100.1,
      "stddev": 84.74,
      "min": 47,
      "max": 424,
      "p0_001": 47,
      "p0_01": 47,
      "p0_1": 47,
      "p1": 53,
      "p2_5": 55,
      "p10": 58,
      "p25": 59,
      "p50": 67,
      "p75": 107,
      "p90": 126,
      "p97_5": 378,
      "p99": 386,
      "p99_9": 424,
      "p99_99": 424,
      "p99_999": 424,
      "totalCount": 500
    },
    "throughput": {
      "average": 52468,
      "mean": 52468,
      "stddev": 24556,
      "min": 27915,
      "max": 77030,
      "total": 104945,
      "p0_001": 27919,
      "p0_01": 27919,
      "p0_1": 27919,
      "p1": 27919,
      "p2_5": 27919,
      "p10": 27919,
      "p25": 27919,
      "p50": 27919,
      "p75": 77055,
      "p90": 77055,
      "p97_5": 77055,
      "p99": 77055,
      "p99_9": 77055,
      "p99_99": 77055,
      "p99_999": 77055
    },
    "errors": 0,
    "timeouts": 0,
    "mismatches": 0,
    "duration": 2.06,
	"sampleInt": 1000,
	"samples": 10,
    "start": "2020-11-06T09:38:31.027Z",
    "finish": "2020-11-06T09:38:33.089Z",
    "connections": 40,
    "pipelining": 1,
    "non2xx": 0,
    "resets": 0,
    "1xx": 0,
    "2xx": 500,
    "3xx": 0,
    "4xx": 0,
    "5xx": 0,
    "statusCodeStats": {
      "200": { "count": "500" }, 
      "302": { "count": "0" },
      "401": { "count": "0" },
      "403": { "count": "0" }
    }
  }
  


================================================
FILE: test/fixtures/httpbin-get.json
================================================
{
  "log": {
    "version": "1.2",
    "creator": {
      "name": "Firefox",
      "version": "80.0.1"
    },
    "browser": {
      "name": "Firefox",
      "version": "80.0.1"
    },
    "pages": [
      {
        "startedDateTime": "2020-09-28T20:47:18.735+02:00",
        "id": "page_1",
        "title": "https://httpbin.org/post",
        "pageTimings": {
          "onContentLoad": 170,
          "onLoad": 187
        }
      }
    ],
    "entries": [
      {
        "pageref": "page_2",
        "startedDateTime": "2020-09-28T22:03:15.885+02:00",
        "request": {
          "bodySize": 0,
          "method": "GET",
          "url": "https://httpbin.org/get",
          "httpVersion": "HTTP/2",
          "headers": [
            {
              "name": "Host",
              "value": "httpbin.org"
            },
            {
              "name": "User-Agent",
              "value": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0"
            },
            {
              "name": "Accept",
              "value": "*/*"
            },
            {
              "name": "Accept-Language",
              "value": "fr,en;q=0.5"
            },
            {
              "name": "Accept-Encoding",
              "value": "gzip, deflate, br"
            },
            {
              "name": "Referer",
              "value": "https://httpbin.org/"
            },
            {
              "name": "DNT",
              "value": "1"
            },
            {
              "name": "Connection",
              "value": "keep-alive"
            }
          ],
          "cookies": [],
          "queryString": [],
          "headersSize": 272
        },
        "response": {
          "status": 200,
          "statusText": "OK",
          "httpVersion": "HTTP/2",
          "headers": [
            {
              "name": "date",
              "value": "Mon, 28 Sep 2020 20:03:16 GMT"
            },
            {
              "name": "content-type",
              "value": "application/json"
            },
            {
              "name": "content-length",
              "value": "461"
            },
            {
              "name": "server",
              "value": "gunicorn/19.9.0"
            },
            {
              "name": "access-control-allow-origin",
              "value": "*"
            },
            {
              "name": "access-control-allow-credentials",
              "value": "true"
            },
            {
              "name": "X-Firefox-Spdy",
              "value": "h2"
            }
          ],
          "cookies": [],
          "content": {
            "mimeType": "application/json",
            "size": 461,
            "text": "{\n  \"args\": {}, \n  \"headers\": {\n    \"Accept\": \"*/*\", \n    \"Accept-Encoding\": \"gzip, deflate, br\", \n    \"Accept-Language\": \"fr,en;q=0.5\", \n    \"Dnt\": \"1\", \n    \"Host\": \"httpbin.org\", \n    \"Referer\": \"https://httpbin.org/\", \n    \"User-Agent\": \"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0\", \n    \"X-Amzn-Trace-Id\": \"Root=1-5f724184-c2b2dc0aa856f9d04dac5d35\"\n  }, \n  \"origin\": \"78.192.173.27\", \n  \"url\": \"https://httpbin.org/get\"\n}\n"
          },
          "redirectURL": "",
          "headersSize": 224,
          "bodySize": 685
        },
        "cache": {},
        "timings": {
          "blocked": 184,
          "dns": 8,
          "connect": 85,
          "ssl": 88,
          "send": 0,
          "wait": 86,
          "receive": 0
        },
        "time": 451,
        "_securityState": "secure",
        "serverIPAddress": "35.170.21.246",
        "connection": "443"
      },
      {
        "pageref": "page_1",
        "startedDateTime": "2020-09-28T21:46:29.772+02:00",
        "request": {
          "bodySize": 0,
          "method": "GET",
          "url": "https://httpbin.org/get?from=10&size=20&sort=+name",
          "httpVersion": "HTTP/2",
          "headers": [
            {
              "name": "Host",
              "value": "httpbin.org"
            },
            {
              "name": "User-Agent",
              "value": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0"
            },
            {
              "name": "Accept",
              "value": "*/*"
            },
            {
              "name": "Accept-Language",
              "value": "fr,en;q=0.5"
            },
            {
              "name": "Accept-Encoding",
              "value": "gzip, deflate, br"
            },
            {
              "name": "Referer",
              "value": "https://httpbin.org/"
            },
            {
              "name": "DNT",
              "value": "1"
            },
            {
              "name": "Connection",
              "value": "keep-alive"
            },
            {
              "name": "TE",
              "value": "Trailers"
            }
          ],
          "cookies": [],
          "queryString": [
            {
              "name": "from",
              "value": "10"
            },
            {
              "name": "size",
              "value": "20"
            },
            {
              "name": "sort",
              "value": " name"
            }
          ],
          "headersSize": 299
        },
        "response": {
          "status": 200,
          "statusText": "OK",
          "httpVersion": "HTTP/2",
          "headers": [
            {
              "name": "date",
              "value": "Mon, 28 Sep 2020 19:46:29 GMT"
            },
            {
              "name": "content-type",
              "value": "application/json"
            },
            {
              "name": "content-length",
              "value": "549"
            },
            {
              "name": "server",
              "value": "gunicorn/19.9.0"
            },
            {
              "name": "access-control-allow-origin",
              "value": "*"
            },
            {
              "name": "access-control-allow-credentials",
              "value": "true"
            },
            {
              "name": "X-Firefox-Spdy",
              "value": "h2"
            }
          ],
          "cookies": [],
          "content": {
            "mimeType": "application/json",
            "size": 549,
            "text": "{\n  \"args\": {\n    \"from\": \"10\", \n    \"size\": \"20\", \n    \"sort\": \" name\"\n  }, \n  \"headers\": {\n    \"Accept\": \"*/*\", \n    \"Accept-Encoding\": \"gzip, deflate, br\", \n    \"Accept-Language\": \"fr,en;q=0.5\", \n    \"Dnt\": \"1\", \n    \"Host\": \"httpbin.org\", \n    \"Referer\": \"https://httpbin.org/\", \n    \"User-Agent\": \"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0\", \n    \"X-Amzn-Trace-Id\": \"Root=1-5f723d95-9675a1b77254a636c2f09fa3\"\n  }, \n  \"origin\": \"78.192.173.27\", \n  \"url\": \"https://httpbin.org/get?from=10&size=20&sort=+name\"\n}\n"
          },
          "redirectURL": "",
          "headersSize": 224,
          "bodySize": 773
        },
        "cache": {},
        "timings": {
          "blocked": 0,
          "dns": 0,
          "connect": 0,
          "ssl": 0,
          "send": 0,
          "wait": 168,
          "receive": 0
        },
        "time": 168,
        "_securityState": "secure",
        "serverIPAddress": "35.170.21.246",
        "connection": "443"
      }
    ]
  }
}

================================================
FILE: test/fixtures/httpbin-post.json
================================================
{
  "log": {
    "version": "1.2",
    "creator": {
      "name": "Firefox",
      "version": "80.0.1"
    },
    "browser": {
      "name": "Firefox",
      "version": "80.0.1"
    },
    "pages": [
      {
        "startedDateTime": "2020-09-28T21:41:16.913+02:00",
        "id": "page_1",
        "title": "httpbin.org",
        "pageTimings": {
          "onContentLoad": -100471,
          "onLoad": -100459
        }
      }
    ],
    "entries": [
      {
        "pageref": "page_1",
        "startedDateTime": "2020-09-28T21:41:16.913+02:00",
        "request": {
          "bodySize": 362,
          "method": "POST",
          "url": "https://httpbin.org/post",
          "httpVersion": "HTTP/2",
          "headers": [
            {
              "name": "Host",
              "value": "httpbin.org"
            },
            {
              "name": "User-Agent",
              "value": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0"
            },
            {
              "name": "Accept",
              "value": "*/*"
            },
            {
              "name": "Accept-Language",
              "value": "fr,en;q=0.5"
            },
            {
              "name": "Accept-Encoding",
              "value": "gzip, deflate, br"
            },
            {
              "name": "Referer",
              "value": "https://httpbin.org/"
            },
            {
              "name": "Content-Type",
              "value": "multipart/form-data; boundary=---------------------------31420230025845772252453285324"
            },
            {
              "name": "Origin",
              "value": "https://httpbin.org"
            },
            {
              "name": "Content-Length",
              "value": "362"
            },
            {
              "name": "DNT",
              "value": "1"
            },
            {
              "name": "Connection",
              "value": "keep-alive"
            },
            {
              "name": "TE",
              "value": "Trailers"
            }
          ],
          "cookies": [],
          "queryString": [],
          "headersSize": 426,
          "postData": {
            "mimeType": "multipart/form-data; boundary=---------------------------31420230025845772252453285324",
            "params": [],
            "text": "-----------------------------31420230025845772252453285324\r\nContent-Disposition: form-data; name=\"text\"\r\n\r\na text value\r\n-----------------------------31420230025845772252453285324\r\nContent-Disposition: form-data; name=\"file\"; filename=\"blob\"\r\nContent-Type: application/octet-stream\r\n\r\nHello World!\n\r\n-----------------------------31420230025845772252453285324--\r\n"
          }
        },
        "response": {
          "status": 200,
          "statusText": "OK",
          "httpVersion": "HTTP/2",
          "headers": [
            {
              "name": "date",
              "value": "Mon, 28 Sep 2020 19:41:16 GMT"
            },
            {
              "name": "content-type",
              "value": "application/json"
            },
            {
              "name": "content-length",
              "value": "766"
            },
            {
              "name": "server",
              "value": "gunicorn/19.9.0"
            },
            {
              "name": "access-control-allow-origin",
              "value": "https://httpbin.org"
            },
            {
              "name": "access-control-allow-credentials",
              "value": "true"
            },
            {
              "name": "X-Firefox-Spdy",
              "value": "h2"
            }
          ],
          "cookies": [],
          "content": {
            "mimeType": "application/json",
            "size": 766,
            "text": "{\n  \"args\": {}, \n  \"data\": \"\", \n  \"files\": {\n    \"file\": \"Hello World!\\n\"\n  }, \n  \"form\": {\n    \"text\": \"a text value\"\n  }, \n  \"headers\": {\n    \"Accept\": \"*/*\", \n    \"Accept-Encoding\": \"gzip, deflate, br\", \n    \"Accept-Language\": \"fr,en;q=0.5\", \n    \"Content-Length\": \"362\", \n    \"Content-Type\": \"multipart/form-data; boundary=---------------------------31420230025845772252453285324\", \n    \"Dnt\": \"1\", \n    \"Host\": \"httpbin.org\", \n    \"Origin\": \"https://httpbin.org\", \n    \"Referer\": \"https://httpbin.org/\", \n    \"User-Agent\": \"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0\", \n    \"X-Amzn-Trace-Id\": \"Root=1-5f723c5c-b0e8a0609820985731015e80\"\n  }, \n  \"json\": null, \n  \"origin\": \"78.192.173.27\", \n  \"url\": \"https://httpbin.org/post\"\n}\n"
          },
          "redirectURL": "",
          "headersSize": 242,
          "bodySize": 1008
        },
        "cache": {},
        "timings": {
          "blocked": 0,
          "dns": 0,
          "connect": 0,
          "ssl": 0,
          "send": 0,
          "wait": 89,
          "receive": 0
        },
        "time": 89,
        "_securityState": "secure",
        "serverIPAddress": "35.170.21.246",
        "connection": "443"
      },
      {
        "pageref": "page_1",
        "startedDateTime": "2020-09-28T21:43:55.877+02:00",
        "request": {
          "bodySize": 27,
          "method": "POST",
          "url": "https://httpbin.org/post",
          "httpVersion": "HTTP/2",
          "headers": [
            {
              "name": "Host",
              "value": "httpbin.org"
            },
            {
              "name": "User-Agent",
              "value": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0"
            },
            {
              "name": "Accept",
              "value": "*/*"
            },
            {
              "name": "Accept-Language",
              "value": "fr,en;q=0.5"
            },
            {
              "name": "Accept-Encoding",
              "value": "gzip, deflate, br"
            },
            {
              "name": "Referer",
              "value": "https://httpbin.org/"
            },
            {
              "name": "Content-Type",
              "value": "application/x-www-form-urlencoded"
            },
            {
              "name": "Origin",
              "value": "https://httpbin.org"
            },
            {
              "name": "Content-Length",
              "value": "27"
            },
            {
              "name": "DNT",
              "value": "1"
            },
            {
              "name": "Connection",
              "value": "keep-alive"
            },
            {
              "name": "TE",
              "value": "Trailers"
            }
          ],
          "cookies": [],
          "queryString": [],
          "headersSize": 372,
          "postData": {
            "mimeType": "application/x-www-form-urlencoded",
            "params": [
              {
                "name": "text",
                "value": "a text value"
              },
              {
                "name": "number",
                "value": "10"
              }
            ],
            "text": "text=a+text+value&number=10"
          }
        },
        "response": {
          "status": 200,
          "statusText": "OK",
          "httpVersion": "HTTP/2",
          "headers": [
            {
              "name": "date",
              "value": "Mon, 28 Sep 2020 19:43:55 GMT"
            },
            {
              "name": "content-type",
              "value": "application/json"
            },
            {
              "name": "content-length",
              "value": "701"
            },
            {
              "name": "server",
              "value": "gunicorn/19.9.0"
            },
            {
              "name": "access-control-allow-origin",
              "value": "https://httpbin.org"
            },
            {
              "name": "access-control-allow-credentials",
              "value": "true"
            },
            {
              "name": "X-Firefox-Spdy",
              "value": "h2"
            }
          ],
          "cookies": [],
          "content": {
            "mimeType": "application/json",
            "size": 701,
            "text": "{\n  \"args\": {}, \n  \"data\": \"\", \n  \"files\": {}, \n  \"form\": {\n    \"number\": \"10\", \n    \"text\": \"a text value\"\n  }, \n  \"headers\": {\n    \"Accept\": \"*/*\", \n    \"Accept-Encoding\": \"gzip, deflate, br\", \n    \"Accept-Language\": \"fr,en;q=0.5\", \n    \"Content-Length\": \"27\", \n    \"Content-Type\": \"application/x-www-form-urlencoded\", \n    \"Dnt\": \"1\", \n    \"Host\": \"httpbin.org\", \n    \"Origin\": \"https://httpbin.org\", \n    \"Referer\": \"https://httpbin.org/\", \n    \"User-Agent\": \"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0\", \n    \"X-Amzn-Trace-Id\": \"Root=1-5f723cfb-880669c8b0b3a9628bea7db3\"\n  }, \n  \"json\": null, \n  \"origin\": \"78.192.173.27\", \n  \"url\": \"https://httpbin.org/post\"\n}\n"
          },
          "redirectURL": "",
          "headersSize": 242,
          "bodySize": 943
        },
        "cache": {},
        "timings": {
          "blocked": 0,
          "dns": 1,
          "connect": 0,
          "ssl": 0,
          "send": 0,
          "wait": 91,
          "receive": 0
        },
        "time": 92,
        "_securityState": "secure",
        "serverIPAddress": "35.170.21.246",
        "connection": "443"
      }
    ]
  }
}

================================================
FILE: test/fixtures/httpbin-simple-get.json
================================================
{
  "log": {
    "version": "1.2",
    "creator": {
      "name": "Firefox",
      "version": "80.0.1"
    },
    "browser": {
      "name": "Firefox",
      "version": "80.0.1"
    },
    "entries": [
      {
        "startedDateTime": "2020-09-28T22:03:15.885+02:00",
        "request": {
          "bodySize": 0,
          "method": "GET",
          "url": "https://httpbin.org/get",
          "httpVersion": "HTTP/2",
          "headers": [
            {
              "name": "Host",
              "value": "httpbin.org"
            },
            {
              "name": "User-Agent",
              "value": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0"
            },
            {
              "name": "Accept",
              "value": "*/*"
            },
            {
              "name": "Accept-Language",
              "value": "fr,en;q=0.5"
            },
            {
              "name": "Accept-Encoding",
              "value": "gzip, deflate, br"
            },
            {
              "name": "Referer",
              "value": "https://httpbin.org/"
            },
            {
              "name": "DNT",
              "value": "1"
            },
            {
              "name": "Connection",
              "value": "keep-alive"
            }
          ],
          "cookies": [],
          "queryString": [],
          "headersSize": 272
        },
        "response": {
          "status": 200,
          "statusText": "OK",
          "httpVersion": "HTTP/2",
          "headers": [
            {
              "name": "date",
              "value": "Mon, 28 Sep 2020 20:03:16 GMT"
            },
            {
              "name": "content-type",
              "value": "application/json"
            },
            {
              "name": "content-length",
              "value": "461"
            },
            {
              "name": "server",
              "value": "gunicorn/19.9.0"
            },
            {
              "name": "access-control-allow-origin",
              "value": "*"
            },
            {
              "name": "access-control-allow-credentials",
              "value": "true"
            },
            {
              "name": "X-Firefox-Spdy",
              "value": "h2"
            }
          ],
          "cookies": [],
          "content": {
            "mimeType": "application/json",
            "size": 461,
            "text": "{\n  \"args\": {}, \n  \"headers\": {\n    \"Accept\": \"*/*\", \n    \"Accept-Encoding\": \"gzip, deflate, br\", \n    \"Accept-Language\": \"fr,en;q=0.5\", \n    \"Dnt\": \"1\", \n    \"Host\": \"httpbin.org\", \n    \"Referer\": \"https://httpbin.org/\", \n    \"User-Agent\": \"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0\", \n    \"X-Amzn-Trace-Id\": \"Root=1-5f724184-c2b2dc0aa856f9d04dac5d35\"\n  }, \n  \"origin\": \"78.192.173.27\", \n  \"url\": \"https://httpbin.org/get\"\n}\n"
          },
          "redirectURL": "",
          "headersSize": 224,
          "bodySize": 685
        },
        "cache": {},
        "timings": {
          "blocked": 184,
          "dns": 8,
          "connect": 85,
          "ssl": 88,
          "send": 0,
          "wait": 86,
          "receive": 0
        },
        "time": 451,
        "_securityState": "secure",
        "serverIPAddress": "35.170.21.246",
        "connection": "443"
      }
    ]
  }
}

================================================
FILE: test/fixtures/multi-domains.json
================================================
{
  "log": {
    "version": "1.2",
    "creator": {
      "name": "Firefox",
      "version": "80.0.1"
    },
    "browser": {
      "name": "Firefox",
      "version": "80.0.1"
    },
    "pages": [
      {
        "startedDateTime": "2020-09-28T21:41:16.913+02:00",
        "id": "page_1",
        "title": "httpbin.org",
        "pageTimings": {
          "onContentLoad": -100471,
          "onLoad": -100459
        }
      }
    ],
    "entries": [
      {
        "pageref": "page_1",
        "startedDateTime": "2020-09-28T21:41:16.913+02:00",
        "request": {
          "bodySize": 362,
          "method": "POST",
          "url": "https://httpbin.org/post",
          "httpVersion": "HTTP/2",
          "headers": [
            {
              "name": "Host",
              "value": "httpbin.org"
            },
            {
              "name": "User-Agent",
              "value": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0"
            },
            {
              "name": "Accept",
              "value": "*/*"
            },
            {
              "name": "Accept-Language",
              "value": "fr,en;q=0.5"
            },
            {
              "name": "Accept-Encoding",
              "value": "gzip, deflate, br"
            },
            {
              "name": "Referer",
              "value": "https://httpbin.org/"
            },
            {
              "name": "Content-Type",
              "value": "multipart/form-data; boundary=---------------------------31420230025845772252453285324"
            },
            {
              "name": "Origin",
              "value": "https://httpbin.org"
            },
            {
              "name": "Content-Length",
              "value": "362"
            },
            {
              "name": "DNT",
              "value": "1"
            },
            {
              "name": "Connection",
              "value": "keep-alive"
            },
            {
              "name": "TE",
              "value": "Trailers"
            }
          ],
          "cookies": [],
          "queryString": [],
          "headersSize": 426,
          "postData": {
            "mimeType": "multipart/form-data; boundary=---------------------------31420230025845772252453285324",
            "params": [],
            "text": "-----------------------------31420230025845772252453285324\r\nContent-Disposition: form-data; name=\"text\"\r\n\r\na text value\r\n-----------------------------31420230025845772252453285324\r\nContent-Disposition: form-data; name=\"file\"; filename=\"blob\"\r\nContent-Type: application/octet-stream\r\n\r\nHello World!\n\r\n-----------------------------31420230025845772252453285324--\r\n"
          }
        },
        "response": {
          "status": 200,
          "statusText": "OK",
          "httpVersion": "HTTP/2",
          "headers": [
            {
              "name": "date",
              "value": "Mon, 28 Sep 2020 19:41:16 GMT"
            },
            {
              "name": "content-type",
              "value": "application/json"
            },
            {
              "name": "content-length",
              "value": "766"
            },
            {
              "name": "server",
              "value": "gunicorn/19.9.0"
            },
            {
              "name": "access-control-allow-origin",
              "value": "https://httpbin.org"
            },
            {
              "name": "access-control-allow-credentials",
              "value": "true"
            },
            {
              "name": "X-Firefox-Spdy",
              "value": "h2"
            }
          ],
          "cookies": [],
          "content": {
            "mimeType": "application/json",
            "size": 766,
            "text": "{\n  \"args\": {}, \n  \"data\": \"\", \n  \"files\": {\n    \"file\": \"Hello World!\\n\"\n  }, \n  \"form\": {\n    \"text\": \"a text value\"\n  }, \n  \"headers\": {\n    \"Accept\": \"*/*\", \n    \"Accept-Encoding\": \"gzip, deflate, br\", \n    \"Accept-Language\": \"fr,en;q=0.5\", \n    \"Content-Length\": \"362\", \n    \"Content-Type\": \"multipart/form-data; boundary=---------------------------31420230025845772252453285324\", \n    \"Dnt\": \"1\", \n    \"Host\": \"httpbin.org\", \n    \"Origin\": \"https://httpbin.org\", \n    \"Referer\": \"https://httpbin.org/\", \n    \"User-Agent\": \"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0\", \n    \"X-Amzn-Trace-Id\": \"Root=1-5f723c5c-b0e8a0609820985731015e80\"\n  }, \n  \"json\": null, \n  \"origin\": \"78.192.173.27\", \n  \"url\": \"https://httpbin.org/post\"\n}\n"
          },
          "redirectURL": "",
          "headersSize": 242,
          "bodySize": 1008
        },
        "cache": {},
        "timings": {
          "blocked": 0,
          "dns": 0,
          "connect": 0,
          "ssl": 0,
          "send": 0,
          "wait": 89,
          "receive": 0
        },
        "time": 89,
        "_securityState": "secure",
        "serverIPAddress": "35.170.21.246",
        "connection": "443"
      },
      {
        "pageref": "page_1",
        "startedDateTime": "2020-09-28T21:43:55.877+02:00",
        "request": {
          "bodySize": 27,
          "method": "POST",
          "url": "https://github.com",
          "httpVersion": "HTTP/2",
          "headers": [
            {
              "name": "Host",
              "value": "github.com"
            },
            {
              "name": "User-Agent",
              "value": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0"
            },
            {
              "name": "Accept",
              "value": "*/*"
            },
            {
              "name": "Accept-Language",
              "value": "fr,en;q=0.5"
            },
            {
              "name": "Accept-Encoding",
              "value": "gzip, deflate, br"
            },
            {
              "name": "Referer",
              "value": "https://github.com/"
            },
            {
              "name": "Content-Type",
              "value": "application/x-www-form-urlencoded"
            },
            {
              "name": "Origin",
              "value": "https://github.com"
            },
            {
              "name": "Content-Length",
              "value": "27"
            },
            {
              "name": "DNT",
              "value": "1"
            },
            {
              "name": "Connection",
              "value": "keep-alive"
            },
            {
              "name": "TE",
              "value": "Trailers"
            }
          ],
          "cookies": [],
          "queryString": [],
          "headersSize": 372,
          "postData": {
            "mimeType": "application/x-www-form-urlencoded",
            "params": [
              {
                "name": "text",
                "value": "a text value"
              },
              {
                "name": "number",
                "value": "10"
              }
            ],
            "text": "text=a+text+value&number=10"
          }
        },
        "response": {
          "status": 200,
          "statusText": "OK",
          "httpVersion": "HTTP/2",
          "headers": [
            {
              "name": "date",
              "value": "Mon, 28 Sep 2020 19:43:55 GMT"
            },
            {
              "name": "content-type",
              "value": "application/json"
            },
            {
              "name": "content-length",
              "value": "701"
            },
            {
              "name": "server",
              "value": "gunicorn/19.9.0"
            },
            {
              "name": "access-control-allow-origin",
              "value": "https://httpbin.org"
            },
            {
              "name": "access-control-allow-credentials",
              "value": "true"
            },
            {
              "name": "X-Firefox-Spdy",
              "value": "h2"
            }
          ],
          "cookies": [],
          "content": {
            "mimeType": "application/json",
            "size": 701,
            "text": "{\n  \"args\": {}, \n  \"data\": \"\", \n  \"files\": {}, \n  \"form\": {\n    \"number\": \"10\", \n    \"text\": \"a text value\"\n  }, \n  \"headers\": {\n    \"Accept\": \"*/*\", \n    \"Accept-Encoding\": \"gzip, deflate, br\", \n    \"Accept-Language\": \"fr,en;q=0.5\", \n    \"Content-Length\": \"27\", \n    \"Content-Type\": \"application/x-www-form-urlencoded\", \n    \"Dnt\": \"1\", \n    \"Host\": \"httpbin.org\", \n    \"Origin\": \"https://httpbin.org\", \n    \"Referer\": \"https://httpbin.org/\", \n    \"User-Agent\": \"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0\", \n    \"X-Amzn-Trace-Id\": \"Root=1-5f723cfb-880669c8b0b3a9628bea7db3\"\n  }, \n  \"json\": null, \n  \"origin\": \"78.192.173.27\", \n  \"url\": \"https://httpbin.org/post\"\n}\n"
          },
          "redirectURL": "",
          "headersSize": 242,
          "bodySize": 943
        },
        "cache": {},
        "timings": {
          "blocked": 0,
          "dns": 1,
          "connect": 0,
          "ssl": 0,
          "send": 0,
          "wait": 91,
          "receive": 0
        },
        "time": 92,
        "_securityState": "secure",
        "serverIPAddress": "35.170.21.246",
        "connection": "443"
      },
      {
        "pageref": "page_1",
        "startedDateTime": "2020-09-28T21:46:29.772+02:00",
        "request": {
          "bodySize": 0,
          "method": "GET",
          "url": "https://httpbin.org/get?from=10&size=20&sort=+name",
          "httpVersion": "HTTP/2",
          "headers": [
            {
              "name": "Host",
              "value": "httpbin.org"
            },
            {
              "name": "User-Agent",
              "value": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0"
            },
            {
              "name": "Accept",
              "value": "*/*"
            },
            {
              "name": "Accept-Language",
              "value": "fr,en;q=0.5"
            },
            {
              "name": "Accept-Encoding",
              "value": "gzip, deflate, br"
            },
            {
              "name": "Referer",
              "value": "https://httpbin.org/"
            },
            {
              "name": "DNT",
              "value": "1"
            },
            {
              "name": "Connection",
              "value": "keep-alive"
            },
            {
              "name": "TE",
              "value": "Trailers"
            }
          ],
          "cookies": [],
          "queryString": [
            {
              "name": "from",
              "value": "10"
            },
            {
              "name": "size",
              "value": "20"
            },
            {
              "name": "sort",
              "value": " name"
            }
          ],
          "headersSize": 299
        },
        "response": {
          "status": 200,
          "statusText": "OK",
          "httpVersion": "HTTP/2",
          "headers": [
            {
              "name": "date",
              "value": "Mon, 28 Sep 2020 19:46:29 GMT"
            },
            {
              "name": "content-type",
              "value": "application/json"
            },
            {
              "name": "content-length",
              "value": "549"
            },
            {
              "name": "server",
              "value": "gunicorn/19.9.0"
            },
            {
              "name": "access-control-allow-origin",
              "value": "*"
            },
            {
              "name": "access-control-allow-credentials",
              "value": "true"
            },
            {
              "name": "X-Firefox-Spdy",
              "value": "h2"
            }
          ],
          "cookies": [],
          "content": {
            "mimeType": "application/json",
            "size": 549,
            "text": "{\n  \"args\": {\n    \"from\": \"10\", \n    \"size\": \"20\", \n    \"sort\": \" name\"\n  }, \n  \"headers\": {\n    \"Accept\": \"*/*\", \n    \"Accept-Encoding\": \"gzip, deflate, br\", \n    \"Accept-Language\": \"fr,en;q=0.5\", \n    \"Dnt\": \"1\", \n    \"Host\": \"httpbin.org\", \n    \"Referer\": \"https://httpbin.org/\", \n    \"User-Agent\": \"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0\", \n    \"X-Amzn-Trace-Id\": \"Root=1-5f723d95-9675a1b77254a636c2f09fa3\"\n  }, \n  \"origin\": \"78.192.173.27\", \n  \"url\": \"https://httpbin.org/get?from=10&size=20&sort=+name\"\n}\n"
          },
          "redirectURL": "",
          "headersSize": 224,
          "bodySize": 773
        },
        "cache": {},
        "timings": {
          "blocked": 0,
          "dns": 0,
          "connect": 0,
          "ssl": 0,
          "send": 0,
          "wait": 168,
          "receive": 0
        },
        "time": 168,
        "_securityState": "secure",
        "serverIPAddress": "35.170.21.246",
        "connection": "443"
      }
    ]
  }
}

================================================
FILE: test/forever.test.js
================================================
'use strict'

const test = require('tap').test
const initJob = require('../lib/init')
const helper = require('./helper')
const server = helper.startServer()

test('running with forever set to true and passing in a callback should cause an error to be returned in the callback', (t) => {
  t.plan(2)

  initJob({
    url: `http://localhost:${server.address().port}`,
    forever: true
  }, (err, res) => {
    t.ok(err, 'should be error when callback passed to run')
    t.notOk(res, 'should not exist')
    t.end()
  })
})

test('run forever should run until .stop() is called', (t) => {
  t.plan(3)
  let numRuns = 0

  const instance = initJob({
    url: `http://localhost:${server.address().port}`,
    duration: 0.5,
    forever: true
  })

  instance.on('done', (results) => {
    t.ok(results, 'should have gotten results')
    if (++numRuns === 2) {
      instance.stop()
      setTimeout(() => {
        t.ok(true, 'should have reached here without the callback being called again')
        t.end()
      }, 1000)
    }
  })
})


================================================
FILE: test/format.test.js
================================================
'use strict'

const test = require('tap').test
const format = require('../lib/format')

const pairs = {
  2: 2,
  '2k': 2000,
  '4k': 4042,
  '2300k': 2300000
}

Object.keys(pairs).forEach((expected) => {
  const original = pairs[expected]
  test(`format ${original} into ${expected}`, (t) => {
    t.equal(expected, format(original))
    t.end()
  })
})


================================================
FILE: test/helper.js
================================================
'use strict'

const http = require('http')
const https = require('https')
const tls = require('tls')
const fs = require('fs')
const path = require('path')
const BusBoy = require('busboy')

function startServer (opts) {
  opts = opts || {}

  if (!Array.isArray(opts.responses)) {
    opts.responses = []
  }

  const fixedStatusCode = opts.statusCode || 200
  const server = http.createServer(handle)
  server.autocannonConnects = 0
  server.autocannonRequests = 0

  server.on('connection', () => { server.autocannonConnects++ })

  server.listen(opts.socketPath || 0)

  function handle (req, res) {
    let { statusCode, body, headers } = opts.responses[server.autocannonRequests] || {}

    server.autocannonRequests++

    if (!statusCode) {
      statusCode = fixedStatusCode
    }

    if (!body) {
      body = opts.body || 'hello world'
    }

    res.statusCode = statusCode
    const reply = () => {
      const bodyToWrite = typeof body === 'function' ? body(req) : body

      if (headers) {
        res.writeHead(statusCode, headers)
      }
      res.end(statusCode < 200 ? undefined : bodyToWrite)
    }

    if (opts.delayResponse) {
      setTimeout(reply, opts.delayResponse)
    } else {
      reply()
    }
  }

  server.unref()

  return server
}

function startTrailerServer () {
  const server = http.createServer(handle)

  function handle (req, res) {
    res.writeHead(200, { 'Content-Type': 'text/plain', Trailer: 'Content-MD5' })
    res.write('hello ')
    res.addTrailers({ 'Content-MD5': '7895bf4b8828b55ceaf47747b4bca667' })
    res.end('world')
  }

  server.listen(0)

  server.unref()

  return server
}

// this server won't reply to requests
function startTimeoutServer () {
  const server = http.createServer(() => {})

  server.listen(0)
  server.unref()

  return server
}

// this server destroys the socket on connection, should result in ECONNRESET
function startSocketDestroyingServer () {
  const server = http.createServer(handle)

  function handle (req, res) {
    res.destroy()
    server.close()
  }

  server.listen(0)
  server.unref()

  return server
}

// this server won't reply to requests
function startHttpsServer (opts = {}) {
  const options = {
    key: fs.readFileSync(path.join(__dirname, '/key.pem')),
    cert: fs.readFileSync(path.join(__dirname, '/cert.pem')),
    passphrase: 'test'
  }

  const server = https.createServer(options, handle)

  server.listen(opts.socketPath || 0)

  function handle (req, res) {
    res.end('hello world')
  }

  server.unref()

  return server
}

// this server will echo the SNI Server Name and emailAddress from the client certificate in a HTTP header
function startTlsServer () {
  const key = fs.readFileSync(path.join(__dirname, '/key.pem'))
  const cert = fs.readFileSync(path.join(__dirname, '/cert.pem'))
  const passphrase = 'test'

  const options = {
    key,
    cert,
    passphrase,
    requestCert: true,
    rejectUnauthorized: false
  }

  const server = tls.createServer(options, handle)

  server.listen(0)

  function handle (socket) {
    const servername = socket.servername || ''
    const certificate = socket.getPeerCertificate()
    const email = (certificate && certificate.subject && certificate.subject.emailAddress) || ''
    socket.on('data', function (data) {
      // Assume this is a http get request and send back the servername in an otherwise empty reponse.
      socket.write('HTTP/1.1 200 OK\n')
      socket.write('X-servername: ' + servername + '\n')
      if (email) {
        socket.write('X-email: ' + email + '\n')
      }
      socket.write('Content-Length: 0\n\n')
      socket.setEncoding('utf8')
      socket.pipe(socket)
    })

    socket.on('error', noop)
  }

  server.unref()

  return server
}

function startMultipartServer (opts = {}, test = () => {}) {
  const server = http.createServer(handle)
  const allowed = ['POST', 'PUT']
  function handle (req, res) {
    if (allowed.includes(req.method)) {
      const bboy = new BusBoy({ headers: req.headers, ...opts })
      const fileData = []
      const payload = {}
      bboy.on('file', (fieldname, file, filename, encoding, mimetype) => {
        payload[fieldname] = {
          filename,
          encoding,
          mimetype
        }
        file.on('data', data => fileData.push(data))
      })
      bboy.on('field', (fieldname, val, fieldnameTruncated, valTruncated, encoding, mimetype) => {
        payload[fieldname] = val
      })
      bboy.on('finish', () => {
        res.statusCode = fileData.length ? 201 : 400
        res.write(JSON.stringify(payload))
        res.end()
        test(payload)
      })
      req.pipe(bboy)
    } else {
      res.statusCode = 404
      res.write(JSON.stringify({}))
      res.end()
    }
  }

  server.listen(0)
  server.unref()

  return server
}
function startBasicAuthServer () {
  const server = http.createServer(handle)

  function handle (req, res) {
    if (!req.headers.authorization || req.headers.authorization.indexOf('Basic ') === -1) {
      res.writeHead(401)
      return res.end()
    }

    res.writeHead(200)
    res.end('hello world')
  }

  server.listen(0)
  server.unref()

  return server
}

function customizeHAR (fixturePath, replaced, domain) {
  const har = JSON.parse(JSON.stringify(require(fixturePath)))
  for (const entry of har.log.entries) {
    entry.request.url = entry.request.url.replace(replaced, domain)
  }
  return har
}

module.exports.startServer = startServer
module.exports.startTimeoutServer = startTimeoutServer
module.exports.startSocketDestroyingServer = startSocketDestroyingServer
module.exports.startHttpsServer = startHttpsServer
module.exports.startTrailerServer = startTrailerServer
module.exports.startTlsServer = startTlsServer
module.exports.startMultipartServer = startMultipartServer
module.exports.startBasicAuthServer = startBasicAuthServer
module.exports.customizeHAR = customizeHAR

function noop () {}


================================================
FILE: test/httpClient.test.js
================================================
'use strict'

const os = require('os')
const http = require('http')
const path = require('path')
const test = require('tap').test
const Client = require('../lib/httpClient')
const helper = require('./helper')
const server = helper.startServer()
const timeoutServer = helper.startTimeoutServer()
const httpsServer = helper.startHttpsServer()
const tlsServer = helper.startTlsServer()
const trailerServer = helper.startTrailerServer()
const bl = require('bl')
const fs = require('fs')

const makeResponseFromBody = ({ server, method, body, headers = {} }) => {
  const sentHeaders = {
    Connection: 'keep-alive',
    ...headers
  }
  if (!sentHeaders['Content-Length'] && body) {
    sentHeaders['Content-Length'] = body.length
  }
  return `${method} / HTTP/1.1\r\nHost: localhost:${
    server.address().port
  }\r\n${
    Object.keys(sentHeaders).map(name => `${name}: ${sentHeaders[name]}`).join('\r\n')
  }\r\n${
    body ? `\r\n${body}` : '\r\n'
  }`
}

test('client calls a server twice', (t) => {
  t.plan(4)

  const client = new Client(server.address())
  let count = 0

  client.on('response', (statusCode, length) => {
    t.equal(statusCode, 200, 'status code matches')
    t.ok(length > 'hello world'.length, 'length includes the headers')
    if (count++ > 0) {
      client.destroy()
    }
  })
})

test('client calls a https server twice', (t) => {
  t.plan(4)

  const opts = httpsServer.address()
  opts.protocol = 'https:'
  const client = new Client(opts)
  let count = 0

  client.on('response', (statusCode, length) => {
    t.equal(statusCode, 200, 'status code matches')
    t.ok(length > 'hello world'.length, 'length includes the headers')
    if (count++ > 0) {
      client.destroy()
    }
  })
})

test('client calculates correct duration when using pipelining', (t) => {
  t.plan(6)

  const delayResponse = 500
  const lazyServer = helper.startServer({ delayResponse })
  const opts = lazyServer.address()
  opts.pipelining = 2
  const startTime = process.hrtime()
  const client = new Client(opts)
  let count = 0

  client.on('response', (statusCode, length, duration) => {
    t.equal(statusCode, 200, 'status code matches')
    t.ok(duration > delayResponse, `Expected response delay > ${delayResponse}ms but got ${duration}ms`)

    const hrduration = process.hrtime(startTime)
    const maxExpectedDuration = hrduration[0] * 1e3 + hrduration[1] / 1e6
    t.ok(duration < maxExpectedDuration, `Expected response delay < ${maxExpectedDuration}ms but got ${duration}ms`)

    if (++count === 2) {
      client.destroy()
    }
  })
})

test('client calls a tls server without SNI servername twice', (t) => {
  t.plan(4)

  const opts = tlsServer.address()
  opts.protocol = 'https:'
  const client = new Client(opts)
  let count = 0

  client.on('headers', (response) => {
    t.equal(response.statusCode, 200, 'status code matches')
    t.same(response.headers, ['X-servername', '', 'Content-Length', '0'])
    if (count++ > 0) {
      client.destroy()
    }
  })
})

test('client calls a tls server with SNI servername twice', (t) => {
  t.plan(4)

  const opts = tlsServer.address()
  opts.protocol = 'https:'
  opts.servername = 'example.com'
  const client = new Client(opts)
  let count = 0

  client.on('headers', (response) => {
    t.equal(response.statusCode, 200, 'status code matches')
    t.same(response.headers, ['X-servername', opts.servername, 'Content-Length', '0'])
    if (count++ > 0) {
      client.destroy()
    }
  })
})

test('client uses SNI servername from URL hostname by default', (t) => {
  t.plan(4)

  const opts = tlsServer.address()
  opts.protocol = 'https:'
  opts.hostname = 'localhost'
  const client = new Client(opts)
  let count = 0

  client.on('headers', (response) => {
    t.equal(response.statusCode, 200, 'status code matches')
    t.same(response.headers, ['X-servername', opts.hostname, 'Content-Length', '0'])
    if (count++ > 0) {
      client.destroy()
    }
  })
})

test('client prefers SNI servername from opts over URL hostname', (t) => {
  t.plan(4)

  const opts = tlsServer.address()
  opts.protocol = 'https:'
  opts.hostname = 'localhost'
  opts.servername = 'example.com'
  const client = new Client(opts)
  let count = 0

  client.on('headers', (response) => {
    t.equal(response.statusCode, 200, 'status code matches')
    t.same(response.headers, ['X-servername', opts.servername, 'Content-Length', '0'])
    if (count++ > 0) {
      client.destroy()
    }
  })
})

test('client ignores IP address in hostname-derived SNI servername', (t) => {
  t.plan(4)

  const opts = tlsServer.address()
  opts.protocol = 'https:'
  opts.hostname = opts.address
  const client = new Client(opts)
  let count = 0

  client.on('headers', (response) => {
    t.equal(response.statusCode, 200, 'status code matches')
    t.same(response.headers, ['X-servername', '', 'Content-Length', '0'])
    if (count++ > 0) {
      client.destroy()
    }
  })
})

test('client ignores falsy SNI servername', (t) => {
  t.plan(4)

  const opts = tlsServer.address()
  opts.protocol = 'https:'
  opts.servername = ''
  const client = new Client(opts)
  let count = 0

  client.on('headers', (response) => {
    t.equal(response.statusCode, 200, 'status code matches')
    t.same(response.headers, ['X-servername', '', 'Content-Length', '0'])
    if (count++ > 0) {
      client.destroy()
    }
  })
})

test('client passes through tlsOptions to connect', (t) => {
  t.plan(4)

  const opts = tlsServer.address()
  opts.protocol = 'https:'
  opts.tlsOptions = {
    key: fs.readFileSync(path.join(__dirname, '/key.pem')),
    cert: fs.readFileSync(path.join(__dirname, '/cert.pem')),
    passphrase: 'test'
  }
  const client = new Client(opts)
  let count = 0

  client.on('headers', (response) => {
    t.equal(response.statusCode, 200, 'status code matches')
    t.same(response.headers, ['X-servername', '', 'X-email', 'tes@test.com', 'Content-Length', '0'])
    if (count++ > 0) {
      client.destroy()
    }
  })
})

test('http client automatically reconnects', (t) => {
  t.plan(4)

  const client = new Client(server.address())
  let count = 0

  client.on('response', (statusCode, length) => {
    t.equal(statusCode, 200, 'status code matches')
    t.ok(length > 'hello world'.length, 'length includes the headers')
    if (count++ > 0) {
      client.destroy()
    }
  })

  server.once('request', function (req, res) {
    setImmediate(() => {
      req.socket.destroy()
    })
  })
})

test('http clients should have a different body', (t) => {
  t.plan(3)

  let clientCnt = 0
  const clients = []
  const reqArray = ['John', 'Gabriel', 'Jason']
  const opts = server.address()

  opts.setupClient = (client) => {
    client.setBody(JSON.stringify({ name: reqArray[clientCnt] }))
    clientCnt++
  }

  for (let i = 0; i < 3; i++) {
    const client = new Client(opts)

    clients.push(client)
  }

  for (let i = 0; i < clients.length; i++) {
    const client = clients[i]
    const body = JSON.parse(client.requestIterator.currentRequest.body)

    t.equal(body.name, reqArray[i], 'body match')
    client.destroy()
  }
})

test('client supports custom headers', (t) => {
  t.plan(3)

  const opts = server.address()
  opts.headers = {
    hello: 'world'
  }
  const client = new Client(opts)

  server.once('request', (req, res) => {
    t.equal(req.headers.hello, 'world', 'custom header matches')
  })

  client.on('response', (statusCode, length) => {
    t.equal(statusCode, 200, 'status code matches')
    t.ok(length > 'hello world'.length, 'length includes the headers')
    client.destroy()
  })
})

test('client supports custom headers in requests', (t) => {
  t.plan(2)

  const opts = server.address()
  opts.requests = [
    {
      path: '/',
      method: 'POST',
      headers: {
        'content-type': 'application/json'
      },
      body: JSON.stringify({
        foo: 'example'
      })
    }
  ]
  const client = new Client(opts)

  server.once('request', (req, res) => {
    t.equal(req.headers['content-type'], 'application/json', 'custom header matches')
  })

  client.on('response', (statusCode, length) => {
    t.equal(statusCode, 200, 'status code matches')
    client.destroy()
  })
})

test('client supports host custom header', (t) => {
  t.plan(2)

  const opts = server.address()
  opts.headers = {
    host: 'www.autocannon.com'
  }
  const client = new Client(opts)

  server.once('request', (req, res) => {
    t.equal(req.headers.host, 'www.autocannon.com', 'host header matches')
  })

  client.on('response', (statusCode, length) => {
    t.equal(statusCode, 200, 'status code matches')
    client.destroy()
  })
})

test('client supports host custom header with mixed case', (t) => {
  t.plan(2)

  const opts = server.address()
  opts.headers = {
    Host: 'www.autocannon.com'
  }
  const client = new Client(opts)

  server.once('request', (req, res) => {
    t.equal(req.headers.host, 'www.autocannon.com', 'host header matches')
  })

  client.on('response', (statusCode, length) => {
    t.equal(statusCode, 200, 'status code matches')
    client.destroy()
  })
})

test('client supports response trailers', (t) => {
  t.plan(3)

  const client = new Client(trailerServer.address())
  let n = 0
  client.on('body', (raw) => {
    if (++n === 1) {
      // trailer value
      t.ok(/7895bf4b8828b55ceaf47747b4bca667/.test(raw.toString()))
    }
  })
  client.on('response', (statusCode, length) => {
    t.equal(statusCode, 200, 'status code matches')
    t.ok(length > 'hello world'.length, 'length includes the headers')
    client.destroy()
  })
})

;
[
  'DELETE',
  'POST',
  'PUT'
].forEach((method) => {
  test(`client supports ${method}`, (t) => {
    t.plan(3)

    const opts = server.address()
    opts.method = method

    const client = new Client(opts)

    server.once('request', (req, res) => {
      t.equal(req.method, method, 'custom method matches')
    })

    client.on('response', (statusCode, length) => {
      t.equal(statusCode, 200, 'status code matches')
      t.ok(length > 'hello world'.length, 'length includes the headers')
      client.destroy()
    })
  })
})

test('client supports sending a body', (t) => {
  t.plan(4)

  const opts = server.address()
  opts.method = 'POST'
  opts.body = Buffer.from('hello world')

  const client = new Client(opts)

  server.once('request', (req, res) => {
    req.pipe(bl((err, body) => {
      t.error(err)
      t.same(body.toString(), opts.body.toString(), 'body matches')
    }))
  })

  client.on('response', (statusCode, length) => {
    t.equal(statusCode, 200, 'status code matches')
    t.ok(length > 'hello world'.length, 'length includes the headers')
    client.destroy()
  })
})

test('client supports sending a body which is a string', (t) => {
  t.plan(4)

  const opts = server.address()
  opts.method = 'POST'
  opts.body = 'hello world'

  const client = new Client(opts)

  server.once('request', (req, res) => {
    req.pipe(bl((err, body) => {
      t.error(err)
      t.same(body.toString(), opts.body, 'body matches')
    }))
  })

  client.on('response', (statusCode, length) => {
    t.equal(statusCode, 200, 'status code matches')
    t.ok(length > 'hello world'.length, 'length includes the headers')
    client.destroy()
  })
})

test('client supports sending a body passed on the CLI as JSON array', (t) => {
  t.plan(3)

  const body = [{ a: [{ b: 1 }] }]
  const jsonBody = JSON.stringify(body)

  // this odd format is parsed by the subarg parser when body is a JSON array
  const mangledBody = { _: [JSON.stringify(body[0])] }

  const opts = server.address()
  opts.method = 'POST'
  opts.body = mangledBody

  const client = new Client(opts)

  server.once('request', (req, res) => {
    req.pipe(bl((err, body) => {
      t.error(err)
      t.same(body.toString(), jsonBody, 'body matches')
    }))
  })

  client.on('response', (statusCode, length) => {
    t.equal(statusCode, 200, 'status code matches')
    client.destroy()
  })
})

test('client supports changing the body', (t) => {
  t.plan(2)

  const opts = server.address()
  opts.method = 'POST'
  opts.body = 'hello world'

  const client = new Client(opts)

  t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, ...opts }), 'request is okay before modifying')

  const body = 'modified'
  client.setBody(body)

  t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, ...opts, body }), 'body changes updated request')
  client.destroy()
})

test('client supports changing the headers', (t) => {
  t.plan(2)

  const opts = server.address()
  opts.method = 'POST'

  const client = new Client(opts)
  t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, ...opts }), 'request is okay before modifying')

  const headers = { header: 'modified' }
  client.setHeaders(headers)

  t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, ...opts, headers }), 'header changes updated request')
  client.destroy()
})

test('client supports changing the headers and body', (t) => {
  t.plan(2)

  const opts = server.address()
  opts.body = 'hello world'
  opts.method = 'POST'

  const client = new Client(opts)

  t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, ...opts }), 'request is okay before modifying')

  const body = 'modified'
  const headers = { header: 'modifiedHeader' }
  client.setBody(body)
  client.setHeaders(headers)

  t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, ...opts, headers, body }), 'changes updated request')
  client.destroy()
})

test('client supports changing the headers and body together', (t) => {
  t.plan(2)

  const opts = server.address()
  opts.body = 'hello world'
  opts.method = 'POST'

  const client = new Client(opts)

  t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, ...opts }), 'request is okay before modifying')

  const body = 'modified'
  const headers = { header: 'modifiedHeader' }
  client.setHeadersAndBody(headers, body)

  t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, ...opts, headers, body }), 'changes updated request')
  client.destroy()
})

test('client supports changing the headers and body with null values', (t) => {
  t.plan(2)

  const opts = server.address()
  opts.body = 'hello world'
  opts.method = 'POST'

  const client = new Client(opts)

  t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, ...opts }), 'request is okay before modifying')

  client.setBody(null)
  client.setHeaders(null)

  t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, method: 'POST' }), 'changes updated request')
  client.destroy()
})

test('client supports changing the headers and body together with null values', (t) => {
  t.plan(2)

  const opts = server.address()
  opts.body = 'hello world'
  opts.method = 'POST'

  const client = new Client(opts)

  t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, ...opts }), 'request is okay before modifying')

  client.setHeadersAndBody(null, null)

  t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, method: 'POST' }), 'changes updated request')
  client.destroy()
})

test('client supports updating the current request object', (t) => {
  t.plan(2)

  const opts = server.address()
  opts.body = 'hello world'
  opts.method = 'POST'

  const client = new Client(opts)

  t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, ...opts }), 'request is okay before modifying')

  const newReq = {
    headers: {
      header: 'modifiedHeader'
    },
    body: 'modified',
    method: 'GET'
  }
  client.setRequest(newReq)

  t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, ...newReq }), 'changes updated request')
  client.destroy()
})

test('client customiseRequest function overwrites the headers and body', (t) => {
  t.plan(5)

  const opts = server.address()
  opts.body = 'hello world'
  opts.method = 'POST'
  const body = 'modified'
  const headers = { header: 'modifiedHeader' }
  opts.setupClient = (client) => {
    t.ok(client.setHeadersAndBody, 'client had setHeadersAndBody method')
    t.ok(client.setHeaders, 'client had setHeaders method')
    t.ok(client.setBody, 'client had setBody method')

    client.setHeadersAndBody(headers, body)
  }

  const client = new Client(opts)

  t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, ...opts, headers, body }), 'changes updated request')

  t.notSame(client.getRequestBuffer().toString(), makeResponseFromBody({ server, ...opts }), 'changes updated request')

  client.destroy()
})

test('client should throw when attempting to modify the request with a pipelining greater than 1', (t) => {
  t.plan(1)

  const opts = server.address()
  opts.pipelining = 10
  const client = new Client(opts)

  t.throws(() => client.setHeaders({}))

  client.destroy()
})

test('client pipelined requests count should equal pipelining when greater than 1', (t) => {
  t.plan(1)

  const opts = server.address()
  opts.pipelining = 10
  const client = new Client(opts)

  t.equal(client.pipelinedRequests.size(), client.opts.pipelining)

  client.destroy()
})

test('client should emit a timeout when no response is received', (t) => {
  t.plan(1)

  const opts = timeoutServer.address()
  opts.timeout = 1
  const client = new Client(opts)

  client.on('timeout', () => {
    t.ok(1, 'timeout should have happened')
    client.destroy()
  })
})

test('client should emit 2 timeouts when no responses are received', (t) => {
  t.plan(2)

  const opts = timeoutServer.address()
  opts.timeout = 1
  const client = new Client(opts)
  let count = 0
  client.on('timeout', () => {
    t.ok(1, 'timeout should have happened')
    if (count++ > 0) {
      client.destroy()
    }
  })
})

test('client should have 2 different requests it iterates over', (t) => {
  t.plan(3)
  const server = helper.startServer()
  const opts = server.address()

  const requests = [
    {
      method: 'POST',
      body: 'hello world again'
    },
    {
      method: 'GET',
      body: 'modified'
    }
  ]

  const client = new Client(opts)
  let number = 0
  client.setRequests(requests)
  client.on('response', (statusCode, length) => {
    number++
    switch (number) {
      case 1:
      case 3:
        t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, ...requests[0] }), 'request was okay')
        break
      case 2:
        t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, ...requests[1] }), 'body changes updated request')
        break
      case 4:
        client.destroy()
        t.end()
        break
    }
  })
})

test('client should emit reset when request iterator has reset', (t) => {
  t.plan(1)
  const server = helper.startServer()
  const opts = server.address()

  const requests = [
    {
      method: 'POST',
      body: 'hello world again'
    },
    {
      method: 'POST',
      body: 'modified',
      // falsey result will reset
      setupRequest: () => {}
    },
    {
      method: 'POST',
      body: 'never used'
    }
  ]

  const client = new Client(opts)
  client.setRequests(requests)
  client.on('reset', () => {
    client.destroy()
    t.end()
  })
  client.on('response', () => {
    t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, ...requests[0] }), 'first request was okay')
  })
})

test('client should stop when first setupRequest() fails', (t) => {
  t.plan(1)
  const server = helper.startServer()
  const opts = server.address()

  const client = new Client(opts)
  t.throws(
    () => client.setRequests([{ method: 'GET', setupRequest: () => {} }]),
    'First setupRequest() failed did not returned valid request. Stopping'
  )
  client.destroy()
  t.end()
})

test('client exposes response bodies and statuses', (t) => {
  const server = helper.startServer({
    body: ({ method }) => method === 'POST' ? 'hello!' : 'world!'
  })
  const opts = server.address()
  opts.requests = [
    {
      method: 'POST',
      body: 'hello world!',
      onResponse: (status, body) => responses.push({ status, body })
    },
    {
      method: 'POST',
      body: 'hello world again'
    },
    {
      method: 'GET',
      onResponse: (status, body) => responses.push({ status, body })
    }
  ]
  const responses = []

  const client = new Client(opts)
  let number = 0
  client.on('response', (statusCode, length) => {
    number++
    switch (number) {
      case 1:
        t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, ...opts.requests[0] }), 'first request')
        t.same(responses, [{
          status: 200,
          body: 'hello!'
        }])
        break
      case 2:
        t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, ...opts.requests[1] }), 'second request')
        t.same(responses, [{
          status: 200,
          body: 'hello!'
        }])
        break
      case 3:
        t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, ...opts.requests[2] }), 'third request')
        t.same(responses, [{
          status: 200,
          body: 'hello!'
        }, {
          status: 200,
          body: 'world!'
        }])
        break
      case 4:
        t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, ...opts.requests[0] }), 'first request')
        t.same(responses, [{
          status: 200,
          body: 'hello!'
        }, {
          status: 200,
          body: 'world!'
        }, {
          status: 200,
          body: 'hello!'
        }])
        client.destroy()
        t.end()
        break
    }
  })
})

test('client keeps context and reset it when looping on requests', (t) => {
  const server = helper.startServer()
  const opts = server.address()
  let number = 0
  const expectedResponse = 'hello world'

  opts.requests = [
    {
      method: 'POST',
      body: 'hello world again',
      onResponse: (status, body, context) => {
        if (number < 3) {
          t.same(context, {}, 'context was supposed to be null')
          context.previousRes = body
        }
      }
    },
    {
      method: 'PUT',
      setupRequest: (req, context) => {
        if (number < 3) {
          t.same(context, { previousRes: expectedResponse }, 'context was supposed to contain previous response')
        }
        return Object.assign({}, req, { body: context.previousRes })
      }
    }
  ]

  const client = new Client(opts)
  client.on('response', (statusCode, length) => {
    number++
    switch (number) {
      case 1:
        t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, ...opts.requests[0] }), 'hard-coded body')
        break
      case 2:
        t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, method: 'PUT', body: expectedResponse }), 'dynamic body')
        client.destroy()
        t.end()
        break
    }
  })
})

test('client supports http basic authentication', (t) => {
  t.plan(2)
  const server = helper.startServer()
  const opts = server.address()
  opts.auth = 'username:password'
  const client = new Client(opts)

  server.once('request', (req, res) => {
    t.equal(req.headers.authorization, 'Basic dXNlcm5hbWU6cGFzc3dvcmQ=', 'authorization header matches')
  })

  client.on('response', (statusCode, length) => {
    t.equal(statusCode, 200, 'status code matches')
    client.destroy()
    t.end()
  })
})

test('should return client instance', (t) => {
  t.plan(1)
  const caller = {}
  const opts = server.address()
  opts.auth = 'username:password'
  const client = Client.call(caller, opts)

  t.type(client, Client)
  client.destroy()
})

test('client calls twice using socket on secure server', (t) => {
  t.plan(4)
  const socketPath = process.platform === 'win32'
    ? path.join('\\\\?\\pipe', process.cwd(), 'autocannon-' + Date.now())
    : path.join(os.tmpdir(), 'autocannon-' + Date.now() + '.sock')

  helper.startHttpsServer({ socketPath })
  const client = new Client({
    url: 'localhost',
    protocol: 'https:',
    socketPath,
    connections: 1
  })
  let count = 0
  client.on('response', (statusCode, length) => {
    t.equal(statusCode, 200, 'status code matches')
    t.ok(length > 'hello world'.length, 'length includes the headers')
    if (count++ > 0) {
      client.destroy()
      t.end()
    }
  })
})

test('client emits mistmatch when expectBody doesn\'t match actual body', (t) => {
  const responses = ['hello...', 'world!']
  const server = helper.startServer({
    body: ({ method }) => responses[method === 'POST' ? 0 : 1]
  })
  const opts = server.address()
  opts.requests = [
    {
      method: 'POST',
      body: 'hi there!'
    },
    {
      method: 'GET'
    }
  ]
  opts.expectBody = responses[0]

  const client = new Client(opts)
  client.on('mismatch', (body) => {
    // we expect body mismatch on second request
    t.same(body, responses[1])
    client.destroy()
    t.end()
  })
})

test('client invokes appropriate onResponse when using pipelining', (t) => {
  const server = helper.startServer({
    body: ({ method }) => method
  })
  const opts = server.address()
  opts.pipelining = 2
  const responses = []
  const onResponse = (status, body) => responses.push(body)
  opts.requests = [
    {
      method: 'POST',
      onResponse
    },
    {
      method: 'GET',
      onResponse
    },
    {
      method: 'PUT',
      onResponse
    }
  ]

  const client = new Client(opts)
  let number = 0
  client.on('response', (statusCode, length) => {
    number++
    switch (number) {
      case 1:
        // 1st & 2nd were sent, receiving 1st
        t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, method: 'GET' }), 'current should be second request')
        t.same(responses, ['POST'])
        break
      case 2:
        // 3rd was sent as 1st is finished, receiving 2nd
        t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, method: 'PUT' }), 'current should be third request')
        t.same(responses, ['POST', 'GET'])
        break
      case 3:
        // 1st was resent, receiving 3rd
        t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, method: 'POST' }), 'current should be first request')
        t.same(responses, ['POST', 'GET', 'PUT'])
        break
      case 4:
        // 2nd was resent, receiving 1st
        t.same(client.getRequestBuffer().toString(), makeResponseFromBody({ server, method: 'GET' }), 'current should be second request')
        t.same(responses, ['POST', 'GET', 'PUT', 'POST'])
        client.destroy()
        t.end()
        break
    }
  })
})

test('client supports receiving large response body', (t) => {
  t.plan(2)

  const mockBody = Array.from({ length: 1024 * 10 }, (_, i) => `str-${i}`).join('\n')
  const server = http.createServer((req, res) => {
    res.end(mockBody)
  })
  server.listen(0)
  server.unref()

  let onResponseCalled = 0
  const opts = server.address()
  opts.method = 'POST'
  opts.body = Buffer.from('hello world')
  opts.requests = [
    {
      path: '/',
      method: 'GET',
      onResponse: (...args) => {
        onResponseCalled++
      }
    }
  ]

  const client = new Client(opts)

  client.on('response', (statusCode, length) => {
    t.equal(onResponseCalled, 1, 'onResponse should be called only once')
    t.equal(statusCode, 200, 'status code matches')
    client.destroy()
  })
})


================================================
FILE: test/httpRequestBuilder.test.js
================================================
'use strict'

const test = require('tap').test
const helper = require('./helper')
const server = helper.startServer()
const RequestBuilder = require('../lib/httpRequestBuilder')
const httpMethods = require('../lib/httpMethods')

test('request builder should create a request with sensible defaults', (t) => {
  t.plan(1)

  const opts = server.address()

  const build = RequestBuilder(opts)

  const result = build()
  t.same(result,
    Buffer.from(`GET / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\n\r\n`),
    'request is okay')
})

test('request builder should allow default overwriting', (t) => {
  t.plan(1)

  const opts = server.address()
  opts.method = 'POST'

  const build = RequestBuilder(opts)

  const result = build()
  t.same(result,
    Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\n\r\n`),
    'request is okay')
})

test('request builder should allow per build overwriting', (t) => {
  t.plan(1)

  const opts = server.address()
  opts.method = 'POST'

  const build = RequestBuilder(opts)

  const result = build({ method: 'GET' })

  t.same(result,
    Buffer.from(`GET / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\n\r\n`),
    'request is okay')
})

test('request builder should throw on unknown http method', (t) => {
  t.plan(1)

  const opts = server.address()

  const build = RequestBuilder(opts)

  t.throws(() => build({ method: 'UNKNOWN' }))
})

test('request builder should accept all valid standard http methods', (t) => {
  t.plan(httpMethods.length)
  httpMethods.forEach((method) => {
    const opts = server.address()

    const build = RequestBuilder(opts)

    t.doesNotThrow(() => build({ method }), `${method} should be usable by the request builded`)
  })
  t.end()
})

test('request builder should add a Content-Length header when the body buffer exists as a default override', (t) => {
  t.plan(1)

  const opts = server.address()
  opts.method = 'POST'
  opts.body = 'body'

  const build = RequestBuilder(opts)

  const result = build()
  t.same(result,
    Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nContent-Length: 4\r\n\r\nbody`),
    'request is okay')
})

test('request builder should add a Content-Length header when the body buffer exists as per build override', (t) => {
  t.plan(1)

  const opts = server.address()
  opts.method = 'POST'

  const build = RequestBuilder(opts)

  const result = build({ body: 'body' })
  t.same(result,
    Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nContent-Length: 4\r\n\r\nbody`),
    'request is okay')
})

test('request builder should add only one HOST header', (t) => {
  t.plan(1)

  const opts = server.address()
  opts.method = 'POST'
  opts.headers = {
    Host: 'example.com'
  }

  const build = RequestBuilder(opts)

  const result = build({ body: 'body' })
  t.same(result,
    Buffer.from('POST / HTTP/1.1\r\nConnection: keep-alive\r\nHost: example.com\r\nContent-Length: 4\r\n\r\nbody'),
    'request is okay')
})

test('request builder should add a Content-Length header with correct calculated value when the body buffer exists and idReplacement is enabled as a default override', (t) => {
  t.plan(1)

  const opts = server.address()
  opts.method = 'POST'
  opts.body = '[<id>]'
  opts.idReplacement = true

  const build = RequestBuilder(opts)

  const result = build()
  t.same(result,
    Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nContent-Length: 33\r\n\r\n[<id>]`),
    'request is okay')
})

test('request builder should add a Content-Length header with value "[<contentLength>]" when the body buffer exists and idReplacement is enabled as a per build override', (t) => {
  t.plan(1)

  const opts = server.address()
  opts.method = 'POST'
  opts.body = '[<id>]'

  const build = RequestBuilder(opts)

  const result = build({ idReplacement: true })
  t.same(result,
    Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nContent-Length: 33\r\n\r\n[<id>]`),
    'request is okay')
})

test('request builder should allow http basic authentication', (t) => {
  t.plan(1)

  const opts = server.address()
  opts.auth = 'username:password'

  const build = RequestBuilder(opts)

  const result = build()
  t.same(result,
    Buffer.from(`GET / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nAuthorization: Basic dXNlcm5hbWU6cGFzc3dvcmQ=\r\n\r\n`),
    'request is okay')
})

test('should throw error if body is not a string or a buffer', (t) => {
  t.plan(1)

  const opts = server.address()

  const build = RequestBuilder(opts)

  try {
    build({ body: [] })
  } catch (error) {
    t.equal(error.message, 'body must be either a string or a buffer')
  }
})


================================================
FILE: test/key.pem
================================================
-----BEGIN RSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: DES-EDE3-CBC,081E2A4DFAF06358

yfmHgUwn2RV+CGBYKJMBfLu+EQCKIOprjUxSBPaytTwc6NsOeVjOb/iAcVvr0D6B
a6Kc8BrIMfVVjABghufAnJXav+aB6Q/LkfaqJp6AfVI86WMaCBb0Fzkg8IYYSbgy
JiskTYmV1IrjYfR6TEtQmeFP0DMh1RU9VLIfehEFRMU7LcDh5Ah3bsZE5muBSlws
98IVBwEwEXoQdVxLJmz+kR3fEjXYmgNZQzP6GFb3jQENV3XijQffgQ4ajREB5EZL
Zag+K0vwbFZORqWNfI5VFVVWOEErRF0BSDFZWJP8jbiSX4tNyEFRzO2dgdjGycqt
3dtWbofY28Hjf36P3ee2mMHe3V8XZUtCtfufiYFLKHedHShg7FolfSSMmIfNmSgE
jCnTFNU4Fsq8I/q6ywfVh3CP/rjEe/I4GAU7wql0PW7LXjAHqRjLshJ09mX5J3w8
+tvsrYiBLsgmtdnX47LDJDyeYZY5gbBaz9XsNd432z1M6lRILsT48RYwXEz5oHBE
El1oKNko/PHljDkTph/xI1jUlkYJ7w9//stao/9VLzn0XQG839+lz1MNi/opmpUi
3P9Z3+yTbdwibRHLmgCR6PNE4EJdfv0VNantsxiSATyhIS/xPGhU4lich8gMNDcv
9IcUSCTkmVGy8ksJITt/m7mespQ8Y1oD3xvXoaCbTJ8aig6EQ5flYwmmiIHrWSol
5w5iKjkNbdNYftAg+RB6+EwrNz43oHLYRMB3dckYc1L+otd/X+lmlTlqOo8WDgh1
cH4MI4cwjdYmFdp5Nhfd9/nWFtayqcj59IBgEAMzafbzcmhma6oJD9GsxSnw9eRY
vb3b7fhtcqeKDgqfN4TklX/7kkoLpRVMEdW4uNyU0US1QC5gTxiFRW3/XGhaQJ6o
quE2UP3qySp7kHsz++P6mya2xF2JNcKh1zxxF+wSnjymUxaWXz1LKGQs4iOjU8Xg
HkPD3wTxtMXXZw/0LGMu7XLMFWMV3nuMGtt/I/GGtCbKbFkDOOI4imZWpmsvvO0s
liMhhtCwJTqkYvlxPtfcLSKFJrwcCeb2xHcLEDAaRa5xUbUt3P60l7Ujyv3p+bVi
sItGE6Mk8kGXglmZGBA0RIGhXlX7r6pNryqMUy0CU5/YniJFCKoaU9WOG8VwHynY
psqvZ1umAtl4twe7SxF0znLdOGiYsOOQls5wcz1rDfj5IXRcbrWEeLwYD9b0oXms
TvgkcfHlutZ+M+NtP7wGFBen1X68HsYBhvhLrVbox5bgMZVrXCN4+HiBO4VAwq+m
c2akVF9kQfoR5iGMhzzgskH8c7TWuF7IDqA8KBuFKcicBHK/Ns/1ljycWr07cLJc
WabX25aI0x58+ise5fJAQvNW6Oq2Jvt3qcUXnr2OMnR6WUQ7amgVC7JAdfRoahYU
2WJl6jkCANIv5mY7ubEgVgXnuYYL4ljScpMZLER3cLW4uQnRXWo4zciz06+BadfI
PjGb9xt+3EE4VB64O3yI9yBoDAM/lL0oadB8TPxFLN1NZA3gixbE6dXd5jGD9YxJ
rJNu8xR4MUttiHA8+aVw84kiqsY8OzrjbJnVr2SSXARYw4dnz8DfxhPCt6hMCWnw
-----END RSA PRIVATE KEY-----


================================================
FILE: test/onPort.test.js
================================================
'use strict'

const path = require('path')
const { test } = require('tap')
const spawn = require('child_process').spawn
const split = require('split2')
const hasAsyncHooks = require('has-async-hooks')

test('--on-port flag', { skip: !hasAsyncHooks() }, (t) => {
  const lines = [
    /Running 1s test @ .*$/,
    /10 connections.*$/,
    /$/,
    /.*/,
    /$/,
    /Stat.*2\.5%.*50%.*97\.5%.*99%.*Avg.*Stdev.*Max.*$/,
    /.*/,
    /Latency.*$/,
    /$/,
    /.*/,
    /Stat.*1%.*2\.5%.*50%.*97\.5%.*Avg.*Stdev.*Min.*$/,
    /.*/,
    /Req\/Sec.*$/,
    /$/,
    /Bytes\/Sec.*$/,
    /.*/,
    /$/,
    /Req\/Bytes counts sampled once per second.*$/,
    /# of samples: 10*$/,
    /$/,
    /.* requests in ([0-9]|\.)+s, .* read/
  ]

  t.plan(lines.length * 2)

  const child = spawn(process.execPath, [
    path.join(__dirname, '..'),
    '-c', '10',
    '-d', '1',
    '--on-port', '/',
    '--', 'node', path.join(__dirname, './targetProcess')
  ], {
    cwd: __dirname,
    env: process.env,
    stdio: ['ignore', 'pipe', 'pipe'],
    detached: false
  })

  t.teardown(() => {
    child.kill()
  })

  child
    .stderr
    .pipe(split())
    .on('data', (line) => {
      const regexp = lines.shift()
      t.ok(regexp, 'we are expecting this line')
      t.ok(regexp.test(line), 'line matches ' + regexp)
    })
})

test('assume --on-port flag if -- node is set', { skip: !hasAsyncHooks() }, (t) => {
  const lines = [
    /Running 1s test @ .*$/,
    /10 connections.*$/,
    /$/,
    /.*/,
    /$/,
    /Stat.*2\.5%.*50%.*97\.5%.*99%.*Avg.*Stdev.*Max.*$/,
    /.*/,
    /Latency.*$/,
    /$/,
    /.*/,
    /Stat.*1%.*2\.5%.*50%.*97\.5%.*Avg.*Stdev.*Min.*$/,
    /.*/,
    /Req\/Sec.*$/,
    /$/,
    /Bytes\/Sec.*$/,
    /.*/,
    /$/,
    /Req\/Bytes counts sampled once per second.*$/,
    /# of samples: 10*$/,
    /$/,
    /.* requests in ([0-9]|\.)+s, .* read/
  ]

  t.plan(lines.length * 2)

  const child = spawn(process.execPath, [
    path.join(__dirname, '..'),
    '-c', '10',
    '-d', '1',
    '/',
    '--', 'node', path.join(__dirname, './targetProcess')
  ], {
    cwd: __dirname,
    env: process.env,
    stdio: ['ignore', 'pipe', 'pipe'],
    detached: false
  })

  t.teardown(() => {
    child.kill()
  })

  child
    .stderr
    .pipe(split())
    .on('data', (line) => {
      const regexp = lines.shift()
      t.ok(regexp, 'we are expecting this line')
      t.ok(regexp.test(line), 'line matches ' + regexp + `actual: ${line}  expected: ${regexp}`)
    })
})


================================================
FILE: test/parseHAR.test.js
================================================
'use strict'

const test = require('tap').test
const { parseHAR } = require('../lib/parseHAR')

test('should throw on empty HAR', (t) => {
  t.plan(1)

  t.throws(() => parseHAR(null), /Could not parse HAR content: no entries found/)
  t.end()
})

test('should throw on HAR with no entries', (t) => {
  t.plan(1)

  t.throws(() => parseHAR({
    log: {
      version: '1.2',
      creator: {
        name: 'Firefox',
        version: '80.0.1'
      },
      pages: [
        {
          startedDateTime: '2020-09-28T16:43:28.987+02:00',
          id: 'page_1',
          title: 'mcollina/autocannon: fast HTTP/1.1 benchmarking tool written in Node.js',
          pageTimings: {
            onContentLoad: 1234,
            onLoad: 1952
          }
        }
      ]
    }
  }), /Could not parse HAR content: no entries found/)
  t.end()
})

test('should throw on HAR with empty entries', (t) => {
  t.plan(1)

  t.throws(() => parseHAR({
    log: {
      version: '1.2',
      creator: {
        name: 'Firefox',
        version: '80.0.1'
      },
      pages: [
        {
          startedDateTime: '2020-09-28T16:43:28.987+02:00',
          id: 'page_1',
          title: 'mcollina/autocannon: fast HTTP/1.1 benchmarking tool written in Node.js',
          pageTimings: {
            onContentLoad: 1234,
            onLoad: 1952
          }
        }
      ],
      entries: []
    }
  }), /Could not parse HAR content: no entries found/)
  t.end()
})

test('should parse and return GET entries', (t) => {
  t.plan(1)

  t.strictSame(parseHAR(require('./fixtures/httpbin-get.json')).get('https://httpbin.org'), [{
    method: 'GET',
    origin: 'https://httpbin.org',
    path: '/get',
    headers: {
      Host: 'httpbin.org',
      'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0',
      Accept: '*/*',
      'Accept-Language': 'fr,en;q=0.5',
      'Accept-Encoding': 'gzip, deflate, br',
      Referer: 'https://httpbin.org/',
      DNT: '1',
      Connection: 'keep-alive'
    }
  }, {
    method: 'GET',
    origin: 'https://httpbin.org',
    path: '/get?from=10&size=20&sort=+name',
    headers: {
      Host: 'httpbin.org',
      'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0',
      Accept: '*/*',
      'Accept-Language': 'fr,en;q=0.5',
      'Accept-Encoding': 'gzip, deflate, br',
      Referer: 'https://httpbin.org/',
      DNT: '1',
      Connection: 'keep-alive',
      TE: 'Trailers'
    }
  }])
  t.end()
})

test('should throw on HAR with invalid entries', (t) => {
  t.plan(2)

  t.throws(() => parseHAR({
    log: {
      entries: ['invalid']
    }
  }), /Could not parse HAR content: invalid request in entry #1/)
  t.throws(() => parseHAR({
    log: {
      entries: [{ request: { headers: [], url: 'http://localhost' } }, { request: null }]
    }
  }), /Could not parse HAR content: invalid request in entry #2/)

  t.end()
})

test('should throw on HAR with invalid headers', (t) => {
  t.plan(2)
  const url = 'http://localhost'

  t.throws(() => parseHAR({
    log: {
      entries: [{ request: { headers: [], url } }, { request: { headers: ['foo'], url } }]
    }
  }), /Could not parse HAR content: invalid name or value in header #1 of entry #2/)
  t.throws(() => parseHAR({
    log: {
      entries: [{ request: { headers: null } }]
    }
  }), /Could not parse HAR content: invalid headers array in entry #1/)
  t.end()
})

test('should parse and return POST entries', (t) => {
  t.plan(1)

  t.strictSame(parseHAR(require('./fixtures/httpbin-post.json')).get('https://httpbin.org'), [{
    method: 'POST',
    origin: 'https://httpbin.org',
    path: '/post',
    headers: {
      Host: 'httpbin.org',
      'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0',
      Accept: '*/*',
      'Accept-Language': 'fr,en;q=0.5',
      'Accept-Encoding': 'gzip, deflate, br',
      Referer: 'https://httpbin.org/',
      'Content-Type': 'multipart/form-data; boundary=---------------------------31420230025845772252453285324',
      Origin: 'https://httpbin.org',
      'Content-Length': '362',
      DNT: '1',
      Connection: 'keep-alive',
      TE: 'Trailers'
    },
    body: '-----------------------------31420230025845772252453285324\r\nContent-Disposition: form-data; name="text"\r\n\r\na text value\r\n-----------------------------31420230025845772252453285324\r\nContent-Disposition: form-data; name="file"; filename="blob"\r\nContent-Type: application/octet-stream\r\n\r\nHello World!\n\r\n-----------------------------31420230025845772252453285324--\r\n'
  }, {
    method: 'POST',
    origin: 'https://httpbin.org',
    path: '/post',
    headers: {
      Host: 'httpbin.org',
      'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0',
      Accept: '*/*',
      'Accept-Language': 'fr,en;q=0.5',
      'Accept-Encoding': 'gzip, deflate, br',
      Referer: 'https://httpbin.org/',
      'Content-Type': 'application/x-www-form-urlencoded',
      Origin: 'https://httpbin.org',
      'Content-Length': '27',
      DNT: '1',
      Connection: 'keep-alive',
      TE: 'Trailers'
    },
    body: 'text=a+text+value&number=10'
  }])
  t.end()
})

test('should split requests per origin', (t) => {
  t.plan(2)

  const requetsPerOrigin = parseHAR(require('./fixtures/multi-domains.json'))
  t.strictSame(requetsPerOrigin.get('https://httpbin.org'), [{
    method: 'POST',
    origin: 'https://httpbin.org',
    path: '/post',
    headers: {
      Host: 'httpbin.org',
      'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0',
      Accept: '*/*',
      'Accept-Language': 'fr,en;q=0.5',
      'Accept-Encoding': 'gzip, deflate, br',
      Referer: 'https://httpbin.org/',
      'Content-Type': 'multipart/form-data; boundary=---------------------------31420230025845772252453285324',
      Origin: 'https://httpbin.org',
      'Content-Length': '362',
      DNT: '1',
      Connection: 'keep-alive',
      TE: 'Trailers'
    },
    body: '-----------------------------31420230025845772252453285324\r\nContent-Disposition: form-data; name="text"\r\n\r\na text value\r\n-----------------------------31420230025845772252453285324\r\nContent-Disposition: form-data; name="file"; filename="blob"\r\nContent-Type: application/octet-stream\r\n\r\nHello World!\n\r\n-----------------------------31420230025845772252453285324--\r\n'
  }, {
    method: 'GET',
    origin: 'https://httpbin.org',
    path: '/get?from=10&size=20&sort=+name',
    headers: {
      Host: 'httpbin.org',
      'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0',
      Accept: '*/*',
      'Accept-Language': 'fr,en;q=0.5',
      'Accept-Encoding': 'gzip, deflate, br',
      Referer: 'https://httpbin.org/',
      DNT: '1',
      Connection: 'keep-alive',
      TE: 'Trailers'
    }
  }])

  t.strictSame(requetsPerOrigin.get('https://github.com'), [{
    method: 'POST',
    origin: 'https://github.com',
    path: '/',
    headers: {
      Host: 'github.com',
      'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0',
      Accept: '*/*',
      'Accept-Language': 'fr,en;q=0.5',
      'Accept-Encoding': 'gzip, deflate, br',
      Referer: 'https://github.com/',
      'Content-Type': 'application/x-www-form-urlencoded',
      Origin: 'https://github.com',
      'Content-Length': '27',
      DNT: '1',
      Connection: 'keep-alive',
      TE: 'Trailers'
    },
    body: 'text=a+text+value&number=10'
  }])
  t.end()
})


================================================
FILE: test/pipelinedRequestsQueue.test.js
================================================
'use strict'

const test = require('tap').test
const PipelinedRequestsQueue = require('../lib/pipelinedRequestsQueue')

test('PipelinedRequestsQueue measures time precisely', (t) => {
  t.plan(2)

  const delay = 42
  const queue = new PipelinedRequestsQueue()

  const startTime = process.hrtime()
  queue.insertRequest()
  setTimeout(() => {
    const data = queue.terminateRequest()

    t.ok(data.duration > delay, `Calculated duration ${data.duration} should not be less than the induced delay ${delay}`)

    const hrduration = process.hrtime(startTime)
    const maxExpectedDuration = Math.ceil(hrduration[0] * 1e3 + hrduration[1] / 1e6)
    t.ok(data.duration <= maxExpectedDuration, `Calculated duration ${data.duration} should be less than the max expected duration ${maxExpectedDuration}`)
  }, delay)
})

test('PipelinedRequestsQueue is a queue/FIFO', (t) => {
  const COUNT = 3
  t.plan(COUNT)

  const queue = new PipelinedRequestsQueue()

  let count = COUNT
  while (count > 0) {
    queue.insertRequest(count--)
  }

  count = COUNT
  while (count > 0) {
    t.equal(queue.terminateRequest().req, count--)
  }
})

test('PipelinedRequestsQueue.clear() empties the queue', (t) => {
  t.plan(5)

  const queue = new PipelinedRequestsQueue()
  t.equal(queue.size(), 0)
  t.equal(queue.toArray().length, 0)
  queue.insertRequest()
  queue.insertRequest()
  queue.insertRequest()
  t.equal(queue.size(), 3)
  t.equal(queue.toArray().length, 3)
  queue.clear()
  t.equal(queue.terminateRequest(), undefined)
})

test('PipelinedRequestsQueue methods set values to the request in first-in-last-out order', (t) => {
  t.plan(6)

  const queue = new PipelinedRequestsQueue()
  queue.insertRequest(1)
  queue.insertRequest(2)

  queue.addBody('1')
  queue.addByteCount(1)
  queue.setHeaders({ val: '1' })

  const req1 = queue.terminateRequest()
  t.equal(req1.req, 1)
  t.equal(req1.body, '1')
  t.same(req1.headers, { val: '1' })

  queue.addBody('2')
  queue.addByteCount(2)
  queue.setHeaders({ val: '2' })

  const req2 = queue.terminateRequest()
  t.equal(req2.req, 2)
  t.equal(req2.body, '2')
  t.same(req2.headers, { val: '2' })
})


================================================
FILE: test/printResult-process.js
================================================
'use strict'

const autocannon = require('../autocannon')
const exampleResult = require('./fixtures/example-result.json')
const crossArgv = require('cross-argv')

let opts = null

if (process.argv.length > 2) {
  const args = crossArgv(process.argv.slice(2))
  opts = autocannon.parseArguments(args)
}

const resultStr = autocannon.printResult(exampleResult, opts)
process.stderr.write(resultStr)


================================================
FILE: test/printResult-renderStatusCodes.test.js
================================================
'use strict'

const test = require('tap').test
const split = require('split2')
const path = require('path')
const childProcess = require('child_process')

test('should stdout (print) the result', (t) => {
  const lines = [
    /.*/,
    /$/,
    /Stat.*2\.5%.*50%.*97\.5%.*99%.*Avg.*Stdev.*Max.*$/,
    /.*/,
    /Latency.*$/,
    /$/,
    /.*/,
    /Stat.*1%.*2\.5%.*50%.*97\.5%.*Avg.*Stdev.*Min.*$/,
    /.*/,
    /Req\/Sec.*$/,
    /.*/,
    /Bytes\/Sec.*$/,
    /.*/,
    /.*/,
    /Code.*Count.*$/,
    /.*/,
    /200.*500.*$/,
    /.*/,
    /302.*0.*$/,
    /.*/,
    /401.*0.*$/,
    /.*/,
    /403.*0.*$/,
    /.*/,
    /$/,
    /Req\/Bytes counts sampled once per second.*$/,
    /# of samples: 10.*$/,
    /$/,
    /.* requests in ([0-9]|\.)+s, .* read/
  ]

  t.plan(lines.length * 2)

  const child = childProcess.spawn(process.execPath, [path.join(__dirname, 'printResult-process.js'), '--renderStatusCodes', 'http://127.0.0.1'], {
    cwd: __dirname,
    env: process.env,
    stdio: ['ignore', 'pipe', 'pipe'],
    detached: false
  })

  t.teardown(() => {
    child.kill()
  })

  child
    .stderr
    .pipe(split())
    .on('data', (line) => {
      const regexp = lines.shift()
      t.ok(regexp, 'we are expecting this line')
      t.ok(regexp.test(line), 'line matches ' + regexp)
    })
    .on('end', t.end)
})


================================================
FILE: test/printResult.test.js
================================================
'use strict'

const test = require('tap').test
const split = require('split2')
const path = require('path')
const childProcess = require('child_process')
const { Writable } = require('stream')
const ansiRegex = require('ansi-regex')
const printResult = require('../lib/printResult')

test('should stdout (print) the result', (t) => {
  const lines = [
    /.*/,
    /$/,
    /Stat.*2\.5%.*50%.*97\.5%.*99%.*Avg.*Stdev.*Max.*$/,
    /.*/,
    /Latency.*$/,
    /$/,
    /.*/,
    /Stat.*1%.*2\.5%.*50%.*97\.5%.*Avg.*Stdev.*Min.*$/,
    /.*/,
    /Req\/Sec.*$/,
    /.*/,
    /Bytes\/Sec.*$/,
    /.*/,
    /$/,
    /Req\/Bytes counts sampled once per second.*$/,
    /# of samples: 10*$/,
    /$/,
    /.* requests in ([0-9]|\.)+s, .* read/
  ]

  t.plan(lines.length * 2)

  const child = childProcess.spawn(process.execPath, [path.join(__dirname, 'printResult-process.js')], {
    cwd: __dirname,
    env: process.env,
    stdio: ['ignore', 'pipe', 'pipe'],
    detached: false
  })

  t.teardown(() => {
    child.kill()
  })

  child
    .stderr
    .pipe(split())
    .on('data', (line) => {
      const regexp = lines.shift()
      t.ok(regexp, 'we are expecting this line')
      t.ok(regexp.test(line), 'line matches ' + regexp)
    })
    .on('end', t.end)
})

test('verify amount of total requests', (t) => {
  t.plan(1)

  // arrange
  const connections = 10
  const pipelining = 2
  const result = {
    connections,
    pipelining,
    latency: {},
    requests: {
      sent: connections * pipelining
    },
    throughput: {
      average: 3319,
      mean: 3319,
      stddev: 0,
      min: 3318,
      max: 3318,
      total: 3318,
      p0_001: 3319,
      p0_01: 3319,
      p0_1: 3319,
      p1: 3319,
      p2_5: 3319,
      p10: 3319,
      p25: 3319,
      p50: 3319,
      p75: 3319,
      p90: 3319,
      p97_5: 3319,
      p99: 3319,
      p99_9: 3319,
      p99_99: 3319,
      p99_999: 3319
    }
  }

  // act
  const output = printResult(result, { })

  // assert
  const expectedRequests = connections * pipelining
  t.match(output.includes(`${expectedRequests} requests in`), true)
})

test('should not print when verbose(V=0) is false', (t) => {
  t.plan(1)

  const connections = 10
  const pipelining = 2
  const result = {
    connections,
    pipelining,
    latency: {},
    requests: {
      sent: connections * pipelining
    },
    throughput: {
      average: 3319,
      mean: 3319,
      stddev: 0,
      min: 3318,
      max: 3318,
      total: 3318,
      p0_001: 3319,
      p0_01: 3319,
      p0_1: 3319,
      p1: 3319,
      p2_5: 3319,
      p10: 3319,
      p25: 3319,
      p50: 3319,
      p75: 3319,
      p90: 3319,
      p97_5: 3319,
      p99: 3319,
      p99_9: 3319,
      p99_99: 3319,
      p99_999: 3319
    }
  }

  // act
  const output = printResult(result, { verbose: false })
  t.ok(output.split('\n').length === 2)
})

test('should print with color when color is supported', (t) => {
  t.plan(1)

  const connections = 10
  const pipelining = 2
  const result = {
    connections,
    pipelining,
    latency: {},
    requests: {
      sent: connections * pipelining
    },
    throughput: {
      average: 3319,
      mean: 3319,
      stddev: 0,
      min: 3318,
      max: 3318,
      total: 3318,
      p0_001: 3319,
      p0_01: 3319,
      p0_1: 3319,
      p1: 3319,
      p2_5: 3319,
      p10: 3319,
      p25: 3319,
      p50: 3319,
      p75: 3319,
      p90: 3319,
      p97_5: 3319,
      p99: 3319,
      p99_9: 3319,
      p99_99: 3319,
      p99_999: 3319
    }
  }

  const { FORCE_COLOR, NO_COLOR, COLOR, CI, COLORTERM } = process.env
  delete process.env.FORCE_COLOR
  delete process.env.NO_COLOR
  delete process.env.COLOR
  delete process.env.CI
  process.env.COLORTERM = 'truecolor'
  const outputStream = new Writable({
    write () {}
  })
  outputStream.isTTY = true

  // act
  const output = printResult(result, { outputStream })
  t.ok(ansiRegex().test(output))

  // cleanup
  process.env.FORCE_COLOR = FORCE_COLOR
  process.env.NO_COLOR = NO_COLOR
  process.env.COLOR = COLOR
  process.env.CI = CI
  process.env.COLORTERM = COLORTERM
})

test('should not print with any color when color is not supported', (t) => {
  t.plan(1)

  const connections = 10
  const pipelining = 2
  const result = {
    connections,
    pipelining,
    latency: {},
    requests: {
      sent: connections * pipelining
    },
    throughput: {
      average: 3319,
      mean: 3319,
      stddev: 0,
      min: 3318,
      max: 3318,
      total: 3318,
      p0_001: 3319,
      p0_01: 3319,
      p0_1: 3319,
      p1: 3319,
      p2_5: 3319,
      p10: 3319,
      p25: 3319,
      p50: 3319,
      p75: 3319,
      p90: 3319,
      p97_5: 3319,
      p99: 3319,
      p99_9: 3319,
      p99_99: 3319,
      p99_999: 3319
    }
  }

  const { FORCE_COLOR, NO_COLOR, COLOR, CI, COLORTERM } = process.env
  delete process.env.FORCE_COLOR
  delete process.env.NO_COLOR
  delete process.env.COLOR
  delete process.env.CI
  process.env.COLORTERM = 'truecolor'
  const outputStream = new Writable({
    write () {}
  })

  // act
  const output = printResult(result, { outputStream })
  t.ok(!ansiRegex().test(output))

  // cleanup
  process.env.FORCE_COLOR = FORCE_COLOR
  process.env.NO_COLOR = NO_COLOR
  process.env.COLOR = COLOR
  process.env.CI = CI
  process.env.COLORTERM = COLORTERM
})


================================================
FILE: test/progressTracker.test.js
================================================
'use strict'

const helper = require('./helper')
const test = require('tap').test
const { defaultMaxListeners } = require('events')
const { Writable } = require('stream')
const sinon = require('sinon')
const autocannon = require('../autocannon')
const { hasWorkerSupport } = require('../lib/util')

test(`should not emit warnings when using >= ${defaultMaxListeners} workers`, { skip: !hasWorkerSupport }, t => {
  const server = helper.startServer()

  const instance = autocannon({
    url: `http://localhost:${server.address().port}`,
    workers: defaultMaxListeners,
    duration: 1
  })

  setTimeout(() => {
    instance.stop()
    t.notOk(emitWarningSpy.called)
    emitWarningSpy.restore()
    t.end()
  }, 2000)

  const emitWarningSpy = sinon.spy(process, 'emitWarning')

  autocannon.track(instance, {
    outputStream: new Writable({
      write () {}
    })
  })
})


================================================
FILE: test/progressTracker.test.stub.js
================================================
'use strict'

const helper = require('./helper')
const test = require('tap').test
const progressTracker = require('../lib/progressTracker')
const autocannon = require('../autocannon')

test('progress tracker should throw if no instance is provided', t => {
  t.plan(1)
  try {
    progressTracker(null, {})
  } catch (error) {
    t.same(error.message, 'instance required for tracking')
  }
})

test('should work', t => {
  const server = helper.startServer({ statusCode: 404 })
  const instance = autocannon({
    url: `http://localhost:${server.address().port}`,
    pipelining: 2
  }, console.log)

  setTimeout(() => {
    instance.stop()
    t.end()
  }, 2000)

  autocannon.track(instance, {
    renderProgressBar: true,
    renderLatencyTable: true
  })
})

test('should work with amount', t => {
  const server = helper.startServer()
  const instance = autocannon({
    url: `http://localhost:${server.address().port}`,
    pipelining: 1,
    amount: 10
  }, process.stdout)

  setTimeout(() => {
    instance.stop()
    t.end()
  }, 2000)
  autocannon.track(instance, {
    renderProgressBar: true
  })
  t.pass()
})

test('should log mismatches', t => {
  const server = helper.startServer()
  const instance = autocannon({
    url: `http://localhost:${server.address().port}`,
    pipelining: 1,
    amount: 10,
    expectBody: 'modified'
  }, console.log)

  setTimeout(() => {
    instance.stop()
    t.end()
  }, 2000)
  autocannon.track(instance, {
    renderProgressBar: true
  })
  t.pass()
})

test('should log resets', t => {
  const server = helper.startServer()
  const instance = autocannon({
    url: `http://localhost:${server.address().port}`,
    connections: 1,
    amount: 10,
    requests: [
      { method: 'GET' },
      {
        method: 'GET',
        // falsey result will reset
        setupRequest: () => {}
      },
      { method: 'GET' }
    ]
  }, console.log)

  setTimeout(() => {
    instance.stop()
    t.end()
  }, 2000)
  autocannon.track(instance, {
    renderProgressBar: true
  })
  t.pass()
})


================================================
FILE: test/requestIterator.test.js
================================================
'use strict'

const test = require('tap').test
const helper = require('./helper')
const server = helper.startServer()
const RequestIterator = require('../lib/requestIterator')

test('request iterator should create requests with sensible defaults', (t) => {
  t.plan(3)

  const opts = server.address()

  let iterator = new RequestIterator(opts)

  t.same(iterator.currentRequest.requestBuffer,
    Buffer.from(`GET / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\n\r\n`),
    'request is okay')

  opts.requests = [{}]

  iterator = new RequestIterator(opts)

  t.same(iterator.currentRequest.requestBuffer,
    Buffer.from(`GET / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\n\r\n`),
    'request is okay')

  opts.requests = []

  iterator = new RequestIterator(opts)

  t.notOk(iterator.currentRequest, 'request doesn\'t exist')
})

test('request iterator should create requests with overwritten defaults', (t) => {
  t.plan(1)

  const opts = server.address()
  opts.method = 'POST'

  const iterator = new RequestIterator(opts)

  t.same(iterator.currentRequest.requestBuffer,
    Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\n\r\n`),
    'request is okay')
})

test('request iterator should use headers from requests', (t) => {
  t.plan(2)

  const opts = server.address()
  opts.requests = [
    {
      path: '/',
      method: 'POST',
      headers: {
        'content-type': 'application/json'
      },
      body: JSON.stringify({ foo: 'bar' })
    },
    {
      path: '/2',
      method: 'POST',
      headers: {
        'content-type': 'text/html'
      },
      body: JSON.stringify({ foo: 'bar' })
    }
  ]
  const iterator = new RequestIterator(opts)

  t.same(iterator.currentRequest.headers['content-type'], 'application/json')
  iterator.nextRequest()
  t.same(iterator.currentRequest.headers['content-type'], 'text/html')
})

test('request iterator should create requests with overwritten defaults', (t) => {
  t.plan(3)

  const opts = server.address()
  opts.method = 'POST'

  const requests = [
    {
      body: 'hello world'
    },
    {
      method: 'GET',
      body: 'modified'
    }
  ]

  const request1Res = Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nContent-Length: 11\r\n\r\nhello world`)
  const request2Res = Buffer.from(`GET / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nContent-Length: 8\r\n\r\nmodified`)

  opts.requests = requests

  const iterator = new RequestIterator(opts)

  t.same(iterator.currentRequest.requestBuffer, request1Res, 'request was okay')
  iterator.nextRequest()
  t.same(iterator.currentRequest.requestBuffer, request2Res, 'request was okay')
  iterator.nextRequest()
  t.same(iterator.currentRequest.requestBuffer, request1Res, 'request was okay')
})

test('request iterator should allow for overwriting the requests passed in, but still use overwritten defaults', (t) => {
  t.plan(5)

  const opts = server.address()
  opts.method = 'POST'

  const requests1 = [
    {
      body: 'hello world'
    },
    {
      method: 'GET',
      body: 'modified'
    }
  ]

  const requests2 = [
    {
      body: 'hell0 w0rld'
    }
  ]

  const request1Res = Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nContent-Length: 11\r\n\r\nhello world`)
  const request2Res = Buffer.from(`GET / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nContent-Length: 8\r\n\r\nmodified`)
  const request3Res = Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nContent-Length: 11\r\n\r\nhell0 w0rld`)

  opts.requests = requests1

  const iterator = new RequestIterator(opts)

  t.same(iterator.currentRequest.requestBuffer, request1Res, 'request was okay')
  iterator.nextRequest()
  t.same(iterator.currentRequest.requestBuffer, request2Res, 'request was okay')
  iterator.nextRequest()
  t.same(iterator.currentRequest.requestBuffer, request1Res, 'request was okay')

  iterator.setRequests(requests2)
  t.same(iterator.currentRequest.requestBuffer, request3Res, 'request was okay')
  iterator.nextRequest()
  t.same(iterator.currentRequest.requestBuffer, request3Res, 'request was okay')
})

test('request iterator should allow for rebuilding the current request', (t) => {
  t.plan(6)

  const opts = server.address()
  opts.method = 'POST'

  const requests1 = [
    {
      body: 'hello world'
    },
    {
      method: 'GET',
      body: 'modified'
    }
  ]

  const request1Res = Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nContent-Length: 11\r\n\r\nhello world`)
  const request2Res = Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nContent-Length: 8\r\n\r\nmodified`)
  const request3Res = Buffer.from(`GET / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nContent-Length: 8\r\n\r\nmodified`)
  const request4Res = Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nheader: modifiedHeader\r\nContent-Length: 8\r\n\r\nmodified`)
  const request5Res = Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nheader: modifiedHeader\r\n\r\n`)

  opts.requests = requests1

  const iterator = new RequestIterator(opts)
  t.same(iterator.currentRequest.requestBuffer, request1Res, 'request was okay')
  iterator.setBody('modified')
  t.same(iterator.currentRequest.requestBuffer, request2Res, 'request was okay')
  iterator.nextRequest() // verify it didn't affect the other request
  t.same(iterator.currentRequest.requestBuffer, request3Res, 'request was okay')
  iterator.nextRequest()
  t.same(iterator.currentRequest.requestBuffer, request2Res, 'request was okay')
  iterator.setHeaders({ header: 'modifiedHeader' })
  t.same(iterator.currentRequest.requestBuffer, request4Res, 'request was okay')
  iterator.setRequest() // this should build default request
  t.same(iterator.currentRequest.requestBuffer, request5Res, 'request was okay')
})

test('request iterator should not replace any [<id>] tags with generated IDs when calling move with idReplacement disabled', (t) => {
  t.plan(3)

  const opts = server.address()
  opts.path = '/[%3Cid%3E]'
  opts.method = 'POST'
  opts.body = '[<id>]'
  opts.requests = [{}]

  const iterator = new RequestIterator(opts)
  const result = iterator.currentRequest.requestBuffer.toString().trim()

  const path = result.split(' ')[1]
  t.equal(path, '/[%3Cid%3E]', '[<id>] should be present in path')

  const contentLength = result.split('Content-Length: ')[1].slice(0, 1)
  t.equal(contentLength, '6', 'Content-Length was incorrect')

  const body = result.split('Content-Length: 6')[1].trim()
  t.equal(body, '[<id>]', '[<id>] should be present in body')
})

test('request iterator should replace all [<id>] tags with generated IDs when calling move with idReplacement enabled', (t) => {
  t.plan(10)

  function isUrlSafe (string) {
    return /^[A-Za-z0-9\-_]+$/.test(string)
  }

  const opts = server.address()
  opts.method = 'POST'
  opts.path = '/[%3Cid%3E]'
  opts.body = '[<id>] [%3Cid%3E]'
  opts.requests = [{}]
  opts.idReplacement = true

  const iterator = new RequestIterator(opts)
  const first = iterator.currentRequest.requestBuffer.toString().trim()
  const firstPath = first.split(' ')[1]
  const firstId = firstPath.slice(1)

  t.equal(first.includes('[<id>]'), false, 'One or more [<id>] tags were not replaced in body')
  t.ok(first.includes('[%3Cid%3E]'), 'Encoded [<id>] tags should not be replaced in body')
  t.equal(firstPath.includes('[%3Cid%3E]'), false, 'One or more [<id>] tags were not replaced in path')
  t.ok(firstId.endsWith('0'), 'Generated ID should end with request number')
  t.ok(isUrlSafe(firstId), 'Generated ID should be URL-safe')

  iterator.nextRequest()
  const second = iterator.currentRequest.requestBuffer.toString().trim()
  const secondPath = second.split(' ')[1]
  const secondId = secondPath.slice(1)

  t.equal(second.includes('[<id>]'), false, 'One or more [<id>] tags were not replaced in body')
  t.ok(second.includes('[%3Cid%3E]'), 'Encoded [<id>] tags should not be replaced in body')
  t.equal(secondPath.includes('[%3Cid%3E]'), false, 'One or more [<id>] tags were not replaced in path')
  t.ok(secondId.endsWith('1'), 'Generated ID should end with a unique request number')
  t.ok(isUrlSafe(secondId), 'Generated ID should be URL-safe')
})

test('request iterator should invoke onResponse callback when set', (t) => {
  t.plan(9)

  const opts = server.address()
  opts.requests = [
    {
      onResponse: (status, body, context) => {
        t.same(status, 200)
        t.same(body, 'ok')
        t.same(context, {})
      }
    },
    {},
    {
      onResponse: (status, body, context) => {
        t.same(status, 201)
        t.same(body, '')
        t.same(context, {})
      }
    }
  ]

  const iterator = new RequestIterator(opts)
  iterator.recordBody(iterator.currentRequest, 200, 'ok')
  iterator.nextRequest()
  iterator.recordBody(iterator.currentRequest, 500, 'ignored')
  iterator.nextRequest()
  iterator.recordBody(iterator.currentRequest, 201, '')
  // will reset the iterator
  iterator.nextRequest()
  iterator.recordBody(iterator.currentRequest, 200, 'ok')
})

test('request iterator should properly mutate requests if a setupRequest function is located', (t) => {
  t.plan(6)

  const opts = server.address()
  opts.method = 'POST'

  let i = 0

  opts.requests = [
    {
      body: 'hello world',
      setupRequest: req => {
        req.body += i++
        return req
      }
    },
    {
      method: 'POST',
      body: 'modified',
      setupRequest: req => {
        req.method = 'GET'
        return req
      }
    }
  ]

  const request1Res = Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nContent-Length: 12\r\n\r\nhello world0`)
  const request2Res = Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nContent-Length: 9\r\n\r\nmodified1`)
  const request3Res = Buffer.from(`GET / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nContent-Length: 8\r\n\r\nmodified`)
  const request4Res = Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nContent-Length: 9\r\n\r\nmodified2`)
  const request5Res = Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nheader: modifiedHeader\r\nContent-Length: 9\r\n\r\nmodified3`)
  const request6Res = Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nheader: modifiedHeader\r\n\r\n`)

  const iterator = new RequestIterator(opts)
  t.same(iterator.currentRequest.requestBuffer, request1Res, 'request was okay')
  iterator.setBody('modified')
  t.same(iterator.currentRequest.requestBuffer, request2Res, 'request was okay')
  iterator.nextRequest() // verify it didn't affect the other request
  t.same(iterator.currentRequest.requestBuffer, request3Res, 'request was okay')
  iterator.nextRequest()
  t.same(iterator.currentRequest.requestBuffer, request4Res, 'request was okay')
  iterator.setHeaders({ header: 'modifiedHeader' })
  t.same(iterator.currentRequest.requestBuffer, request5Res, 'request was okay')
  iterator.setRequest() // this should build default request
  t.same(iterator.currentRequest.requestBuffer, request6Res, 'request was okay')
})

test('request iterator should reset when setupRequest returns nothing', (t) => {
  t.plan(12)

  const opts = server.address()
  opts.method = 'POST'

  let i = 0

  opts.requests = [
    { method: 'GET' },
    {
      body: 'hello world',
      setupRequest: req => ++i >= 2 ? null : req
    },
    { method: 'PUT' }
  ]

  const requestGET = `GET / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\n\r\n`
  const requestPUT = `PUT / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\n\r\n`
  const requestPOST = `POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nContent-Length: 11\r\n\r\nhello world`

  const iterator = new RequestIterator(opts)
  t.equal(iterator.resetted, false)
  // first GET, i is 0
  t.same(iterator.currentRequest.requestBuffer.toString(), requestGET, 'request 1 was okay')
  iterator.nextRequest()
  // first POST, i becomes 1
  t.equal(iterator.resetted, false)
  t.same(iterator.currentRequest.requestBuffer.toString(), requestPOST, 'request 2 was okay')
  iterator.nextRequest()
  // first PUT, i is 1
  t.equal(iterator.resetted, false)
  t.same(iterator.currentRequest.requestBuffer.toString(), requestPUT, 'request 3 was okay')
  iterator.nextRequest()
  // second GET, i is 1
  t.equal(iterator.resetted, false)
  t.same(iterator.currentRequest.requestBuffer.toString(), requestGET, 'request 4 was okay')
  iterator.nextRequest()
  // second POST, i becomes 2, pipeline is reset
  t.equal(iterator.resetted, true)
  t.same(iterator.currentRequest.requestBuffer.toString(), requestGET, 'request 5 was okay')
  iterator.nextRequest()
  // third POST, i becomes 3, pipeline is reset
  t.equal(iterator.resetted, true)
  t.same(iterator.currentRequest.requestBuffer.toString(), requestGET, 'request 6 was okay')
})

test('request iterator should throw when first setupRequest returns nothing', (t) => {
  t.plan(4)

  const opts = server.address()
  opts.method = 'POST'

  let i = 0
  opts.requests = [{ body: 'hello world', setupRequest: req => ++i > 1 ? null : req }]
  const requestPOST = `POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nContent-Length: 11\r\n\r\nhello world`

  const iterator = new RequestIterator(opts)
  t.equal(iterator.resetted, false)
  // first POST, i is 0
  t.same(iterator.currentRequest.requestBuffer.toString(), requestPOST, 'request 1 was okay')
  t.throws(() => iterator.nextRequest(), 'First setupRequest() failed did not returned valid request. Stopping')
  t.equal(iterator.resetted, false)
})

test('request iterator should maintain context while looping on requests', (t) => {
  t.plan(4)

  const opts = server.address()
  opts.requests = [
    {
      setupRequest: (req, context) => {
        t.same(context, {}, 'context was supposed to be empty for first request')
        context.num = 1
        context.init = true
        return req
      }
    },
    {
      setupRequest: (req, context) => {
        t.same(context, { num: 1, init: true }, 'context was supposed to be initialized for second request')
        context.num++
        return req
      }
    },
    {
      setupRequest: (req, context) => {
        t.same(context, { num: 2, init: true }, 'context was supposed to be initialized for third request')
        context.num++
        return req
      }
    }
  ]

  const iterator = new RequestIterator(opts)
  iterator.nextRequest()
  iterator.nextRequest()
  // will reset the iterator
  iterator.nextRequest()
})

test('request iterator should return instance of RequestIterator', t => {
  t.plan(1)
  const caller = {}
  const opts = server.address()

  const iterator = RequestIterator.call(caller, opts)
  t.type(iterator, RequestIterator)
})

test('request iterator should return next request buffer', (t) => {
  t.plan(1)

  const opts = server.address()
  opts.method = 'POST'

  const requests = [
    {
      body: 'hello world'
    },
    {
      method: 'GET',
      body: 'modified'
    }
  ]

  const request2Res = Buffer.from(`GET / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nContent-Length: 8\r\n\r\nmodified`)

  opts.requests = requests

  const iterator = new RequestIterator(opts)
  const buffer = iterator.nextRequestBuffer()
  t.same(request2Res, buffer, 'request is okay')
})

test('request iterator should initialize context from options', (t) => {
  t.plan(3)

  const opts = server.address()
  opts.initialContext = { foo: 'bar' }
  opts.requests = [
    {
      setupRequest: (req, context) => {
        t.same(context, { foo: 'bar' }, 'context should be initialized from opts')
        context.baz = 'qux'
        return req
      }
    },
    {
      setupRequest: (req, context) => {
        t.same(context, { foo: 'bar', baz: 'qux' }, 'context should contain updated data')
        return req
      }
    }
  ]

  const iterator = new RequestIterator(opts)
  iterator.nextRequest()
  // will reset and reinit context
  iterator.nextRequest()
})

test('request iterator should use the same headers when set', (t) => {
  t.plan(6)

  const opts = server.address()
  opts.method = 'POST'

  let i = 0

  opts.requests = [
    {
      body: 'hello world',
      setupRequest: req => {
        req.body += i++
        return req
      }
    },
    {
      method: 'POST',
      body: 'modified',
      setupRequest: req => {
        req.method = 'GET'
        return req
      }
    }
  ]

  const request1Res = Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nAccess-Control-Allow-Credentials: true\r\nContent-Length: 12\r\n\r\nhello world1`)
  const request2Res = Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nAccess-Control-Allow-Credentials: true\r\nContent-Length: 12\r\n\r\nhello world1`)
  const request3Res = Buffer.from(`GET / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nAccess-Control-Allow-Credentials: true\r\nContent-Length: 8\r\n\r\nmodified`)
  const request4Res = Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nAccess-Control-Allow-Credentials: true\r\nContent-Length: 12\r\n\r\nhello world2`)
  const request5Res = Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nAccess-Control-Allow-Credentials: true\r\nContent-Length: 12\r\n\r\nhello world2`)
  const request6Res = Buffer.from(`POST / HTTP/1.1\r\nHost: localhost:${server.address().port}\r\nConnection: keep-alive\r\nAccess-Control-Allow-Credentials: true\r\n\r\n`)

  const iterator = new RequestIterator(opts)
  iterator.setHeaders({ 'Access-Control-Allow-Credentials': 'true' })
  t.same(iterator.currentRequest.requestBuffer, request1Res, iterator.currentRequest.requestBuffer.toString())
  t.same(iterator.currentRequest.requestBuffer, request2Res, iterator.currentRequest.requestBuffer.toString())
  iterator.nextRequest()
  t.same(iterator.currentRequest.requestBuffer, request3Res, iterator.currentRequest.requestBuffer.toString())
  iterator.nextRequest()
  t.same(iterator.currentRequest.requestBuffer, request4Res, iterator.currentRequest.requestBuffer.toString())
  t.same(iterator.currentRequest.requestBuffer, request5Res, iterator.currentRequest.requestBuffer.toString())
  iterator.setRequest()
  t.same(iterator.currentRequest.requestBuffer, request6Res, iterator.currentRequest.requestBuffer.toString())
})

test('request iterator should invoke onResponse callback with headers in it', (t) => {
  t.plan(4)

  const opts = server.address()
  opts.requests = [
    {
      onResponse: (status, body, context, headers) => {
        t.same(status, 200)
        t.same(body, 'ok')
        t.same(context, {})
        t.same(headers, { 'set-cookie': 123 })
      }
    }
  ]

  const iterator = new RequestIterator(opts)
  iterator.recordBody(iterator.currentRequest, 200, 'ok', ['set-cookie', 123])
  iterator.nextRequest()

  t.end()
})


================================================
FILE: test/run.test.js
================================================
'use strict'

const os = require('os')
const path = require('path')
const test = require('tap').test
const initJob = require('../lib/init')
const defaultOptions = require('../lib/defaultOptions')
const helper = require('./helper')
const server = helper.startServer()

test('init', (t) => {
  initJob({
    url: 'http://localhost:' + server.address().port,
    connections: 2,
    duration: 2,
    title: 'title321'
  }, function (err, result) {
    t.error(err)

    t.ok(result.duration >= 2, 'duration is at least 2s')
    t.equal(result.title, 'title321', 'title should be what was passed in')
    t.equal(result.connections, 2, 'connections is the same')
    t.equal(result.pipelining, 1, 'pipelining is the default')

    t.ok(result.latency, 'latency exists')
    t.type(result.latency.average, 'number', 'latency.average exists')
    t.type(result.latency.stddev, 'number', 'latency.stddev exists')
    t.ok(result.latency.min >= 0, 'latency.min exists')
    t.type(result.latency.max, 'number', 'latency.max exists')
    t.type(result.latency.p2_5, 'number', 'latency.p2_5 (2.5%) exists')
    t.type(result.latency.p50, 'number', 'latency.p50 (50%) exists')
    t.type(result.latency.p97_5, 'number', 'latency.p97_5 (97.5%) exists')
    t.type(result.latency.p99, 'number', 'latency.p99 (99%) exists')

    t.ok(result.requests, 'requests exists')
    t.type(result.requests.average, 'number', 'requests.average exists')
    t.type(result.requests.stddev, 'number', 'requests.stddev exists')
    t.type(result.requests.min, 'number', 'requests.min exists')
    t.type(result.requests.max, 'number', 'requests.max exists')
    t.ok(result.requests.total >= result.requests.average * 2 / 100 * 95, 'requests.total exists')
    t.type(result.requests.sent, 'number', 'sent exists')
    t.ok(result.requests.sent >= result.requests.total, 'total requests made should be more than or equal to completed requests total')
    t.type(result.requests.p1, 'number', 'requests.p1 (1%) exists')
    t.type(result.requests.p2_5, 'number', 'requests.p2_5 (2.5%) exists')
    t.type(result.requests.p50, 'number', 'requests.p50 (50%) exists')
    t.type(result.requests.p97_5, 'number', 'requests.p97_5 (97.5%) exists')

    t.ok(result.throughput, 'throughput exists')
    t.type(result.throughput.average, 'number', 'throughput.average exists')
    t.type(result.throughput.stddev, 'number', 'throughput.stddev exists')
    t.type(result.throughput.min, 'number', 'throughput.min exists')
    t.type(result.throughput.max, 'number', 'throughput.max exists')
    t.ok(result.throughput.total >= result.throughput.average * 2 / 100 * 95, 'throughput.total exists')
    t.type(result.throughput.p1, 'number', 'throughput.p1 (1%) exists')
    t.type(result.throughput.p2_5, 'number', 'throughput.p2_5 (2.5%) exists')
    t.type(result.throughput.p50, 'number', 'throughput.p50 (50%) exists')
    t.type(result.throughput.p97_5, 'number', 'throughput.p97_5 (97.5%) exists')

    t.ok(result.start, 'start time exists')
    t.ok(result.finish, 'finish time exists')

    t.equal(result.errors, 0, 'no errors')
    t.equal(result.mismatches, 0, 'no mismatches')
    t.equal(result.resets, 0, 'no resets')

    t.equal(result['1xx'], 0, '1xx codes')
    t.equal(result['2xx'], result.requests.total, '2xx codes')
    t.equal(result['3xx'], 0, '3xx codes')
    t.equal(result['4xx'], 0, '4xx codes')
    t.equal(result['5xx'], 0, '5xx codes')
    t.equal(result.non2xx, 0, 'non 2xx codes')

    t.end()
  })
})

test('tracker.stop()', (t) => {
  const tracker = initJob({
    url: 'http://localhost:' + server.address().port,
    connections: 2,
    duration: 2
  }, function (err, result) {
    t.error(err)

    t.ok(result.duration < 5, 'duration is lower because of stop')
    t.notOk(result.title, 'title should not exist when not passed in')
    t.equal(result.connections, 2, 'connections is the same')
    t.equal(result.pipelining, 1, 'pipelining is the default')

    t.ok(result.latency, 'latency exists')
    t.type(result.latency.average, 'number', 'latency.average exists')
    t.type(result.latency.stddev, 'number', 'latency.stddev exists')
    t.ok(result.latency.min >= 0, 'latency.min exists')
    t.type(result.latency.max, 'number', 'latency.max exists')
    t.type(result.latency.p2_5, 'number', 'latency.p2_5 (2.5%) exists')
    t.type(result.latency.p50, 'number', 'latency.p50 (50%) exists')
    t.type(result.latency.p97_5, 'number', 'latency.p97_5 (97.5%) exists')
    t.type(result.latency.p99, 'number', 'latency.p99 (99%) exists')

    t.ok(result.requests, 'requests exists')
    t.type(result.requests.average, 'number', 'requests.average exists')
    t.type(result.requests.stddev, 'number', 'requests.stddev exists')
    t.type(result.requests.min, 'number', 'requests.min exists')
    t.type(result.requests.max, 'number', 'requests.max exists')
    t.ok(result.requests.total >= result.requests.average * 2 / 100 * 95, 'requests.total exists')
    t.type(result.requests.sent, 'number', 'sent exists')
    t.ok(result.requests.sent >= result.requests.total, 'total requests made should be more than or equal to completed requests total')
    t.type(result.requests.p1, 'number', 'requests.p1 (1%) exists')
    t.type(result.requests.p2_5, 'number', 'requests.p2_5 (2.5%) exists')
    t.type(result.requests.p50, 'number', 'requests.p50 (50%) exists')
    t.type(result.requests.p97_5, 'number', 'requests.p97_5 (97.5%) exists')

    t.ok(result.throughput, 'throughput exists')
    t.type(result.throughput.average, 'number', 'throughput.average exists')
    t.type(result.throughput.stddev, 'number', 'throughput.stddev exists')
    t.type(result.throughput.min, 'number', 'throughput.min exists')
    t.type(result.throughput.max, 'number', 'throughput.max exists')
    t.ok(result.throughput.total >= result.throughput.average * 2 / 100 * 95, 'throughput.total exists')
    t.type(result.throughput.p1, 'number', 'throughput.p1 (1%) exists')
    t.type(result.throughput.p2_5, 'number', 'throughput.p2_5 (2.5%) exists')
    t.type(result.throughput.p50, 'number', 'throughput.p50 (50%) exists')
    t.type(result.throughput.p97_5, 'number', 'throughput.p97_5 (97.5%) exists')

    t.ok(result.start, 'start time exists')
    t.ok(result.finish, 'finish time exists')

    t.equal(result.errors, 0, 'no errors')
    t.equal(result.mismatches, 0, 'no mismatches')

    t.equal(result['1xx'], 0, '1xx codes')
    t.equal(result['2xx'], result.requests.total, '2xx codes')
    t.equal(result['3xx'], 0, '3xx codes')
    t.equal(result['4xx'], 0, '4xx codes')
    t.equal(result['5xx'], 0, '5xx codes')
    t.equal(result.non2xx, 0, 'non 2xx codes')

    t.end()
  })

  t.ok(tracker.opts, 'opts exist on tracker')

  setTimeout(() => {
    tracker.stop()
  }, 1000)
})

test('requests.min should be 0 when there are no successful requests', (t) => {
  initJob({
    url: 'nonexistent',
    connections: 1,
    amount: 1
  }, function (err, result) {
    t.error(err)
    t.equal(result.requests.min, 0, 'requests.min should be 0')
    t.end()
  })
})

test('run should callback with an error with an invalid connections factor', (t) => {
  t.plan(2)

  initJob({
    url: 'http://localhost:' + server.address().port,
    connections: -1
  }, function (err, result) {
    t.ok(err, 'invalid connections should cause an error')
    t.notOk(result, 'results should not exist')
    t.end()
  })
})

test('run should callback with an error with an invalid pipelining factor', (t) => {
  t.plan(2)

  initJob({
    url: 'http://localhost:' + server.address().port,
    pipelining: -1
  }, function (err, result) {
    t.ok(err, 'invalid pipelining should cause an error')
    t.notOk(result, 'results should not exist')
    t.end()
  })
})

test('run should callback with an error with an invalid bailout', (t) => {
  t.plan(2)

  initJob({
    url: 'http://localhost:' + server.address().port,
    bailout: -1
  }, function (err, result) {
    t.ok(err, 'invalid bailout should cause an error')
    t.notOk(result, 'results should not exist')
    t.end()
  })
})

test('run should callback with an error with an invalid duration', (t) => {
  t.plan(2)

  initJob({
    url: 'http://localhost:' + server.address().port,
    duration: -1
  }, function (err, result) {
    t.ok(err, 'invalid duration should cause an error')
    t.notOk(result, 'results should not exist')
    t.end()
  })
})

test('run should callback with an error when no url is passed in', (t) => {
  t.plan(2)

  initJob({}, function (err, result) {
    t.ok(err, 'no url should cause an error')
    t.notOk(result, 'results should not exist')
    t.end()
  })
})

test('run should callback with an error after a bailout', (t) => {
  t.plan(2)

  initJob({
    url: 'http://localhost:4', // 4 = first unassigned port: https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers
    bailout: 1
  }, function (err, result) {
    t.error(err)
    t.ok(result, 'results should not exist')
    t.end()
  })
})

test('run should callback with an error using expectBody and requests', (t) => {
  t.plan(2)

  initJob({
    url: 'http://localhost:' + server.address().port,
    requests: [{ body: 'something' }],
    expectBody: 'hello'
  }, function (err, result) {
    t.ok(err, 'expectBody used with requests should cause an error')
    t.notOk(result, 'results should not exist')
    t.end()
  })
})

test('run should handle context correctly', (t) => {
  t.plan(1)

  initJob({
    url: 'http://localhost:' + server.address().port,
    connections: 1,
    amount: 1,
    initialContext: { init: 'context' },
    requests: [{
      setupRequest: (req, context) => {
        t.same(context, { init: 'context' }, 'context should be initialized from opts')
        return req
      }
    }]
  })
})

test('run should allow users to enter timestrings to be used for duration', (t) => {
  t.plan(3)

  const instance = initJob({
    url: 'http://localhost:' + server.address().port,
    duration: '10m'
  }, function (err, result) {
    t.error(err)
    t.ok(result, 'results should exist')
    t.end()
  })

  t.equal(instance.opts.duration, 10 * 60, 'duration should have been parsed to be 600 seconds (10m)')

  setTimeout(() => {
    instance.stop()
  }, 500)
})

test('run should recognise valid urls without http at the start', (t) => {
  t.plan(3)

  initJob({
    url: 'localhost:' + server.address().port,
    duration: 1
  }, (err, res) => {
    t.error(err)
    t.ok(res, 'results should exist')
    t.equal(res.url, 'http://localhost:' + server.address().port, 'url should have http:// added to start')
    t.end()
  })
})

test('run should produce count of mismatches with expectBody set', (t) => {
  t.plan(2)

  initJob({
    url: 'http://localhost:' + server.address().port,
    expectBody: 'body will not be this',
    maxOverallRequests: 10,
    timeout: 100
  }, function (err, result) {
    t.error(err)
    t.equal(result.mismatches, 10)
    t.end()
  })
})

test('run should produce 0 mismatches with expectBody set and matches', (t) => {
  t.plan(2)

  const responseBody = 'hello dave'
  const server = helper.startServer({ body: responseBody })

  initJob({
    url: 'http://localhost:' + server.address().port,
    expectBody: responseBody,
    maxOverallRequests: 10
  }, function (err, result) {
    t.error(err)
    t.equal(result.mismatches, 0)
    t.end()
  })
})

test('run should produce count of mismatches with verifyBody set', (t) => {
  t.plan(2)

  initJob({
    url: 'http://localhost:' + server.address().port,
    verifyBody: function () {
      return false
    },
    maxOverallRequests: 10,
    timeout: 100
  }, function (err, result) {
    t.error(err)
    t.equal(result.mismatches, 10)
    t.end()
  })
})

test('run should produce 0 mismatches with verifyBody set and return true', (t) => {
  t.plan(2)

  const responseBody = 'hello dave'
  const server = helper.startServer({ body: responseBody })

  initJob({
    url: 'http://localhost:' + server.address().port,
    verifyBody: function (body) {
      return body.indexOf('hello') > -1
    },
    maxOverallRequests: 10
  }, function (err, result) {
    t.error(err)
    t.equal(result.mismatches, 0)
    t.end()
  })
})

test('run should accept a unix socket/windows pipe', (t) => {
  t.plan(11)

  const socketPath = process.platform === 'win32'
    ? path.join('\\\\?\\pipe', process.cwd(), 'autocannon-' + Date.now())
    : path.join(os.tmpdir(), 'autocannon-' + Date.now() + '.sock')

  helper.startServer({ socketPath })

  initJob({
    url: 'localhost',
    socketPath,
    connections: 2,
    duration: 2
  }, (err, result) => {
    t.error(err)
    t.ok(result, 'results should exist')
    t.equal(result.socketPath, socketPath, 'socketPath should be included in result')
    t.ok(result.requests.total > 0, 'should make at least one request')

    if (process.platform === 'win32') {
      // On Windows a few errors are expected. We'll accept a 1% error rate on
      // the pipe.
      t.ok(result.errors / result.requests.total < 0.01, `should have less than 1% errors on Windows (had ${result.errors} errors)`)
    } else {
      t.equal(result.errors, 0, 'no errors')
    }

    t.equal(result['1xx'], 0, '1xx codes')
    t.equal(result['2xx'], result.requests.total, '2xx codes')
    t.equal(result['3xx'], 0, '3xx codes')
    t.equal(result['4xx'], 0, '4xx codes')
    t.equal(result['5xx'], 0, '5xx codes')
    t.equal(result.non2xx, 0, 'non 2xx codes')
    t.end()
  })
})

for (let i = 1; i <= 5; i++) {
  test(`run should count all ${i}xx status codes`, (t) => {
    const server = helper.startServer({ statusCode: i * 100 + 2 })

    initJob({
      url: `http://localhost:${server.address().port}`,
      connections: 2,
      duration: 2
    }, (err, result) => {
      t.error(err)

      t.ok(result[`${i}xx`], `${i}xx status codes recorded`)

      t.ok(result.latency, 'latency exists')
      t.ok(!Number.isNaN(result.latency.average), 'latency.average is not NaN')
      t.type(result.latency.average, 'number', 'latency.average exists')
      t.type(result.latency.stddev, 'number', 'latency.stddev exists')
      t.ok(result.latency.min >= 0, 'latency.min exists')
      t.type(result.latency.max, 'number', 'latency.max exists')
      t.type(result.latency.p2_5, 'number', 'latency.p2_5 (2.5%) exists')
      t.type(result.latency.p50, 'number', 'latency.p50 (50%) exists')
      t.type(result.latency.p97_5, 'number', 'latency.p97_5 (97.5%) exists')
      t.type(result.latency.p99, 'number', 'latency.p99 (99%) exists')

      t.ok(result.throughput, 'throughput exists')
      t.ok(!Number.isNaN(result.throughput.average), 'throughput.average is not NaN')
      t.type(result.throughput.average, 'number', 'throughput.average exists')
      t.type(result.throughput.stddev, 'number', 'throughput.stddev exists')
      t.type(result.throughput.min, 'number', 'throughput.min exists')
      t.type(result.throughput.max, 'number', 'throughput.max exists')
      t.ok(result.throughput.total >= result.throughput.average * 2 / 100 * 95, 'throughput.total exists')
      t.type(result.throughput.p1, 'number', 'throughput.p1 (1%) exists')
      t.type(result.throughput.p2_5, 'number', 'throughput.p2_5 (2.5%) exists')
      t.type(result.throughput.p50, 'number', 'throughput.p50 (50%) exists')
      t.type(result.throughput.p97_5, 'number', 'throughput.p97_5 (97.5%) exists')

      t.end()
    })
  })
}

test('run should not modify default options', (t) => {
  const origin = Object.assign({}, defaultOptions)
  initJob({
    url: 'http://localhost:' + server.address().port,
    connections: 2,
    duration: 2
  }, function (err, result) {
    t.error(err)
    t.same(defaultOptions, origin, 'calling run function does not modify default options')
    t.end()
  })
})

test('run will exclude non 2xx stats from latency and throughput averages if excludeErrorStats is true', (t) => {
  const server = helper.startServer({ statusCode: 404 })

  initJob({
    url: `http://localhost:${server.address().port}`,
    connections: 2,
    duration: 2,
    excludeErrorStats: true
  }, (err, result) => {
    t.error(err)

    t.equal(result['1xx'], 0, '1xx codes')
    t.equal(result['2xx'], 0, '2xx codes')
    t.equal(result['3xx'], 0, '3xx codes')
    t.equal(result['4xx'], result.requests.total, '4xx codes')
    t.equal(result['5xx'], 0, '5xx codes')
    t.equal(result.non2xx, result.requests.total, 'non 2xx codes')

    t.ok(result.latency, 'latency exists')
    t.equal(result.latency.average, 0, 'latency.average should be 0')
    t.equal(result.latency.stddev, 0, 'latency.stddev should be 0')
    t.equal(result.latency.min, 0, 'latency.min should be 0')
    t.equal(result.latency.max, 0, 'latency.max should be 0')
    t.equal(result.latency.p1, 0, 'latency.p1 (1%) should be 0')
    t.equal(result.latency.p2_5, 0, 'latency.p2_5 (2.5%) should be 0')
    t.equal(result.latency.p50, 0, 'latency.p50 (50%) should be 0')
    t.equal(result.latency.p97_5, 0, 'latency.p97_5 (97.5%) should be 0')
    t.equal(result.latency.p99, 0, 'latency.p99 (99%) should be 0')

    t.ok(result.throughput, 'throughput exists')
    t.equal(result.throughput.average, 0, 'throughput.average should be 0')
    t.equal(result.throughput.stddev, 0, 'throughput.stddev should be 0')
    t.equal(result.throughput.min, 0, 'throughput.min should be 0')
    t.equal(result.throughput.max, 0, 'throughput.max should be 0')
    t.equal(result.throughput.total, 0, 'throughput.total should be 0')
    t.equal(result.throughput.p1, 0, 'throughput.p1 (1%) should be 0')
    t.equal(result.throughput.p2_5, 0, 'throughput.p2_5 (2.5%) should be 0')
    t.equal(result.throughput.p50, 0, 'throughput.p50 (50%) should be 0')
    t.equal(result.throughput.p97_5, 0, 'throughput.p97_5 (97.5%) should be 0')

    t.end()
  })
})

test('tracker will emit reqError with error message on timeout', (t) => {
  t.plan(2)

  const server = helper.startTimeoutServer()

  const tracker = initJob({
    url: `http://localhost:${server.address().port}`,
    connections: 1,
    duration: 5,
    timeout: 2,
    bailout: 1,
    excludeErrorStats: true
  })

  tracker.once('reqError', (err) => {
    t.type(err, Error, 'reqError should pass an Error to listener')
    t.equal(err.message, 'request timed out', 'error should indicate timeout')
    tracker.stop()
  })
})

test('tracker will emit reqError with error message on error', (t) => {
  t.plan(1)

  const server = helper.startSocketDestroyingServer()

  const tracker = initJob({
    url: `http://localhost:${server.address().port}`,
    connections: 10,
    duration: 15,
    method: 'POST',
    body: 'hello',
    excludeErrorStats: true
  })

  tracker.once('reqError', (err) => {
    console.log(err)
    t.type(err, Error, 'reqError should pass an Error to listener')
    tracker.stop()
  })
})

test('tracker will emit reqMismatch when body does not match expectBody', (t) => {
  t.plan(2)

  const responseBody = 'hello world'
  const server = helper.startServer({ body: responseBody })

  const expectBody = 'goodbye world'

  const tracker = initJob({
    url: `http://localhost:${server.address().port}`,
    connections: 10,
    duration: 15,
    method: 'GET',
    body: 'hello',
    expectBody
  })

  tracker.once('reqMismatch', (bodyStr) => {
    t.equal(bodyStr, responseBody)
    t.not(bodyStr, expectBody)
    tracker.stop()
  })
})

test('tracker will emit tick with current counter value', (t) => {
  t.plan(1)

  const server = helper.startSocketDestroyingServer()

  const tracker = initJob({
    url: `http://localhost:${server.address().port}`,
    connections: 10,
    duration: 10
  })

  tracker.once('tick', (counter) => {
    t.type(counter, 'object')
    tracker.stop()
  })
})

test('throw if connections is greater than amount', (t) => {
  t.plan(1)

  const server = helper.startSocketDestroyingServer()

  t.throws(function () {
    initJob({
      url: `http://localhost:${server.address().port}`,
      connections: 10,
      amount: 1,
      excludeErrorStats: true
    }, () => {})
  })
})

test('run promise', (t) => {
  initJob({
    url: 'http://localhost:' + server.address().port,
    connections: 2,
    duration: 2,
    title: 'title321'
  }).then(result => {
    t.ok(result.duration >= 2, 'duration is at least 2s')
    t.equal(result.title, 'title321', 'title should be what was passed in')
    t.equal(result.connections, 2, 'connections is the same')
    t.equal(result.pipelining, 1, 'pipelining is the default')

    t.ok(result.latency, 'latency exists')
    t.type(result.latency.average, 'number', 'latency.average exists')
    t.type(result.latency.stddev, 'number', 'latency.stddev exists')
    t.ok(result.latency.min >= 0, 'latency.min exists')
    t.type(result.latency.max, 'number', 'latency.max exists')
    t.type(result.latency.p2_5, 'number', 'latency.p2_5 (2.5%) exists')
    t.type(result.latency.p50, 'number', 'latency.p50 (50%) exists')
    t.type(result.latency.p97_5, 'number', 'latency.p97_5 (97.5%) exists')
    t.type(result.latency.p99, 'number', 'latency.p99 (99%) exists')

    t.ok(result.requests, 'requests exists')
    t.type(result.requests.average, 'number', 'requests.average exists')
    t.type(result.requests.stddev, 'number', 'requests.stddev exists')
    t.type(result.requests.min, 'number', 'requests.min exists')
    t.type(result.requests.max, 'number', 'requests.max exists')
    t.ok(result.requests.total >= result.requests.average * 2 / 100 * 95, 'requests.total exists')
    t.type(result.requests.sent, 'number', 'sent exists')
    t.ok(result.requests.sent >= result.requests.total, 'total requests made should be more than or equal to completed requests total')
    t.type(result.requests.p1, 'number', 'requests.p1 (1%) exists')
    t.type(result.requests.p2_5, 'number', 'requests.p2_5 (2.5%) exists')
    t.type(result.requests.p50, 'number', 'requests.p50 (50%) exists')
    t.type(result.requests.p97_5, 'number', 'requests.p97_5 (97.5%) exists')

    t.ok(result.throughput, 'throughput exists')
    t.type(result.throughput.average, 'number', 'throughput.average exists')
    t.type(result.throughput.stddev, 'number', 'throughput.stddev exists')
    t.type(result.throughput.min, 'number', 'throughput.min exists')
    t.type(result.throughput.max, 'number', 'throughput.max exists')
    t.ok(result.throughput.total >= result.throughput.average * 2 / 100 * 95, 'throughput.total exists')
    t.type(result.throughput.p1, 'number', 'throughput.p1 (1%) exists')
    t.type(result.throughput.p2_5, 'number', 'throughput.p2_5 (2.5%) exists')
    t.type(result.throughput.p50, 'number', 'throughput.p50 (50%) exists')
    t.type(result.throughput.p97_5, 'number', 'throughput.p97_5 (97.5%) exists')

    t.ok(result.start, 'start time exists')
    t.ok(result.finish, 'finish time exists')

    t.equal(result.errors, 0, 'no errors')
    t.equal(result.resets, 0, 'no resets')

    t.equal(result['1xx'], 0, '1xx codes')
    t.equal(result['2xx'], result.requests.total, '2xx codes')
    t.equal(result['3xx'], 0, '3xx codes')
    t.equal(result['4xx'], 0, '4xx codes')
    t.equal(result['5xx'], 0, '5xx codes')
    t.equal(result.non2xx, 0, 'non 2xx codes')

    t.end()
  })
})

test('should throw if duration is not a number nor a string', t => {
  t.plan(1)
  const server = helper.startServer()
  initJob({
    url: 'http://localhost:' + server.address().port,
    connections: 2,
    duration: ['foobar'],
    title: 'title321'
  })
    .then((result) => {
      t.fail()
    })
    .catch((err) => {
      t.equal(err.message, 'duration entered was in an invalid format')
    })
})

test('should emit error', t => {
  t.plan(1)
  const server = helper.startServer()
  const tracker = initJob({
    url: `http://unknownhost:${server.address().port}`,
    connections: 1,
    timeout: 100,
    forever: true,
    form: {
      param1: {
        type: 'string',
        value: null // this will trigger an error
      }
    }
  })

  tracker.once('error', (error) => {
    t.equal(error.message, 'A \'type\' key with value \'text\' or \'file\' should be specified')
    t.end()
  })
})

test('should throw if timeout is less than zero', t => {
  t.plan(1)
  const server = helper.startServer()
  initJob({
    url: 'http://localhost:' + server.address().port,
    connections: 2,
    timeout: -1,
    title: 'title321'
  })
    .then((result) => {
      t.fail()
    })
    .catch((err) => {
      t.equal(err.message, 'timeout must be greater than 0')
    })
})

test('should handle duration in string format', t => {
  t.plan(1)
  const server = helper.startServer()
  initJob({
    url: 'http://localhost:' + server.address().port,
    connections: 2,
    duration: '1',
    title: 'title321'
  }).then((result) => {
    t.pass()
  })
})

test('should count resets', t => {
  t.plan(1)
  const server = helper.startServer()
  initJob({
    url: 'http://localhost:' + server.address().port,
    connections: 1,
    amount: 10,
    requests: [
      { method: 'GET' },
      { method: 'PUT' },
      {
        method: 'POST',
        // falsey result will reset
        setupRequest: () => {}
      }
    ]
  }).then((result) => {
    t.equal(result.resets, 4)
    t.end()
  })
})

test('should get onResponse callback invoked even when there is no body', async t => {
  t.plan(4)
  const server = helper.startServer({ responses: [{ statusCode: 200, body: 'ok' }, { statusCode: 204 }] })

  await initJob({
    url: 'http://localhost:' + server.address().port,
    connections: 1,
    amount: 2,
    requests: [
      {
        method: 'GET',
        onResponse (status, body) {
          t.same(status, 200)
          t.same(body, 'ok')
        }
      },
      {
        method: 'GET',
        onResponse (status, body) {
          t.same(status, 204)
          t.same(body, '')
        }
      }
    ]
  })

  t.end()
})

test('should use request from HAR', (t) => {
  t.plan(6)
  const server = helper.startServer()
  const url = `http://localhost:${server.address().port}`
  const har = helper.customizeHAR('./fixtures/httpbin-get.json', 'https://httpbin.org', url)

  initJob({
    url,
    duration: 1,
    har
  }, (err, res) => {
    t.error(err)
    t.ok(res, 'results should exist')
    t.equal(res.errors, 0)
    t.equal(res.timeouts, 0)
    t.ok(res['2xx'] > 0)
    t.equal(res.url, url)
    t.end()
  })
})

test('should use extend headers of HAR requests', (t) => {
  t.plan(6 + 2) // header check done as many times as sent requests
  const server = helper.startServer()
  const url = `http://localhost:${server.address().port}`
  const har = helper.customizeHAR('./fixtures/httpbin-simple-get.json', 'https://httpbin.org', url)

  initJob({
    url,
    connections: 1,
    amount: 2,
    headers: { 'X-CUSTOM': 'my-own-value' },
    har
  }, (err, res) => {
    t.error(err)
    t.ok(res, 'results should exist')
    t.equal(res.errors, 0)
    t.equal(res.timeouts, 0)
    t.ok(res['2xx'] > 0)
    t.equal(res.url, url)
    t.end()
  }).on('response', (client) => {
    t.equal(client.requestIterator.currentRequest.headers['X-CUSTOM'], 'my-own-value', 'X-CUSTOM was not sent to server')
  })
})

test('should not override method or body of HAR requests', (t) => {
  t.plan(6 + 4) // method and body checks done as many times as sent requests
  const server = helper.startServer()
  const url = `http://localhost:${server.address().port}`
  const har = helper.customizeHAR('./fixtures/httpbin-simple-get.json', 'https://httpbin.org', url)

  initJob({
    url,
    connections: 1,
    amount: 2,
    method: 'POST',
    body: 'my-custom-body',
    har
  }, (err, res) => {
    t.error(err)
    t.ok(res, 'results should exist')
    t.equal(res.errors, 0)
    t.equal(res.timeouts, 0)
    t.ok(res['2xx'] > 0)
    t.equal(res.url, url)
    t.end()
  }).on('response', (client) => {
    t.equal(client.requestIterator.currentRequest.method, 'GET', 'Method was not mean to be overidden')
    t.equal(client.requestIterator.currentRequest.body, undefined, 'Body was not mean to be overidden')
  })
})

test('should ignore HAR requests targetting a different domain', (t) => {
  t.plan(6)
  const server = helper.startServer()
  const url = `http://localhost:${server.address().port}`
  const har = helper.customizeHAR('./fixtures/multi-domains.json', 'https://httpbin.org', url)

  initJob({
    url,
    connections: 1,
    amount: 4,
    har
  }, (err, res) => {
    t.error(err)
    t.ok(res, 'results should exist')
    t.equal(res.errors, 0)
    t.equal(res.timeouts, 0)
    // if the github request is fired, it'll fail with 4xx status
    t.equal(res['2xx'], 4)
    t.equal(res.url, url)
    t.end()
  })
})

test('should throw on invalid HAR', (t) => {
  t.plan(1)

  initJob({
    url: `http://localhost:${server.address().port}`,
    connections: 1,
    amount: 4,
    har: {
      log: {
        version: '1.2',
        creator: {
          name: 'Firefox',
          version: '80.0.1'
        },
        pages: [
          {
            startedDateTime: '2020-09-28T16:43:28.987+02:00',
            id: 'page_1',
            title: 'mcollina/autocannon: fast HTTP/1.1 benchmarking tool written in Node.js',
            pageTimings: {
              onContentLoad: 1234,
              onLoad: 1952
            }
          }
        ]
      }
    }
  }, (err, res) => {
    t.match(err, /Could not parse HAR content: no entries found/)
    t.end()
  })
})

test('should run when no callback is passed in', (t) => {
  t.plan(1)

  const tracker = initJob({
    url: 'http://localhost:' + server.address().port,
    connections: 1,
    duration: 1
  })
  t.resolveMatch(tracker, { connections: 1 }, 'The main tracker should resolve')
})

test('Should run a warmup if one is passed in', (t) => {
  t.plan(1)

  const tracker = initJob({
    url: 'http://localhost:' + server.address().port,
    connections: 1,
    duration: 1,
    warmup: {
      connections: 1,
      duration: 1
    }
  })
  t.resolves(tracker, 'The main tracker should resolve')
})

test('The warmup should not pollute the main result set', (t) => {
  t.plan(3)

  const tracker = initJob({
    url: 'http://localhost:' + server.address().port,
    connections: 3,
    duration: 1,
    warmup: {
      connections: 4,
      duration: 2
    }
  })
  tracker.then((result) => {
    t.equal(result.connections, 3, 'connections should equal the main connections and not the warmup connections')
    t.ok(result.duration >= 1, 'duration should equal the main duration and not the warmup duration')
    t.type(result.warmup, 'object')
  })
})

test('should get headers passed from server onResponse callback', async t => {
  t.plan(3)
  const server = helper.startServer({ responses: [{ statusCode: 200, body: 'ok', headers: { 'set-cookie': 123 } }] })

  await initJob({
    url: 'http://localhost:' + server.address().port,
    connections: 1,
    amount: 1,
    requests: [
      {
        method: 'GET',
        onResponse (status, body, context, headers) {
          t.same(status, 200)
          t.same(body, 'ok')
          t.same(headers['set-cookie'], 123)
        }
      }
    ]
  })

  t.end()
})

test('should get multi-value headers passed from server onResponse callback', async t => {
  t.plan(3)
  const server = helper.startServer({ responses: [{ statusCode: 200, body: 'ok', headers: { 'set-cookie': [123, 456, 789] } }] })

  await initJob({
    url: 'http://localhost:' + server.address().port,
    connections: 1,
    amount: 1,
    requests: [
      {
        method: 'GET',
        onResponse (status, body, context, headers) {
          t.same(status, 200)
          t.same(body, 'ok')
          t.same(headers['set-cookie'], [123, 456, 789])
        }
      }
    ]
  })

  t.end()
})


================================================
FILE: test/runAmount.test.js
================================================
'use strict'

const test = require('tap').test
const initJob = require('../lib/init')
const helper = require('./helper')
const timeoutServer = helper.startTimeoutServer()
const server = helper.startServer()

test('run should only send the expected number of requests', (t) => {
  t.plan(10)

  let done = false

  initJob({
    url: `http://localhost:${server.address().port}`,
    duration: 1,
    connections: 100,
    amount: 50146
  }, (err, res) => {
    t.error(err)
    t.equal(res.requests.total + res.timeouts, 50146, 'results should match the amount')
    t.equal(res.requests.sent, 50146, 'totalRequests should match the amount')
    done = true
  })

  setTimeout(() => {
    t.notOk(done)
  }, 1000)

  initJob({
    url: `http://localhost:${server.address().port}`,
    connections: 2,
    maxConnectionRequests: 10
  }, (err, res) => {
    t.error(err)
    t.equal(res.requests.total, 20, 'results should match max connection requests * connections')
    t.equal(res.requests.sent, 20, 'totalRequests should match the expected amount')
  })

  initJob({
    url: `http://localhost:${server.address().port}`,
    connections: 2,
    maxOverallRequests: 10
  }, (err, res) => {
    t.error(err)
    t.equal(res.requests.total, 10, 'results should match max overall requests')
    t.equal(res.requests.sent, 10, 'totalRequests should match the expected amount')
  })
})

test('should shutdown after all amounts timeout', (t) => {
  t.plan(5)

  initJob({
    url: `http://localhost:${timeoutServer.address().port}`,
    amount: 10,
    timeout: 2,
    connections: 10
  }, (err, res) => {
    t.error(err)
    t.equal(res.errors, 10)
    t.equal(res.timeouts, 10)
    t.equal(res.requests.sent, 10, 'totalRequests should match the expected amount')
    t.equal(res.requests.total, 0, 'total completed requests should be 0')
  })
})

test('should reconnect twice to the server with a reset rate of 10 for 20 connections', (t) => {
  t.plan(3)
  const testServer = helper.startServer()

  initJob({
    url: 'localhost:' + testServer.address().port,
    connections: 1,
    amount: 20,
    reconnectRate: 2
  }, (err, res) => {
    t.error(err)
    t.equal(res.requests.sent, 20, 'totalRequests should match the expected amount')
    t.equal(testServer.autocannonConnects, 10, 'should have connected to the server 10 times after dropping the connection every second request')
    t.end()
  })
})


================================================
FILE: test/runMultiServer.test.js
================================================
const test = require('tap').test
const initJob = require('../lib/init')
const helper = require('./helper')

const server1 = helper.startServer({ body: 'from server1' })
const server2 = helper.startServer({ body: 'from server2' })
const server3 = helper.startServer({ body: 'from server3' })

test('should receive the message from different server', (t) => {
  t.plan(3)

  const instance = initJob({
    url: [
      server1,
      server2,
      server3
    ].map(server => `http://localhost:${server.address().port}`),
    duration: 1,
    connections: 3
  })

  let receivedServer1 = false
  let receivedServer2 = false
  let receivedServer3 = false

  instance.on('response', (client) => {
    if (!receivedServer1 && client.parser.chunk.toString().includes('from server1')) {
      receivedServer1 = true
      t.pass()
    }
    if (!receivedServer2 && client.parser.chunk.toString().includes('from server2')) {
      receivedServer2 = true
      t.pass()
    }
    if (!receivedServer3 && client.parser.chunk.toString().includes('from server3')) {
      receivedServer3 = true
      t.pass()
    }
  })
})


================================================
FILE: test/runMultipart.test.js
================================================
'use strict'

const test = require('tap').test
const { tmpdir } = require('os')
const { join } = require('path')
const { writeFile } = require('fs')
const { promisify } = require('util')
const initJob = require('../lib/init')
const helper = require('./helper')
const writef = promisify(writeFile)
const { hasWorkerSupport } = require('../lib/util')

test('run should return an error with invalid form options', async t => {
  const cases = [
    {
      name: 'invalid JSON',
      value: 'u',
      message: 'Invalid JSON or file where to get form data'
    },
    {
      name: 'non existing JSON file',
      value: 'nonexisting.json',
      message: 'Invalid JSON or file where to get form data'
    },
    {
      name: 'JSON options missing path key in file type',
      value: '{ "image": { "type": "file" }}',
      message: 'Missing key \'path\' in form object for key \'image\''
    },
    {
      name: 'JS Object missing path key in file type',
      value: { image: { type: 'file' } },
      message: 'Missing key \'path\' in form object for key \'image\''
    },
    {
      name: 'JSON options missing value in text type',
      value: '{ "image": { "type": "text" }}',
      message: 'Missing key \'value\' in form object for key \'image\''
    },
    {
      name: 'JS Object missing value in text type',
      value: { image: { type: 'text' } },
      message: 'Missing key \'value\' in form object for key \'image\''
    },
    {
      name: 'JSON options with not supported type',
      value: '{ "image": { "type": "random" }}',
      message: 'A \'type\' key with value \'text\' or \'file\' should be specified'
    },
    {
      name: 'JS Object with not supported type',
      value: { image: { type: 'random' } },
      message: 'A \'type\' key with value \'text\' or \'file\' should be specified'
    }
  ]

  const server = helper.startMultipartServer()
  t.teardown(() => server.close())

  for (const c of cases) {
    t.test(c.name, async t => {
      const [err] = await new Promise((resolve) => {
        initJob({
          url: 'http://localhost:' + server.address().port,
          connections: 1,
          amount: 1,
          form: c.value
        }, (err, res) => {
          resolve([err, res])
        })
      })
      await t.test('error', t => {
        t.not(null, err)
        t.equal(c.message, err.message, `mismatching error message ${err.message}`)
        t.end()
      })
    })
  }
})

test('run should take form options as a JSON string or a JS Object', async t => {
  const form = {
    image: {
      type: 'file',
      path: require.resolve('./j5.jpeg')
    },
    name: {
      type: 'text',
      value: 'j5'
    }
  }
  const string = JSON.stringify(form)
  const temp = tmpdir()
  const jsonFile = join(temp, 'multipart.json')

  await writef(jsonFile, string, 'utf8')

  const cases = [
    {
      name: 'from string',
      value: string
    },
    {
      name: 'from json file',
      value: jsonFile
    },
    {
      name: 'from JS Object',
      value: form
    }
  ]
  const allCases = [...cases, ...cases.map(c => ({ ...c, workers: true }))]

  for (const c of allCases) {
    t.test(c.name, { skip: c.workers && !hasWorkerSupport }, async t => {
      const server = helper.startMultipartServer(null, payload => {
        t.equal('j5', payload.name)
        t.equal('j5.jpeg', payload.image.filename)
      })
      t.teardown(() => server.close())
      const [err, res] = await new Promise((resolve) => {
        initJob({
          url: 'http://localhost:' + server.address().port,
          connections: 1,
          amount: 1,
          form: c.value,
          workers: c.workers ? 1 : undefined // use only one worker coz we're checking for 1 req
        }, (err, res) => {
          resolve([err, res])
        })
      })
      await t.test('result', t => {
        t.equal(null, err)
        t.equal(0, res.errors, 'result should not have errors')
        t.equal(1, res['2xx'], 'result status code should be 2xx')
        t.equal(0, res.non2xx, 'result status code should be 2xx')
        t.end()
      })
    })
  }
})

test('run should use a custom method if `options.method` is passed', t => {
  const server = helper.startMultipartServer(null, payload => {
    t.equal('j5', payload.name)
    t.equal('j5.jpeg', payload.image.filename)
  })
  t.teardown(() => server.close())

  const form = {
    image: {
      type: 'file',
      path: require.resolve('./j5.jpeg')
    },
    name: {
      type: 'text',
      value: 'j5'
    }
  }
  initJob({
    url: 'http://localhost:' + server.address().port,
    method: 'PUT',
    connections: 1,
    amount: 1,
    form
  }, (err, res) => {
    t.equal(null, err)
    t.equal(0, res.errors, 'result should not have errors')
    t.equal(1, res['2xx'], 'result status code should be 2xx')
    t.equal(0, res.non2xx, 'result status code should be 2xx')
    t.end()
  })
})

test('run should set filename', t => {
  const server = helper.startMultipartServer(null, payload => {
    t.equal('j5', payload.name)
    t.equal('j5.jpeg', payload.image.filename)
  })
  t.teardown(() => server.close())

  const form = {
    image: {
      type: 'file',
      path: require.resolve('./j5.jpeg')
    },
    name: {
      type: 'text',
      value: 'j5'
    }
  }
  initJob({
    url: 'http://localhost:' + server.address().port,
    method: 'POST',
    connections: 1,
    amount: 1,
    form
  }, (err, res) => {
    t.equal(null, err)
    t.equal(0, res.errors, 'result should not have errors')
    t.equal(1, res['2xx'], 'result status code should be 2xx')
    t.equal(0, res.non2xx, 'result status code should be 2xx')
    t.end()
  })
})

test('run should allow overriding filename', t => {
  const server = helper.startMultipartServer(null, payload => {
    t.equal('j5', payload.name)
    t.equal('testfilename.jpeg', payload.image.filename)
  })
  t.teardown(() => server.close())

  const form = {
    image: {
      type: 'file',
      path: require.resolve('./j5.jpeg'),
      options: {
        filename: 'testfilename.jpeg'
      }
    },
    name: {
      type: 'text',
      value: 'j5'
    }
  }
  initJob({
    url: 'http://localhost:' + server.address().port,
    method: 'POST',
    connections: 1,
    amount: 1,
    form
  }, (err, res) => {
    t.equal(null, err)
    t.equal(0, res.errors, 'result should not have errors')
    t.equal(1, res['2xx'], 'result status code should be 2xx')
    t.equal(0, res.non2xx, 'result status code should be 2xx')
    t.end()
  })
})

test('run should allow overriding filename with file path', t => {
  const server = helper.startMultipartServer({ preservePath: true }, payload => {
    t.equal('j5', payload.name)
    t.equal('some/path/testfilename.jpeg', payload.image.filename)
  })
  t.teardown(() => server.close())

  const form = {
    image: {
      type: 'file',
      path: require.resolve('./j5.jpeg'),
      options: {
        filepath: 'some/path/testfilename.jpeg'
      }
    },
    name: {
      type: 'text',
      value: 'j5'
    }
  }
  initJob({
    url: 'http://localhost:' + server.address().port,
    method: 'POST',
    connections: 1,
    amount: 1,
    form
  }, (err, res) => {
    t.equal(null, err)
    t.equal(0, res.errors, 'result should not have errors')
    t.equal(1, res['2xx'], 'result status code should be 2xx')
    t.equal(0, res.non2xx, 'result status code should be 2xx')
    t.end()
  })
})


================================================
FILE: test/runRate.test.js
================================================
'use strict'

const test = require('tap').test
const initJob = require('../lib/init')
const helper = require('./helper')
const server = helper.startServer()

test('run should only send the expected number of requests per second - scenario 1', (t) => {
  t.plan(3)

  initJob({
    url: `http://localhost:${server.address().port}`,
    connections: 2,
    overallRate: 10,
    amount: 40,
    sampleInt: 1000
  }, (err, res) => {
    t.error(err)

    t.equal(Math.floor(res.duration), 4, 'should have take 4 seconds to send 10 requests per seconds')
    t.equal(res.requests.average, 10, 'should have sent 10 requests per second on average')
  })
})

test('run should only send the expected number of requests per second - scenario 2', (t) => {
  t.plan(3)

  initJob({
    url: `http://localhost:${server.address().port}`,
    connections: 2,
    connectionRate: 10,
    amount: 40,
    sampleInt: 1000
  }, (err, res) => {
    t.error(err)
    t.equal(Math.floor(res.duration), 2, 'should have taken 2 seconds to send 10 requests per connection with 2 connections')
    t.equal(res.requests.average, 20, 'should have sent 20 requests per second on average with two connections')
  })
})

test('run should only send the expected number of requests per second - scenario 3', (t) => {
  t.plan(3)

  initJob({
    url: `http://localhost:${server.address().port}`,
    connections: 15,
    overallRate: 10,
    amount: 40,
    sampleInt: 1000
  }, (err, res) => {
    t.error(err)
    t.equal(Math.floor(res.duration), 4, 'should have take 4 seconds to send 10 requests per seconds')
    t.equal(res.requests.average, 10, 'should have sent 10 requests per second on average')
  })
})

test('run should compensate for coordinated omission when the expected number of requests per second is too high', (t) => {
  t.plan(2)

  initJob({
    url: `http://localhost:${server.address().port}`,
    connections: 100,
    connectionRate: 1000,
    duration: 1
  }, (err, res) => {
    t.error(err)
    t.not(res.latency.totalCount, res.requests.total, 'should have recorded additionnal latencies')
  })
})

test('run should not compensate for coordinated omission when this feature is disabled', (t) => {
  t.plan(2)

  initJob({
    url: `http://localhost:${server.address().port}`,
    connections: 100,
    connectionRate: 1000,
    ignoreCoordinatedOmission: true,
    duration: 1
  }, (err, res) => {
    t.error(err)
    t.equal(res.latency.totalCount, res.requests.total, 'should not have recorded additionnal latencies')
  })
})


================================================
FILE: test/sampleInt.test.js
================================================
'use strict'

const test = require('tap').test
const validate = require('../lib/validate')
const parseArguments = require('../autocannon').parseArguments
const initJob = require('../lib/init')
const printResult = require('../lib/printResult')

test('validate should return an error', (t) => {
  t.plan(2)

  const args = {
    sampleInt: 'hello',
    url: 'https://github.com/mcollina/autocannon'
  }

  const result = validate(args)

  t.ok(result instanceof Error)
  t.equal(result.message, 'sample interval entered was in an invalid format')
})

test('validate should return an error', (t) => {
  t.plan(2)

  const args = {
    sampleInt: -1,
    url: 'https://github.com/mcollina/autocannon'
  }

  const result = validate(args)

  t.ok(result instanceof Error)
  t.equal(result.message, 'sample interval can not be less than 0')
})

test('validate should not return an error', (t) => {
  t.plan(2)

  const args = {
    sampleInt: 2,
    url: 'https://github.com/mcollina/autocannon'
  }

  const result = validate(args)

  t.ok(!(result instanceof Error))
  t.equal(result.sampleInt, 2)
})

test('parseArguments should accept value in ms (2000)', (t) => {
  t.plan(1)

  const args = [
    '-L', 2000,
    'https://github.com/mcollina/autocannon'
  ]

  const result = parseArguments(args)

  t.equal(result.sampleInt, 2000)
})

test('run should return sampleInt == 2000 & samples == 3', (t) => {
  t.plan(2)

  initJob({
    duration: 6,
    sampleInt: 2000,
    url: 'https://github.com/mcollina/autocannon'
  }, (err, res) => {
    if (err) {
      console.err(err)
    }
    t.equal(res.sampleInt, 2000)
    t.equal(res.samples, 3)
  })
})

test('printResult should print the sample interval (2) & the total samples (3)', (t) => {
  t.plan(2)

  const result = {
    duration: 6,
    sampleInt: 2000,
    samples: 3,
    url: 'https://github.com/mcollina/autocannon',
    latency: {},
    requests: {},
    throughput: {
      average: 3319,
      mean: 3319,
      stddev: 0,
      min: 3318,
      max: 3318,
      total: 3318,
      p0_001: 3319,
      p0_01: 3319,
      p0_1: 3319,
      p1: 3319,
      p2_5: 3319,
      p10: 3319,
      p25: 3319,
      p50: 3319,
      p75: 3319,
      p90: 3319,
      p97_5: 3319,
      p99: 3319,
      p99_9: 3319,
      p99_99: 3319,
      p99_999: 3319
    }
  }

  const output = printResult(result, {})

  t.ok(output.includes('Req/Bytes counts sampled every 2 seconds.'))
  t.ok(output.includes('# of samples: 3'))
})


================================================
FILE: test/serial/autocannon.test.js
================================================
'use strict'

const childProcess = require('child_process')
const fs = require('fs')
const path = require('path')
const test = require('tap').test

const { promisify } = require('util')

const exec = promisify(childProcess.exec).bind(childProcess)
const proxyquire = require('proxyquire')

const baseDir = path.join(__dirname, '..', '..')

test('should print error if url.URL is not a function', t => {
  t.plan(2)

  const _error = console.error
  const _exit = process.exit

  process.exit = (code) => {
    t.equal(code, 1)
    process.exit = _exit
    t.end()
  }
  console.error = (obj) => {
    t.equal(
      obj,
      'autocannon requires the WHATWG URL API, but it is not available. Please upgrade to Node 6.13+.'
    )
    console.error = _error
  }
  proxyquire('../..', {
    url: {
      URL: null
    }
  })
})

test('should print version if invoked with --version', async t => {
  t.plan(1)
  const res = await exec(`node ${baseDir}/autocannon.js --version`)
  t.ok(res.stdout.match(/autocannon v(\d+\.\d+\.\d+)/))
})

test('should print help if invoked with --help', async t => {
  t.plan(1)
  const help = fs.readFileSync(path.join(baseDir, 'help.txt'), 'utf8')
  const res = await exec(`node ${baseDir}/autocannon.js --help`)
  t.same(res.stderr.trim(), help.trim()) // console.error adds \n at the end of print
})

test('should print help if no url is provided', async t => {
  t.plan(1)
  const help = fs.readFileSync(path.join(baseDir, 'help.txt'), 'utf8')
  const res = await exec(`node ${baseDir}/autocannon.js`)
  t.same(res.stderr.trim(), help.trim()) // console.error adds \n at the end of print
})

test('start should console an error when a promise is caught', (t) => {
  const Autocannon = t.mock('../../autocannon', {
    '../../lib/init': () => new Promise((resolve, reject) => {
      reject(new Error('Test Error'))
    })
  })

  t.plan(1)

  const _error = console.error
  console.error = (obj) => {
    t.equal(
      obj,
      'Test Error'
    )
    console.error = _error
  }

  Autocannon.start(
    Autocannon.parseArguments([
      '-d', '1',
      '-c', '1',
      'http://localhost/foo/bar'
    ])
  )
})

test('start should console an error when one is thrown without a promise', (t) => {
  const Autocannon = t.mock('../../autocannon', {
    '../../lib/init': () => { throw new Error('Test Error') }
  })

  t.plan(1)

  const _error = console.error
  console.error = (obj) => {
    t.equal(
      obj,
      'Test Error'
    )
    console.error = _error
  }

  Autocannon.start(
    Autocannon.parseArguments([
      '-d', '1',
      '-c', '1',
      '--forever',
      'http://localhost/foo/bar'
    ])
  )
})

test('start should console an error when --on-port is used without async hooks', (t) => {
  const Autocannon = t.mock('../../autocannon', {
    'has-async-hooks': () => false,
    child_process: {
      spawn: () => {}
    },
    '../../lib/init': () => {},
    net: {
      createServer: () => ({
        listen: () => {},
        on: () => {}
      })
    }
  })

  t.plan(2)

  const _exit = process.exit
  process.exit = (code) => {
    t.equal(code, 1)
    process.exit = _exit
    t.end()
  }
  const _error = console.error
  console.error = (obj) => {
    t.equal(
      obj,
      'The --on-port flag requires the async_hooks builtin module, but it is not available. Please upgrade to Node 8.1+.'
    )
    console.error = _error
  }

  Autocannon.start(
    Autocannon.parseArguments([
      '-d', '1',
      '-c', '1',
      '--on-port',
      'http://localhost/foo/bar'
    ])
  )
})

test('When there is a port, createChannel should try to unlink the socketPath', (t) => {
  const Autocannon = t.mock('../../autocannon', {
    'has-async-hooks': () => true,
    child_process: {
      spawn: () => {}
    },
    '../../lib/init': () => {},
    net: {
      createServer: () => ({
        listen: () => {},
        on: (eventName, cb) => {
          t.equal(eventName, 'close')
          cb()
        }
      })
    }
  })

  t.plan(1)

  Autocannon.start(
    Autocannon.parseArguments([
      '-d', '1',
      '-c', '1',
      '--on-port',
      'http://localhost/foo/bar'
    ])
  )
})

test('createChannel should try to unlink the socketPath', (t) => {
  const Autocannon = t.mock('../../autocannon', {
    'has-async-hooks': () => true,
    child_process: {
      spawn: () => {}
    },
    '../../lib/init': () => {},
    net: {
      createServer: () => ({
        listen: () => {},
        on: (_, cb) => {
          t.equal(_, 'close')
          cb()
        }
      })
    }
  })

  t.plan(1)

  Autocannon.start(
    Autocannon.parseArguments([
      '-d', '1',
      '-c', '1',
      '--on-port',
      'http://localhost/foo/bar'
    ])
  )
})


================================================
FILE: test/serial/run.test.js
================================================
'use strict'
const test = require('tap').test
const initJob = require('../../lib/init')

test('should log error on connection error', t => {
  t.plan(1)
  console.error = function (obj) {
    t.type(obj, Error)
    console.error = () => {}
  }
  initJob({
    url: 'http://unknownhost',
    connections: 2,
    duration: 5,
    title: 'title321',
    debug: true
  })
})


================================================
FILE: test/serial/tap-parallel-not-ok
================================================


================================================
FILE: test/serial/wasm.test.js
================================================
'use strict'

const test = require('tap').test
const initJob = require('../../lib/init')
const helper = require('../helper')

test('should clean up HdrHistogram WASM memory at each run', async (t) => {
  const server = helper.startServer()
  const runTwentyTimes = (resolve, reject, numberOfRuns = 0) => {
    initJob({
      url: 'http://localhost:' + server.address().port,
      connections: 1,
      amount: 1
    }, (result) => {
      // should get error " url or socketPath option required"
      // we can ignore this error, we just want run() to execute
      // and to instantiate new WASM histograms
      if (numberOfRuns < 20) {
        runTwentyTimes(resolve, reject, ++numberOfRuns)
      } else {
        resolve()
      }
    })
  }
  const lotsOfRuns = []
  for (let index = 0; index < 50; index++) {
    lotsOfRuns.push(new Promise(runTwentyTimes))
  }

  await Promise.all(lotsOfRuns)

  // if the process has not crashed, we are good \o/
  t.end()
})


================================================
FILE: test/subargAliases.test.js
================================================
'use strict'

const test = require('tap').test
const generateSubArgAliases = require('../lib/subargAliases')

test('generateSubArgAliases Should generate warmup aliases', (t) => {
  t.plan(4)

  const args = {
    connections: 1,
    duration: 2,
    warmup: {
      c: 3,
      d: 4
    }
  }

  const result = generateSubArgAliases(args)

  t.equal(result.connections, 1)
  t.equal(result.duration, 2)
  t.equal(result.warmup.connections, 3)
  t.equal(result.warmup.duration, 4)
})

test('generateSubArgAliases should not process aliases that are not defined in subargAliases.js', (t) => {
  t.plan(5)

  const args = {
    connections: 1,
    warmup: {
      c: 3,
      T: 'A title'
    }
  }

  const result = generateSubArgAliases(args)

  t.equal(result.connections, 1)
  t.equal(result.warmup.connections, 3)
  t.equal(result.warmup.c, 3)
  t.equal(result.warmup.T, 'A title')
  t.equal(Object.keys(result.warmup).length, 3)
})


================================================
FILE: test/tap-parallel-ok
================================================


================================================
FILE: test/targetProcess.js
================================================
const server = require('./helper').startServer()

server.ref()


================================================
FILE: test/url.test.js
================================================
'use strict'

const test = require('tap').test
// const { ofUrl, checkUrl } = require('../lib/url')
const { ofURL, checkURL } = require('../lib/url')

test('checkURL should return true if a populated string is passed', (t) => {
  t.plan(1)

  const result = checkURL('foo')
  t.ok(result)
})

test('checkURL should return false if an empty string is passed', (t) => {
  t.plan(1)

  const result = checkURL('')
  t.notOk(result)
})

test('checkURL should return true if a populated array is passed', (t) => {
  t.plan(1)

  const result = checkURL(['foo'])
  t.ok(result)
})

test('checkURL should return false if an empty array is passed', (t) => {
  t.plan(1)

  const result = checkURL([])
  t.notOk(result)
})

test('ofUrl should return the array if the passed in url is an array', (t) => {
  t.plan(1)

  const result = ofURL(['foo', 'bar'])
  t.same(result, ['foo', 'bar'])
})

test('When ofUrl is passed a string ofUrl should return an object containing a map function that accepts an url', (t) => {
  t.plan(1)

  const result = ofURL('foo', false)
  const mappedResult = result.map((url) => url)
  t.same(mappedResult, 'foo')
})

test('When ofUrl is passed a string and asArray=true ofUrl should return an object containing a map function that returns an array', (t) => {
  t.plan(1)

  const result = ofURL('foo', true)
  const mappedResult = result.map((url) => url)
  t.same(mappedResult, ['foo'])
})

test('ofUrl Should throw an error when passed an invalid url type', (t) => {
  t.plan(1)

  t.throws(() => ofURL(123), 'url should only be a string or an array of string')
})


================================================
FILE: test/utils/has-worker-support.js
================================================
'use strict'

const semver = require('semver')

module.exports = semver.gte(process.versions.node, '11.7.0')


================================================
FILE: test/utils/on-response.js
================================================
'use strict'

module.exports = (status, body, context) => {
  context.foo = 'bar=baz'
}


================================================
FILE: test/utils/setup-client.js
================================================
'use strict'

module.exports = (client) => {
  client.setHeaders({ custom: 'my-header' })
}


================================================
FILE: test/utils/setup-request.js
================================================
'use strict'

module.exports = (req, context) => ({
  ...req,
  path: `/test-123?some=thing&${context.foo}`
})


================================================
FILE: test/utils/verify-body.js
================================================
module.exports = (body) => {
  return false
}


================================================
FILE: test/validate.test.js
================================================
'use strict'

const test = require('tap').test
const validateOpts = require('../lib/validate')
const helper = require('./helper')
const { hasWorkerSupport } = require('../lib/util')

test('validateOpts should not return an error with only an url passed in', (t) => {
  t.plan(1)

  const result = validateOpts({ url: 'http://localhost' })
  t.ok(!(result instanceof Error))
})

test('validateOpts should return an error when workers option is present and hasWorkerSupport is false', (t) => {
  const validateOpts = t.mock('../lib/validate', {
    '../lib/util': { hasWorkerSupport: false }
  })
  t.plan(2)

  const result = validateOpts({ workers: 1 })
  t.ok(result instanceof Error)
  t.equal(result.message, 'Please use node >= 11.7.0 for workers support')
})

test('validateOpts should return an error when bailout is less than 1', (t) => {
  const validateOpts = t.mock('../lib/validate', {
    '../lib/util': { hasWorkerSupport: false }
  })
  t.plan(2)

  const result = validateOpts({ bailout: 0 })
  t.ok(result instanceof Error)
  t.equal(result.message, 'bailout threshold can not be less than 1')
})

test('validateOpts should return an error when connectionRate is less than 1', (t) => {
  t.plan(2)

  const result = validateOpts({ connectionRate: 0 })
  t.ok(result instanceof Error)
  t.equal(result.message, 'connectionRate can not be less than 1')
})

test('validateOpts should return an error when overallRate is less than 1', (t) => {
  t.plan(2)

  const result = validateOpts({ overallRate: 0 })
  t.ok(result instanceof Error)
  t.equal(result.message, 'bailout overallRate can not be less than 1')
})

test('validateOpts should return an error when amount is less than 1', (t) => {
  t.plan(2)

  const result = validateOpts({ amount: 0 })
  t.ok(result instanceof Error)
  t.equal(result.message, 'amount can not be less than 1')
})

test('validateOpts should return an error when maxConnectionRequests is less than 1', (t) => {
  t.plan(2)

  const result = validateOpts({ url: 'http://localhost', maxConnectionRequests: 0 })
  t.ok(result instanceof Error)
  t.equal(result.message, 'maxConnectionRequests can not be less than 1')
})

test('validateOpts should return an error when maxOverallRequests is less than 1', (t) => {
  t.plan(2)

  const result = validateOpts({ maxOverallRequests: 0 })
  t.ok(result instanceof Error)
  t.equal(result.message, 'maxOverallRequests can not be less than 1')
})

test('validateOpts should return an error when requests does not contain a valid setupRequest function', (t) => {
  t.plan(2)

  const result = validateOpts({ url: 'http://localhost', requests: [{ setupRequest: 123 }] })
  t.ok(result instanceof Error)
  t.equal(result.message, 'Invalid option setupRequest, please provide a function (or file path when in workers mode)')
})

test('validateOpts should return an error when requests does not contain a valid onResponse function', (t) => {
  t.plan(2)

  const result = validateOpts({ url: 'http://localhost', requests: [{ onResponse: 123 }] })
  t.ok(result instanceof Error)
  t.equal(result.message, 'Invalid option onResponse, please provide a function (or file path when in workers mode)')
})

test('validateOpts should return an error when setupClient is not a valid function', (t) => {
  t.plan(2)

  const result = validateOpts({ url: 'http://localhost', setupClient: 123 })
  t.ok(result instanceof Error)
  t.equal(result.message, 'Invalid option setupClient, please provide a function (or file path when in workers mode)')
})

test('validateOpts should return an error if neither url or socket path are provided', (t) => {
  t.plan(2)

  const result = validateOpts({ })
  t.ok(result instanceof Error)
  t.equal(result.message, 'url or socketPath option required')
})

test('validateOpts should convert a duration that is a string representation of a number into a number', (t) => {
  t.plan(1)

  const result = validateOpts({ url: 'http://localhost', duration: '100' })
  t.equal(result.duration, 100)
})

test('validateOpts should convert a duration that is a timestring into a number', (t) => {
  t.plan(1)

  const result = validateOpts({ url: 'http://localhost', duration: '2 weeks' })
  t.equal(result.duration, 1209600)
})

test('validateOpts should return an error if duration is in an invalid format', (t) => {
  t.plan(1)

  const result = validateOpts({ url: 'http://localhost', duration: '2 dsweeks' })
  t.ok(result instanceof Error)
})

test('validateOpts should return an error if duration less than 0', (t) => {
  t.plan(2)

  const result = validateOpts({ url: 'http://localhost', duration: -1 })
  t.ok(result instanceof Error)
  t.equal(result.message, 'duration can not be less than 0')
})

test('validateOpts should return an error if expectBody is used in conjunction with requests', (t) => {
  t.plan(2)

  const result = validateOpts({ url: 'http://localhost', expectBody: 'foo', requests: [] })
  t.ok(result instanceof Error)
  t.equal(result.message, 'expectBody cannot be used in conjunction with requests')
})

test('validateOpts should parse a multipart form correctly', (t) => {
  t.plan(1)

  const result = validateOpts({ url: 'http://localhost', form: '{ "field 1": { "type": "text", "value": "a text value"} }' })
  t.ok(result.form)
})

test('validateOpts should return an error if a multipart form is incorrectly formatted', (t) => {
  t.plan(1)

  const result = validateOpts({ url: 'http://localhost', form: 'invalid form' })
  t.ok(result instanceof Error)
})

test('validateOpts should parse a HAR request successfully', (t) => {
  t.plan(1)

  const har = helper.customizeHAR('./fixtures/httpbin-get.json', 'https://httpbin.org', 'http://localhost')
  const result = validateOpts({ url: 'http://localhost', har })
  t.ok(result.har)
})

test('validateOpts should return an error if a HAR request is unsuccessful', (t) => {
  t.plan(1)

  const result = validateOpts({ url: 'http://localhost', har: 'invalid har' })
  t.ok(result instanceof Error)
})

test('validateOpts should return an error when connections is less than 1', (t) => {
  t.plan(2)

  const result = validateOpts({ url: 'http://localhost', connections: 0 })
  t.ok(result instanceof Error)
  t.equal(result.message, 'connections can not be less than 1')
})

test('validateOpts should return an error when ignoreCoordinatedOmission used without connectionRate or overallRate', (t) => {
  t.plan(2)

  const result = validateOpts({
    url: 'http://localhost',
    ignoreCoordinatedOmission: true
  })
  t.ok(result instanceof Error)
  t.equal(result.message, 'ignoreCoordinatedOmission makes no sense without connectionRate or overallRate')
})

test('validateOpts is successful when ignoreCoordinatedOmission is used with connectionRate', (t) => {
  t.plan(1)

  const result = validateOpts({
    url: 'http://localhost',
    ignoreCoordinatedOmission: true,
    connectionRate: 1
  })
  t.ok(result.ignoreCoordinatedOmission)
})

test('validateOpts is successful when ignoreCoordinatedOmission is used with overallRate', (t) => {
  t.plan(1)

  const result = validateOpts({
    url: 'http://localhost',
    ignoreCoordinatedOmission: true,
    overallRate: 1
  })
  t.ok(result.ignoreCoordinatedOmission)
})

test('validateOpts should return an error when forever is used with cbPassedIn', (t) => {
  t.plan(2)

  const result = validateOpts({ url: 'http://localhost', forever: true }, () => {})
  t.ok(result instanceof Error)
  t.equal(result.message, 'should not use the callback parameter when the `forever` option is set to true. Use the `done` event on this event emitter')
})

test('validateOpts should return an error when forever is used with workers', { skip: !hasWorkerSupport }, (t) => {
  t.plan(2)

  const result = validateOpts({ url: 'http://localhost', forever: true, workers: 2 })
  t.ok(result instanceof Error)
  t.equal(result.message, 'Using `forever` option isn\'t currently supported with workers')
})

test('validateOpts should not set render options by default', (t) => {
  t.plan(3)

  const result = validateOpts({ url: 'http://localhost' })
  t.equal(result.renderProgressBar, undefined)
  t.equal(result.renderResultsTable, undefined)
  t.equal(result.renderLatencyTable, undefined)
})

test('validateOpts should disable render options when json is true', (t) => {
  t.plan(3)

  const result = validateOpts({ url: 'http://localhost', json: true })
  t.equal(result.renderProgressBar, false)
  t.equal(result.renderResultsTable, false)
  t.equal(result.renderLatencyTable, false)
})


================================================
FILE: test/workers.test.js
================================================
'use strict'

const path = require('path')
const fs = require('fs')
const test = require('tap').test
const http = require('http')
const initJob = require('../lib/init')
const { hasWorkerSupport } = require('../lib/util')
const helper = require('./helper')
const httpsServer = helper.startHttpsServer()

test('returns error when no worker support was found', (t) => {
  const server = helper.startServer()
  initJob({
    url: 'http://localhost:' + server.address().port,
    connections: 3,
    workers: 3,
    amount: 6,
    title: 'with-workers'
  }, function (err, result) {
    if (hasWorkerSupport) {
      t.error(err)
    } else {
      t.equal(err.message, 'Please use node >= 11.7.0 for workers support')
    }

    t.end()
  })
})

test('init with workers', { skip: !hasWorkerSupport }, (t) => {
  const server = helper.startServer()
  initJob({
    url: 'http://localhost:' + server.address().port,
    connections: 3,
    workers: 3,
    amount: 6,
    title: 'with-workers'
  }, function (err, result) {
    t.error(err)

    t.ok(result.workers === 3, 'correct worker count')
    t.equal(result.title, 'with-workers', 'title should be what was passed in')
    t.equal(result.connections, 3, 'connections is the same')
    t.equal(result.pipelining, 1, 'pipelining is the default')

    t.ok(result.latency, 'latency exists')
    t.type(result.latency.average, 'number', 'latency.average exists')
    t.type(result.latency.stddev, 'number', 'latency.stddev exists')
    t.ok(result.latency.min >= 0, 'latency.min exists')
    t.type(result.latency.max, 'number', 'latency.max exists')
    t.type(result.latency.p2_5, 'number', 'latency.p2_5 (2.5%) exists')
    t.type(result.latency.p50, 'number', 'latency.p50 (50%) exists')
    t.type(result.latency.p97_5, 'number', 'latency.p97_5 (97.5%) exists')
    t.type(result.latency.p99, 'number', 'latency.p99 (99%) exists')

    t.ok(result.requests, 'requests exists')
    t.type(result.requests.average, 'number', 'requests.average exists')
    t.type(result.requests.stddev, 'number', 'requests.stddev exists')
    t.type(result.requests.min, 'number', 'requests.min exists')
    t.type(result.requests.max, 'number', 'requests.max exists')
    t.ok(result.requests.total === 6, 'requests.total exists')
    t.type(result.requests.sent, 'number', 'sent exists')
    t.ok(result.requests.sent >= result.requests.total, 'total requests made should be more than or equal to completed requests total')
    t.type(result.requests.p1, 'number', 'requests.p1 (1%) exists')
    t.type(result.requests.p2_5, 'number', 'requests.p2_5 (2.5%) exists')
    t.type(result.requests.p50, 'number', 'requests.p50 (50%) exists')
    t.type(result.requests.p97_5, 'number', 'requests.p97_5 (97.5%) exists')

    t.ok(result.throughput, 'throughput exists')
    t.type(result.throughput.average, 'number', 'throughput.average exists')
    t.type(result.throughput.stddev, 'number', 'throughput.stddev exists')
    t.type(result.throughput.min, 'number', 'throughput.min exists')
    t.type(result.throughput.max, 'number', 'throughput.max exists')
    t.type(result.throughput.total, 'number', 'throughput.total exists')
    t.type(result.throughput.p1, 'number', 'throughput.p1 (1%) exists')
    t.type(result.throughput.p2_5, 'number', 'throughput.p2_5 (2.5%) exists')
    t.type(result.throughput.p50, 'number', 'throughput.p50 (50%) exists')
    t.type(result.throughput.p97_5, 'number', 'throughput.p97_5 (97.5%) exists')

    t.ok(result.start, 'start time exists')
    t.ok(result.finish, 'finish time exists')

    t.equal(result.errors, 0, 'no errors')
    t.equal(result.mismatches, 0, 'no mismatches')
    t.equal(result.resets, 0, 'no resets')

    t.equal(result['1xx'], 0, '1xx codes')
    t.equal(result['2xx'], result.requests.total, '2xx codes')
    t.equal(result['3xx'], 0, '3xx codes')
    t.equal(result['4xx'], 0, '4xx codes')
    t.equal(result['5xx'], 0, '5xx codes')
    t.equal(result.non2xx, 0, 'non 2xx codes')

    t.end()
  })
})

test('setupRequest and onResponse work with workers', { skip: !hasWorkerSupport }, (t) => {
  const server = http.createServer((req, res) => {
    // it's not easy to assert things within setupRequest and onResponse
    // when in workers mode. So, we set something in onResponse and use in the
    // next Request and make sure it exist or we return 404.
    if (req.method === 'GET' && req.url !== '/test-123?some=thing&bar=baz') {
      res.statusCode = 404
      res.end('NOT OK')
      return
    }

    res.end('OK')
  })
  server.listen(0)
  server.unref()

  initJob({
    url: 'http://localhost:' + server.address().port,
    connections: 2,
    amount: 4,
    workers: 1,
    requests: [
      {
        method: 'PUT',
        onResponse: path.join(__dirname, './utils/on-response')
      },
      {
        method: 'GET',
        setupRequest: path.join(__dirname, './utils/setup-request')
      }
    ]
  }, function (err, result) {
    t.error(err)

    t.equal(4, result['2xx'], 'should have 4 ok requests')
    t.equal(0, result['4xx'], 'should not have any 404s')
    t.end()
  })
})

test('verifyBody work with workers', { skip: !hasWorkerSupport }, (t) => {
  const server = http.createServer((req, res) => {
    // it's not easy to assert things within setupRequest and onResponse
    // when in workers mode. So, we set something in onResponse and use in the
    // next Request and make sure it exist or we return 404.
    if (req.method === 'GET' && req.url !== '/test-123?some=thing&bar=baz') {
      res.statusCode = 404
      res.end('NOT OK')
      return
    }

    res.end('OK')
  })
  server.listen(0)
  server.unref()

  initJob({
    url: 'http://localhost:' + server.address().port,
    connections: 2,
    amount: 4,
    workers: 1,
    verifyBody: path.join(__dirname, './utils/verify-body')
  }, function (err, result) {
    t.error(err)

    t.equal(4, result.mismatches, 'should have 4 mismatches requests')
    t.end()
  })
})

test('setupClient works with workers', { skip: !hasWorkerSupport }, (t) => {
  const server = http.createServer((req, res) => {
    if (req.headers.custom !== 'my-header') {
      res.statusCode = 404
      res.end('NOT OK')
      return
    }
    res.end('OK')
  })
  server.listen(0)
  server.unref()

  initJob({
    url: 'http://localhost:' + server.address().port,
    connections: 2,
    amount: 2,
    workers: 1,
    setupClient: path.join(__dirname, './utils/setup-client')
  }, function (err, result) {
    t.error(err)

    t.equal(2, result['2xx'], 'should have 2 ok requests')
    t.equal(0, result['4xx'], 'should not have any 404s')
    t.end()
  })
})

test('tlsOptions using pfx work as intended in workers', { skip: !hasWorkerSupport }, (t) => {
  initJob({
    url: 'https://localhost:' + httpsServer.address().port,
    connections: 1,
    amount: 1,
    workers: 2,
    tlsOptions: {
      pfx: fs.readFileSync(path.join(__dirname, '/keystore.pkcs12')),
      passphrase: 'test'
    }
  }, function (err, result) {
    t.error(err)
    t.ok(result, 'requests are ok')
    t.end()
  })
})