react 0.0.1 → 0.2.0

package/oldExamples/trait2.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var trait = require('traits').Trait;
+
+
+
+
+var tTaskMethods = trait({
+  ready: trait.required,
+  isReady: function(){ return this.ready; },
+  exec: function(){ console.log('exec'); },
+  toString: function(){ return 'taskMethods'; }
+});
+
+var tDebugOutput = trait({
+  isReady: trait.required,
+  toString: function(){ return "trait: ready: "+this.isReady(); }
+});
+
+function Foo() {
+}
+
+Foo.prototype = { };
+Foo.prototype.constructor = Foo;
+Foo.prototype.greet = function(){ console.log('hello'); };
+
+function taskFactory(ready){
+  return Object.create(Foo.prototype, trait.compose(
+    tTaskMethods,
+    tDebugOutput,
+    trait({ ready: ready })
+  ));
+}
+
+
+
+var t = taskFactory(true);
+console.log(t.toString());
+
+if (t.isReady()) {
+  t.exec();
+}
+
+t.greet();

package/package.json

@@ -1,13 +1,23 @@
 {
   "name": "react",
   "description": "React is a javascript module to make it easier to work with asynchronous code, by reducing boilerplate code and improving error and exception handling while allowing variable and task dependencies when defining flow.",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "author": "Jeff Barczewski <jeff.barczewski@gmail.com>",
-  "repository": { "type": "git", "url": "http://github.com/jeffbski/react.git" }, 
-  "bugs" : { "url": "http://github.com/jeffbski/react/issues" }, 
+  "repository": { "type": "git", "url": "http://github.com/jeffbski/react.git" },
+  "bugs" : { "url": "http://github.com/jeffbski/react/issues" },
   "licenses": [{ "type": "MIT", "url" : "http://github.com/jeffbski/react/raw/master/LICENSE" }],
   "main": "react",
-  "engines": { "node": "~v0.4.12" },
-  "dependencies": {},
-  "devDependencies": {}
+  "engines": { "node": "*" },
+  "dependencies": {
+    "eventemitter2": "~0.4.1",
+    "sprintf": "~0.1.1",
+    "ensure-array": "~0.0.2"
+  },
+  "devDependencies": {
+    "tap" : "~0.1.0",
+    "tapr" : "~0.1.0"
+  },
+  "scripts": {
+    "test": "node_modules/.bin/tapr test"
+  }
 }

package/react.js

@@ -1,2 +1,12 @@
+'use strict';
 
-module.exports = require('./lib/react');
+var core = require('./lib/core.js');
+
+module.exports = require('./lib/dsl.js');  // core + default dsl
+module.exports.options = core.options; // global react options
+module.exports.events = core.events;   // global react event emitter
+
+// additional interfaces
+module.exports.fstrDefine = require('./lib/fstr.js');
+module.exports.pcodeDefine = require('./lib/pcode.js');
+module.exports.chainDefine = require('./lib/chain.js');

package/test/ast.test.js

@@ -0,0 +1,69 @@
+'use strict';
+
+var test = require('tap').test;
+
+var react = require('../react');
+
+function load(res, cb) { cb(null, res + '-loaded'); }
+function prefix(prefstr, str, cb) { cb(null, prefstr + str); }
+function postfix(str, poststr, cb) { cb(null, str + poststr); }
+function upper(str) { return str.toUpperCase(); }
+function makeError(str, cb) { cb(new Error('makeErr-' + str)); }
+
+test('mixed', function (t) {
+  t.plan(5);
+  
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['res', 'prefstr', 'poststr'],
+    tasks: [
+      { f: load,    a: ['res'],              out: ['lres'] },
+      { f: upper,   a: ['lres'],             out: ['ulres'], type: 'ret'  },
+      { f: prefix,  a: ['prefstr', 'ulres'], out: ['plres'] },
+      { f: postfix, a: ['plres', 'poststr'], out: ['plresp'] }
+    ],
+    outTask: { a: ['plresp'] }
+  });
+
+  t.deepEqual(errors, []);
+
+  fn('foo', 'pre-', '-post', function cb(err, lres) {
+    t.equal(err, null);
+    t.equal(lres, 'pre-FOO-LOADED-post');
+  });
+
+  fn('bar', 'PRE-', '-POST', function cb(err, lres) {
+    t.equal(err, null);
+    t.equal(lres, 'PRE-BAR-LOADED-POST');
+  });
+});
+
+test('cb with err', function (t) {
+  t.plan(5);
+  
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['res', 'prefstr', 'poststr'],
+    tasks: [
+      { f: load,      a: ['res'],               out: ['lres'] },
+      { f: upper,     a: ['lres'],              out: ['ulres'], type: 'ret' },
+      { f: makeError, a: ['ulres'],             out: ['na']  },
+      { f: prefix,    a: ['prefstr', 'na'],     out: ['plres'] },
+      { f: postfix,   a: ['plres', 'poststr'],  out: ['plresp'] }
+    ],
+    outTask: { a: ['plresp'] }
+  });
+
+  t.deepEqual(errors, []);
+
+  fn('foo', 'pre-', '-post', function cb(err, lres) {
+    t.equal(err.message, 'makeErr-FOO-LOADED');
+    t.equal(lres, undefined);
+  });
+
+  fn('bar', 'PRE-', '-POST', function cb(err, lres) {
+    t.equal(err.message, 'makeErr-BAR-LOADED');
+    t.equal(lres, undefined);
+  });
+});
+

package/test/cb-task.test.js

@@ -0,0 +1,197 @@
+'use strict';
+
+var test = require('tap').test;
+
+var CbTask = require('../lib/cb-task.js');
+var VContext = require('../lib/vcon.js');
+
+function foo() { }
+function bar() { }
+function cat() { }
+
+test('new task is not complete', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: [], out: []});
+  t.equal(task.isComplete(), false);
+  t.end();
+});
+
+test('ready task is not complete', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: [], out: [], status: 'ready'});
+  t.equal(task.isComplete(), false);
+  t.end();
+});
+
+test('running task is not complete', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: [], out: [], status: 'running'});
+  t.equal(task.isComplete(), false);
+  t.end();
+});
+
+test('complete task is complete', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: [], out: [], status: 'complete' });
+  t.equal(task.isComplete(), true);
+  t.end();
+});
+
+test('task with any status is not ready', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: [], out: [], status: 'complete' });
+  var vCon = VContext.create([], []);
+  var tasksByName = { foo: task };
+  t.equal(task.isReady(vCon, tasksByName), false);
+  task.status = 'ready';
+  t.equal(task.isReady(vCon, tasksByName), false);
+  task.status = 'running';
+  t.equal(task.isReady(vCon, tasksByName), false);
+  task.status = null;
+  t.equal(task.isReady(vCon, tasksByName), true);
+  t.end();  
+});
+
+test('no args defined, no after -> not ready', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: ['b'], out: [] });
+  var vCon = VContext.create([], []);
+  var tasksByName = { foo: task };
+  t.equal(task.isReady(vCon, tasksByName), false);
+  t.end();
+});
+
+test('objprop undefined -> NOT ready', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c.prop'], out: [] });
+  var vCon = VContext.create([1, {}], ['b', 'c']);
+  var tasksByName = { foo: task };
+  t.equal(task.isReady(vCon, tasksByName), false);
+  t.end();  
+});
+
+test('all args defined, no after, out no obj parent -> NOT ready', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c'], out: ['d.e'] });
+  var vCon = VContext.create([1, null], ['b', 'c']);
+  var tasksByName = { foo: task };
+  t.equal(task.isReady(vCon, tasksByName), false, 'false if out objparent undef');  
+  t.end();  
+});
+
+test('all args defined, no after, out no obj.par.par -> NOT ready', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c'], out: ['c.e.f'] });
+  var vCon = VContext.create([1, { }], ['b', 'c']);
+  var tasksByName = { foo: task };
+  t.equal(task.isReady(vCon, tasksByName), false, 'false if out objparent undef');  
+  t.end();  
+});
+
+test('all args defined, no after, out null obj parent -> NOT ready', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c'], out: ['c.e'] });
+  var vCon = VContext.create([1, null], ['b', 'c']);
+  var tasksByName = { foo: task };
+  t.equal(task.isReady(vCon, tasksByName), false, 'false if out objparent null');  
+  t.end();  
+});
+
+test('all args defined, no after, out null obj.par.par -> NOT ready', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c'], out: ['c.e.f'] });
+  var vCon = VContext.create([1, { e: null }], ['b', 'c']);
+  var tasksByName = { foo: task };
+  t.equal(task.isReady(vCon, tasksByName), false, 'false if out objparent null');  
+  t.end();  
+});
+
+test('all args defined, no after -> ready', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c'], out: ['d'] });
+  var vCon = VContext.create([1, null], ['b', 'c']);
+  var tasksByName = { foo: task };
+  t.equal(task.isReady(vCon, tasksByName), true);
+  t.end();  
+});
+
+test('all args defined, objprop null, no after -> ready', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c.prop'], out: [] });
+  var vCon = VContext.create([1, { prop: null }], ['b', 'c']);
+  var tasksByName = { foo: task };
+  t.equal(task.isReady(vCon, tasksByName), true);
+  t.end();  
+});
+
+test('all args defined, after not complete -> NOT ready', function (t) {
+  var tcat = new CbTask({ type: 'cb', f: cat, a: [], out: [], status: 'complete' });
+  var tbar = new CbTask({ type: 'cb', f: bar, a: [], out: [], status: 'running' });
+  var task = new CbTask(
+    { type: 'cb', f: foo, a: ['b', 'c'], out: [], after: ['cat', 'bar']});
+  var vCon = VContext.create([1, 2], ['b', 'c']);
+  var tasksByName = { foo: task, bar: tbar, cat: tcat };
+  t.equal(task.isReady(vCon, tasksByName), false);  
+  t.end();  
+});
+
+test('all args defined, after all complete -> ready', function (t) {
+  var tcat = new CbTask({ type: 'cb', f: cat, a: [], out: [], status: 'complete' });
+  var tbar = new CbTask({ type: 'cb', f: bar, a: [], out: [], status: 'complete' });
+  var task = new CbTask(
+    { type: 'cb', f: foo, a: ['b', 'c'], out: [], after: ['cat', 'bar']});
+  var vCon = VContext.create([1, 2], ['b', 'c']);
+  var tasksByName = { foo: task, bar: tbar, cat: tcat };
+  t.equal(task.isReady(vCon, tasksByName), true);  
+  t.end();  
+});
+
+test('string without . is not method call', function (t) {
+  var task = new CbTask({ type: 'cb', f: 'foo', a: [], out: [] });
+  t.equal(task.isMethodCall(), false);
+  task.f = null;
+  t.equal(task.isMethodCall(), false);
+  t.end();
+});
+
+test('string with . is method call', function (t) {
+  var task = new CbTask({ type: 'cb', f: 'foo.bar', a: [], out: [] });
+  t.equal(task.isMethodCall(), true);
+  task.f = 'foo.bar.baz';
+  t.equal(task.isMethodCall(), true);
+  t.end();
+});
+
+test('undefined or null fn - functionExists', function (t) {
+  var task = new CbTask({ type: 'cb', f: 'foo', a: [], out: [] });
+  var vCon = VContext.create([], []);
+  task.f = null;
+  t.notOk(task.functionExists(vCon));
+  task.f = undefined;
+  t.notOk(task.functionExists(vCon));
+  task.f = 'foo';
+  t.notOk(task.functionExists(vCon));
+  vCon.values.foo = { };
+  task.f = 'foo.bar';
+  t.notOk(task.functionExists(vCon));
+  t.end();
+});
+
+test('functionExists', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: [], out: [] });
+  var vCon = VContext.create([], []);
+  t.ok(task.functionExists(vCon));
+  t.end();
+});
+
+test('method functionExists', function (t) {
+  var task = new CbTask({ type: 'cb', f: 'foo.b', a: [], out: [] });
+  var vCon = VContext.create([{b: bar}], ['foo']);
+  t.ok(task.functionExists(vCon));
+  task.f = 'foo.bar.cat';
+  vCon.values.foo = { bar: { cat: cat}};
+  t.ok(task.functionExists(vCon));
+  t.end();
+});
+
+test('getMethodObj non-existent return undefined', function (t) {
+  var task = new CbTask({ type: 'cb', f: 'foo.b.c', a: [], out: [] });
+  var vCon = VContext.create([{}], ['foo']);
+  t.equal(task.getMethodObj(vCon), undefined);
+  t.end();
+});
+
+test('getMethodObj returns object', function (t) {
+  var task = new CbTask({ type: 'cb', f: 'foo.b', a: [], out: [] });
+  var vCon = VContext.create([{b: bar}], ['foo']);
+  t.deepEqual(task.getMethodObj(vCon), { b: bar});
+  t.end();
+});
+

package/test/chain.test.js

@@ -0,0 +1,239 @@
+'use strict';
+
+var test = require('tap').test;
+var sprintf = require('sprintf').sprintf;
+
+var chainDefine = require('../lib/chain.js');
+
+function falpha() { }
+function fbeta() { }
+
+test('module exports a function', function (t) {
+  t.type(chainDefine, 'function', 'has define by chain method');
+  t.type(chainDefine(), 'object', 'has define by chain method');
+  t.type(chainDefine().selectFirst, 'function', 'has selectFirst def');
+  t.type(chainDefine().in, 'function', 'has input param def');
+  t.type(chainDefine().out, 'function', 'has output param def');
+  t.type(chainDefine().async, 'function', 'has async - cb type task def');
+  t.type(chainDefine().sync, 'function', 'has sync - ret type task def');
+  t.type(chainDefine().after, 'function', 'has after prereq def');
+  t.type(chainDefine().end, 'function', 'has end to complete flow and validate');
+  t.end();
+});
+
+test('no arguments -> empty inParams, tasks, outTask', function (t) {
+  var fn = chainDefine().end();
+  t.deepEqual(fn.ast.inParams, []);
+  t.deepEqual(fn.ast.tasks, []);
+  t.deepEqual(fn.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();
+});
+
+
+test('in only -> inParams["foo"], empty tasks, outTask', function (t) {
+  var fn = chainDefine()
+    .in('foo')
+    .end();
+  t.deepEqual(fn.ast.inParams, ['foo']);
+  t.deepEqual(fn.ast.tasks, []);
+  t.deepEqual(fn.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();
+});
+
+test('in empty  -> inParams["foo"], empty tasks, outTask', function (t) {
+  var fn = chainDefine()
+    .in()
+    .end();
+  t.deepEqual(fn.ast.inParams, []);
+  t.deepEqual(fn.ast.tasks, []);
+  t.deepEqual(fn.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();
+});
+
+
+test('in triple first param -> inParams["foo", "bar", "baz"]', function (t) {
+  var fn = chainDefine()
+    .in('foo', 'bar', 'baz')
+    .end();
+  t.deepEqual(fn.ast.inParams, ['foo', 'bar', 'baz']);
+  t.deepEqual(fn.ast.tasks, []);
+  t.deepEqual(fn.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();
+});
+
+test('single task, single out params', function (t) {
+  var fn = chainDefine()
+    .out('c')
+    .async(falpha).in('a', 'b').out('c')
+    .end();
+  t.deepEqual(fn.ast.inParams, []);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha' }
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c'], type: 'finalcb' });
+  t.end();  
+});
+
+test('single task, err and out params', function (t) {
+  var fn = chainDefine()
+    .out('err', 'c')
+    .async(falpha).in('a', 'b').out('err', 'c')
+    .end();
+  t.deepEqual(fn.ast.inParams, []);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha' }
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c'], type: 'finalcb' });
+  t.end();  
+});
+
+test('single task, ERR and out params', function (t) {
+  var fn = chainDefine()
+    .out('ERR', 'c')
+    .async(falpha).in('a', 'b').out('ERR', 'c')
+    .end();
+  t.deepEqual(fn.ast.inParams, []);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha' }
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c'], type: 'finalcb' });
+  t.end();  
+});
+
+test('cb used in defs is simply ignored', function (t) {
+  var fn = chainDefine()
+    .in('a', 'b', 'cb')
+    .out('err', 'c')
+    .async(falpha).in('a', 'b', 'cb').out('err', 'c')
+    .end();
+  t.deepEqual(fn.ast.inParams, ['a', 'b']);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha'}
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c'], type: 'finalcb' });
+  t.end();  
+});
+
+test('callback used in defs is simply ignored', function (t) {
+  var fn = chainDefine()
+    .in('a', 'b', 'callback')
+    .out('err', 'c')
+    .async(falpha).in('a', 'b', 'callback').out('err', 'c')
+    .end();
+  t.deepEqual(fn.ast.inParams, ['a', 'b']);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha'}
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c'], type: 'finalcb' });
+  t.end();  
+});
+
+test('two inputs, two tasks, two out params', function (t) {
+  var fn = chainDefine()
+    .in('a', 'b', 'cb')
+    .out('err', 'c', 'd')
+    .async(falpha).in('a', 'b', 'cb').out('err', 'c')
+    .async(fbeta).in('a', 'b', 'cb').out('err', 'd', 'e')
+    .end();
+  t.deepEqual(fn.ast.inParams, ['a', 'b']);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha'},
+    { f: fbeta, type: 'cb', a: ['a', 'b'], out: ['d', 'e'], name: 'fbeta'}
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+test('two inputs, two tasks, two out params, name, options', function (t) {
+  var fn = chainDefine()
+    .name('myflow')
+    .in('a', 'b', 'cb')
+    .out('err', 'c', 'd')
+    .options({ otherOptFoo: 'foo'})
+    .async(falpha).in('a', 'b', 'cb').out('err', 'c').name('myalpha')
+    .async(fbeta).in('a', 'b', 'cb').out('err', 'd', 'e').options({ bar: 'bar'})
+    .end();
+  t.deepEqual(fn.ast.inParams, ['a', 'b']);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'myalpha'},
+    { f: fbeta, type: 'cb', a: ['a', 'b'], out: ['d', 'e'],
+      bar: 'bar', name: 'fbeta' }
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.equal(fn.ast.name, 'myflow', 'name should match if supplied');
+  t.equal(fn.ast.otherOptFoo, 'foo', 'other options should pass through');
+  t.end();  
+});
+
+test('two inputs, two mixed tasks, two out params', function (t) {
+  var fn = chainDefine()
+    .in('a', 'b', 'cb')
+    .out('err', 'c', 'd')
+    .async(falpha).in('a', 'b', 'cb').out('err', 'c')
+    .sync(fbeta).in('a', 'b').out('d')
+    .end();
+  t.deepEqual(fn.ast.inParams, ['a', 'b']);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha'},
+    { f: fbeta, type: 'ret', a: ['a', 'b'], out: ['d'], name: 'fbeta'}
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+test('two inputs, two mixed tasks, two out params, opts', function (t) {
+  var fn = chainDefine()
+    .in('a', 'b', 'cb')
+    .out('err', 'c', 'd')
+    .async(falpha).in('a', 'b', 'cb').out('err', 'c').after(fbeta)
+    .sync(fbeta).in('a', 'b').out('d')
+    .end();
+  t.deepEqual(fn.ast.inParams, ['a', 'b']);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], after: ['fbeta'], name: 'falpha'},
+    { f: fbeta, type: 'ret', a: ['a', 'b'], out: ['d'], name: 'fbeta'}
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+// Object use
+test('object prop task params', function (t) {
+  var fn = chainDefine()
+    .in('a', 'b', 'cb')
+    .out('err', 'c', 'e')
+    .async(falpha).in('a', 'b.cat', 'cb').out('err', 'c')
+    .sync(fbeta).in('c.dog', 'b').out('d')
+    .async('d.egg').in('c').out('err', 'e')
+    .end();
+  t.deepEqual(fn.ast.inParams, ['a', 'b']);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: ['a', 'b.cat'], out: ['c'], name: 'falpha'},
+    { f: fbeta, type: 'ret', a: ['c.dog', 'b'], out: ['d'], name: 'fbeta'},
+    { f: 'd.egg', type: 'cb', a: ['c'], out: ['e'], name: 'd.egg'}
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c', 'e'], type: 'finalcb' });
+  t.end();  
+});
+
+
+// selectFirst 
+
+test('selectFirst', function (t) {
+  var fn = chainDefine()
+    .selectFirst()
+    .in('a', 'b', 'cb')
+    .out('err', 'c')
+    .async(falpha).in('a', 'b', 'cb').out('err', 'c')
+    .sync(fbeta).in('a', 'b').out('c')
+    .end();
+  t.deepEqual(fn.ast.inParams, ['a', 'b']);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha'},
+    { f: fbeta,  type: 'ret', a: ['a', 'b'], out: ['c'], name: 'fbeta', after: ['falpha']}
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c'], type: 'finalcbFirst' });
+  t.end();  
+});
+
+