Added some tests

tests/node_modules/tape/test/async-await/async-bug.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var test = require('../../');
+
+function myCode(arr) {
+    let sum = 0;
+    // oops forgot to handle null
+    for (let i = 0; i < arr.length; i++) {
+        sum += arr[i];
+    }
+    return sum;
+}
+
+test('async-error', async function myTest(t) {
+    await sleep(100);
+    t.ok(true, 'before throw');
+
+    const sum = myCode([1, 2, 3]);
+    t.equal(sum, 6);
+
+    const sum2 = myCode(null);
+    t.equal(sum2, 0);
+
+    t.end();
+});
+
+
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}

tests/node_modules/tape/test/async-await/async-error.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var test = require('../../');
+
+test('async-error', async function myTest(t) {
+    t.ok(true, 'before throw');
+    throw new Error('oopsie');
+    t.ok(true, 'after throw');
+});

tests/node_modules/tape/test/async-await/async1.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var test = require('../../');
+
+test('async1', async function myTest(t) {
+    try {
+        t.ok(true, 'before await');
+        await new Promise((resolve) => {
+            setTimeout(resolve, 10);
+        });
+        t.ok(true, 'after await');
+        t.end();
+    } catch (err) {
+        t.ifError(err);
+    }
+});

tests/node_modules/tape/test/async-await/async2.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var test = require('../../');
+
+test('async2', async function myTest(t) {
+    try {
+        t.ok(true, 'before await');
+        await new Promise((resolve) => {
+            setTimeout(resolve, 10);
+        });
+        t.ok(false, 'after await');
+    } catch (err) {
+        t.ifError(err);
+    }
+});

tests/node_modules/tape/test/async-await/async3.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var test = require('../../');
+
+test('async3', async function myTest(t) {
+    t.ok(true, 'before await');
+    await new Promise((resolve) => {
+        setTimeout(resolve, 10);
+    });
+    t.ok(true, 'after await');
+});

tests/node_modules/tape/test/async-await/async4.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var test = require('../../');
+
+test('async4', async function myTest(t) {
+    try {
+        t.ok(true, 'before await');
+        await new Promise((resolve, reject) => {
+            setTimeout(function myTimeout() {
+                reject(new Error('oops'));
+            }, 10);
+        });
+        t.ok(true, 'after await');
+    } catch (err) {
+        t.ifError(err);
+    }
+});

tests/node_modules/tape/test/async-await/async5.js

@@ -0,0 +1,59 @@
+'use strict';
+
+var util = require('util');
+var http = require('http');
+
+var test = require('../../');
+
+test('async5', async function myTest(t) {
+    try {
+        t.ok(true, 'before server');
+
+        var mockDb = { state: 'old' };
+        var server = http.createServer(function (req, res) {
+            res.end('OK');
+
+            // Pretend we write to the DB and it takes time.
+            setTimeout(function () {
+                mockDb.state = 'new';
+            }, 10);
+        });
+
+        await util.promisify(function (cb) {
+            server.listen(0, cb);
+        })();
+
+        t.ok(true, 'after server');
+
+        t.ok(true, 'before request');
+
+        var res = await util.promisify(function (cb) {
+            var req = http.request({
+                hostname: 'localhost',
+                port: server.address().port,
+                path: '/',
+                method: 'GET'
+            }, function (res) {
+                cb(null, res);
+            });
+            req.end();
+        })();
+
+        t.ok(true, 'after request');
+
+        res.resume();
+        t.equal(res.statusCode, 200, 'res.statusCode is 200');
+
+        setTimeout(function () {
+            t.equal(mockDb.state, 'new', 'mockDb.state is new');
+
+            server.close(function (err) {
+                t.ifError(err, 'error on close');
+                t.end();
+            });
+        }, 50);
+    } catch (err) {
+        t.ifError(err, 'error in catch');
+        t.end();
+    }
+});

tests/node_modules/tape/test/async-await/sync-error.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var test = require('../../');
+
+test('sync-error', function myTest(t) {
+    t.ok(true, 'before throw');
+    throw new Error('oopsie');
+    t.ok(true, 'after throw');
+    t.end();
+});