test('socket timeout is canceled on error', withServer, async (t, server, got) => {
	server.get('/', defaultHandler);

	const message = 'oh, snap!';

	const promise = got({
		timeout: {socket: 100},
		retry: 0
	}).on('request', request => {
		request.emit('error', new Error(message));
		request.abort();
	});

	await t.throwsAsync(promise, {message});

	// Wait a bit more to check if there are any unhandled errors
	await delay(100);
});

 _.each(arr, async function(newData, i, arr) {
      if (i > 0) {
        let previousIndex = i - 1
        let previousData = arr[previousIndex]
        let d = (newData.prdt - previousData.prdt) * 1000
        dly = dly + d
        await delay(dly)
      }
      ws.send(JSON.stringify(newData))
 });

test('no more timeouts after an error', async t => {
	await t.throwsAsync(got(`http://${Date.now()}.dev`, {
		retry: 1,
		timeout: {
			lookup: 1,
			connect: 1,
			secureConnect: 1,
			socket: 1,
			response: 1,
			send: 1,
			request: 1
		}
	}), {instanceOf: got.GotError}); // Don't check the message, because it may throw ENOTFOUND before the timeout.

	// Wait a bit more to check if there are any unhandled errors
	await delay(100);
});

test('no unhandled errors', async t => {
	const server = net.createServer(connection => {
		connection.end('blah');
	}).listen(0);

	const message = 'snap!';

	const options = {
		cookieJar: {
			setCookie: () => {},
			getCookieString: (_, __, cb) => cb(new Error(message))
		}
	};

	await t.throwsAsync(got(`http://127.0.0.1:${(server.address() as AddressInfo).port}`, options), {message});
	await delay(500);
	t.pass();

	server.close();
});

				async options => {
					await delay(100);
					options.headers.foo = 'bar';
				}

 .catch((e: Error) => {
   spinner.fail(e.message)
   return delay(1000).then(() => randomEbayResult())
 })

 it('counts the time', async function() {
   const counter = new StatsCounter()
   await delay(1)
   expect(counter.duration()).to.match(/\d+.s/)
 })