test.js

var http = require('http');
var url = require('url');
var assert = require('assert');

function debug_break() {
  stack();
}

// simple async callback that will call back with whatever is passed to it
function callback() {
  var args = [];
  for (var i = 0; i < arguments.length - 1; i++)
    args.push(arguments[i]);
  var cb = arguments[i];
  process.nextTick(function() {
    cb.apply(null, args);
  });
}

function stack() {
  console.log(new Error().stack);
}

// test some fully sync code
async function synctest1() {
  var total = 0;
  for (var j = 0; j < 3; j++) {
    for (var i = 0; i < 3; i++) {
      total += i;
    }
    assert.equal(i, 3);
  }
  assert.equal(j, 3);
  assert.equal(total, 9);
}


async function synctest2() {
  var total = 0;
  for (var j = 0; j < 3; j++) {
    for (var i = 0; i < 3; i++) {
      total += i;
    }
    assert.equal(i, 3);
  }
  assert.equal(j, 3);
  assert.equal(total, 9);
}


async function synctest3() {
  var total = 0;
  for (var j = 0; j < 8; j++) {
    for (var i = 0; i < 8; i++) {
      if (i % 2 == 0) {
        total += i;
      }
    }
  }
  assert.equal(j, 8);
  assert.equal(total, 96);
}

async function synctest4() {
  var total = 0;
  for (var j = 0; j < 8; j++) {
    for (var i = 0; i < 8; i++) {
      if (i % 2 == 0)
        total += i;
    }
  }
  assert.equal(j, 8);
  assert.equal(total, 96);
}

async function synctest5() {
  var i = 0;
  var total = 0;
  while (i < 5) {
    total += i;
    i++;
  }
  assert.equal(i, 5);
  assert.equal(total, 10);
}

async function synctest6() {
  var i = 0;
  var total = 0;
  do
  {
    total += i;
    i++;
  } while (i < 5)
  //             ^
  // tested without a semicolon appended
  // to the while look
  assert.equal(i, 5);
  assert.equal(total, 10);
}

async function synctest7() {
  var i = 0;
  var total = 0;
  do
  {
    total += i;
    i++;
  } while (i < 5);
  assert.equal(i, 5);
  assert.equal(total, 10);
}

async function synctest8() {
  var total = 0;
  for (var i = 0; i < 10; i++) {
    if (i > 6) {
      break;
    }
    total += i;
  }
  assert.equal(i, 7);
  assert.equal(total, 21);
}

async function synctest9() {
  var total = 0;
  var i = 0;
  while (i < 10) {
    if (i > 6) {
      break;
    }
    total += i;
    i++;
  }
  assert.equal(total, 21);
}

async function synctest10() {
  var total = 0;
  var i = 0;
  do {
    if (i > 6) {
      break;
    }
    total += i;
    i++;
  }
  while (i < 10);
  assert.equal(total, 21);
}

async function synctest11() {
  var total = 0;
  for (var i = 0; i < 10; i++) {
    if (i > 6) {
      continue;
    }
    total += i;
  }
  assert.equal(total, 21);
}

async function synctest12() {
  var total = 0;
  var i = 0;
  while (i < 10) {
    if (i > 6) {
      ++i;
      continue;
    }
    total += i;
    i++;
  }
  assert.equal(total, 21);
}

async function synctest13() {
  var total = 0;
  var i = 0;
  do {
    if (i > 6) {
      ++i;
      continue;
    }
    total += i;
    i++;
  }
  while (i < 10);
  assert.equal(total, 21);
}

async function synctest14() {
  var i = 0;
  try {
    throw 1;
  }
  catch (e) {
    i = e;
  }
  assert.equal(i, 1);
}

async function synctest15() {
  var total = 0;
  try {
    for (var i = 0; i < 10; i++) {
      if (i > 6) {
        throw i;
      }
      total += i;
    }
  }
  catch (e) {
    total += e;
  }
  assert.equal(total, 28);
}

async function synctest16() {
  var total = 0;
  try {
    for (var i = 0; i < 10; i++) {
      if (i > 6) {
        throw i;
      }
      total += i;
    }
  }
  catch (e) {
    total += e;
  }
  finally {
    total += 10;
  }
  assert.equal(total, 38);
}

async function synctest17() {
  var total = 0;
  try {
    try {
      for (var i = 0; i < 10; i++) {
        if (i > 6) {
          throw i;
        }
        total += i;
      }
    }
    finally {
      total += 10;
    }
  }
  catch (e) {
    total += 10;
  }
  assert.equal(total, 41);
}

async function synctest18() {
  var total = 0;
  try {
    try {
      for (var i = 0; i < 10; i++) {
        if (i > 6) {
          throw i;
        }
        total += i;
      }
    }
    catch (e) {
      total += e;
    }
  }
  finally {
    total += 10;
  }
  assert.equal(total, 38);
}

async function asynctest1(done) {
  var total = 0;
  for (var i = 0; i < 10; i++) {
    await ret = callback(i);
    total += ret;
  }
  assert.equal(total, 45);
  done(total);
}

async function asynctest2(done) {
  var total = 0;
  for (var j = 0; j < 8; j++) {
    for (var i = 0; i < 8; i++) {
      if (i % 2 == 0) {
        await ret = callback(i);
        total += ret;
      }
    }
  }
  assert.equal(j, 8);
  assert.equal(total, 96);
  done(total);
}

async function asynctest3(done) {
  var i = 0;
  var total = 0;
  while (i < 5) {
    await ret = callback(i);
    total += ret;
    i++;
  }
  assert.equal(i, 5);
  assert.equal(total, 10);
  done(total);
}

async function asynctest4(done) {
  var i = 0;
  var total = 0;
  while (i < 5) {
    // test operator precendence
    await ret = callback(i++);
    total += ret;
  }
  assert.equal(i, 5);
  assert.equal(total, 10);
  done(total);
}


async function asynctest5(done) {
  var i = 0;
  var total = 0;
  while (i < 5) {
    // test operator precendence
    await ret = callback(++i);
    total += ret;
  }
  assert.equal(i, 5);
  assert.equal(total, 15);
  done(total);
}

async function asynctest6(done) {
  var i = 0;
  var total = 0;
  do
  {
    await ret = callback(i);
    total += ret;
    i++;
  } while (i < 5)
  //             ^
  // tested without a semicolon appended
  // to the while look
  assert.equal(i, 5);
  assert.equal(total, 10);
  done(total);
}

async function asynctest7(done) {
  var i = 0;
  var total = 0;
  do
  {
    await ret = callback(i);
    total += ret;
    i++;
  } while (i < 5);
  assert.equal(i, 5);
  assert.equal(total, 10);
  done(total);
}

async function asynctest8(done) {
  var total = 0;
  for (var i = 0; i < 10; i++) {
    await ret = callback(i);
    if (i > 6) {
      break;
    }
    total += ret;
  }
  assert.equal(i, 7);
  assert.equal(total, 21);
  done(total);
}

async function asynctest9(done) {
  var total = 0;
  var i = 0;
  while (i < 10) {
    await ret = callback(i);
    if (i > 6) {
      break;
    }
    total += ret;
    i++;
  }
  assert.equal(total, 21);
  done(total);
}

async function asynctest10(done) {
  var total = 0;
  var i = 0;
  do {
    await ret = callback(i);
    if (i > 6) {
      break;
    }
    total += ret;
    i++;
  }
  while (i < 10);
  assert.equal(total, 21);
  done(total);
}

async function asynctest11(done) {
  var total = 0;
  for (var i = 0; i < 10; i++) {
    await ret = callback(i);
    if (i > 6) {
      continue;
    }
    total += ret;
  }
  assert.equal(total, 21);
  done(total);
}

async function asynctest12(done) {
  var total = 0;
  var i = 0;
  while (i < 10) {
    await ret = callback(i++);
    if (i > 6) {
      continue;
    }
    total += ret;
  }
  assert.equal(total, 15);
  done(total);
}

async function asynctest13(done) {
  var total = 0;
  var i = 0;
  do {
    await ret = callback(i++);
    if (i > 6) {
      continue;
    }
    total += ret;
  }
  while (i < 10);
  assert.equal(total, 15);
  done(total);
}

async function asynctest14(done) {
  var i = 0;
  try {
    await ret = callback(1);
    throw ret;
  }
  catch (e) {
    i = e;
  }
  assert.equal(i, 1);
  done(i);
}

async function asynctest15(done) {
  var total = 0;
  try {
    for (var i = 0; i < 10; i++) {
      await ret = callback(i);
      if (i > 6) {
        throw ret;
      }
      total += i;
    }
  }
  catch (e) {
    total += e;
  }
  assert.equal(total, 28);
  done(total);
}

async function asynctest16(done) {
  var total = 0;
  try {
    for (var i = 0; i < 10; i++) {
      await ret = callback(i);
      if (i > 6) {
        throw ret;
      }
      total += i;
    }
  }
  catch (e) {
    total += e;
  }
  finally {
    total += 10;
  }
  assert.equal(total, 38);
  done(total);
}

async function asynctest17(done) {
  var total = 0;
  try {
    try {
      for (var i = 0; i < 10; i++) {
        if (i > 6) {
          await ret = callback(i);
          throw ret;
        }
        total += i;
      }
    }
    finally {
      total += 10;
    }
  }
  catch (e) {
    total += e;
  }
  assert.equal(total, 38);
  done(total);
}

async function asynctest18(done) {
  var total = 0;
  try {
    try {
      for (var i = 0; i < 10; i++) {
        await ret = callback(i);
        if (i > 6) {
          throw ret;
        }
        total += i;
      }
    }
    catch (e) {
      total += e;
    }
  }
  finally {
    total += 10;
  }
  assert.equal(total, 38);
  done(total);
}

async function regression1(done) {
  await ret = callback(20, []);
  assert.equal(ret, 20);
  done(ret);
}

// tests must complete in 5 seconds
var timeout = setTimeout(function() {
  assert.ok(result);
}, 50000);

var result = false;
var syncRunCount = 0;
var asyncRunCount = 0;
var regressionRunCount = 0;
async function runtests() {
  console.log('running synchronous smoke tests');
  synctest1();
  console.log('sync test ' + ++syncRunCount + ' completed.');
  synctest2();
  console.log('sync test ' + ++syncRunCount + ' completed.');
  synctest3();
  console.log('sync test ' + ++syncRunCount + ' completed.');
  synctest4();
  console.log('sync test ' + ++syncRunCount + ' completed.');
  synctest5();
  console.log('sync test ' + ++syncRunCount + ' completed.');
  synctest6();
  console.log('sync test ' + ++syncRunCount + ' completed.');
  synctest7();
  console.log('sync test ' + ++syncRunCount + ' completed.');
  synctest8();
  console.log('sync test ' + ++syncRunCount + ' completed.');
  synctest9();
  console.log('sync test ' + ++syncRunCount + ' completed.');
  synctest10();
  console.log('sync test ' + ++syncRunCount + ' completed.');
  synctest11();
  console.log('sync test ' + ++syncRunCount + ' completed.');
  synctest12();
  console.log('sync test ' + ++syncRunCount + ' completed.');
  synctest13();
  console.log('sync test ' + ++syncRunCount + ' completed.');
  synctest14();
  console.log('sync test ' + ++syncRunCount + ' completed.');
  synctest15();
  console.log('sync test ' + ++syncRunCount + ' completed.');
  synctest16();
  console.log('sync test ' + ++syncRunCount + ' completed.');
  synctest17();
  console.log('sync test ' + ++syncRunCount + ' completed.');
  synctest18();
  console.log('sync test ' + ++syncRunCount + ' completed.');

  console.log('running async tests');
  await x = asynctest1();
  console.log('async test ' + ++asyncRunCount + ' completed.');
  await x = asynctest2();
  console.log('async test ' + ++asyncRunCount + ' completed.');
  await x = asynctest3();
  console.log('async test ' + ++asyncRunCount + ' completed.');
  await x = asynctest4();
  console.log('async test ' + ++asyncRunCount + ' completed.');
  await x = asynctest5();
  console.log('async test ' + ++asyncRunCount + ' completed.');
  await x = asynctest6();
  console.log('async test ' + ++asyncRunCount + ' completed.');
  await x = asynctest7();
  console.log('async test ' + ++asyncRunCount + ' completed.');
  await x = asynctest8();
  console.log('async test ' + ++asyncRunCount + ' completed.');
  await x = asynctest9();
  console.log('async test ' + ++asyncRunCount + ' completed.');
  await x = asynctest10();
  console.log('async test ' + ++asyncRunCount + ' completed.');
  await x = asynctest11();
  console.log('async test ' + ++asyncRunCount + ' completed.');
  await x = asynctest12();
  console.log('async test ' + ++asyncRunCount + ' completed.');
  await x = asynctest13();
  console.log('async test ' + ++asyncRunCount + ' completed.');


  await x = asynctest14();
  console.log('async test ' + ++asyncRunCount + ' completed.');
  await x = asynctest15();
  console.log('async test ' + ++asyncRunCount + ' completed.');
  await x = asynctest16();
  console.log('async test ' + ++asyncRunCount + ' completed.');
  await x = asynctest17();
  console.log('async test ' + ++asyncRunCount + ' completed.');
  await x = asynctest18();
  console.log('async test ' + ++asyncRunCount + ' completed.');
  
  await x = regression1();
  console.log('regression test ' + ++regressionRunCount + ' completed.');

  assert.equal(syncRunCount + asyncRunCount + regressionRunCount, 37);
  console.log('all tests successful');
  result = true;
  clearTimeout(timeout);
}

runtests();