var tasks = {
    name: function () {}
};
proGulp.__set__("tasks", tasks);
proGulp.task("name").should.equal(tasks.name);

proGulp.task("name", function () {});
proGulp.task("name").should.be.of.type("function");

proGulp.task("name", function () {});
proGulp.task("name")().should.be.a.Promise;

var spy_0 = sinon.spy();
proGulp.task("name", spy_0);
return proGulp.task("name")().then(function () {
    spy_0.called.should.equal(true);
});

var spy_0 = sinon.spy();
var spy_1 = sinon.spy();
proGulp.task("name", spy_0, spy_1);
return proGulp.task("name")().then(function () {
    spy_0.called.should.equal(true);
    spy_1.called.should.equal(true);
});

var ret = proGulp.parallel();
ret.should.be.of.type("function");

var ret = proGulp.parallel([]);
ret().should.be.a.Promise;

var spy = sinon.spy();
proGulp.task("task_0", spy);
proGulp.task("task_1", spy);
var ret = proGulp.parallel(["task_0", "task_1"]);
return ret().then(function () {
    spy.calledTwice.should.equal(true);
});

var ret = proGulp.sequence();
ret.should.be.of.type("function");

var ret = proGulp.sequence([]);
ret().should.be.a.Promise;

var spies = [];
var getTime = function () {
    var timestamp = process.hrtime();
    return timestamp[0] * 1e9 + timestamp[1];
};
var createSpy = function (n) {
    spies[n] = {};
    spies[n].fn = sinon.spy(function () {
        spies[n].start = getTime();
        return BPromise.delay(100).then(function () {
            spies[n].end = getTime();
        });
    });
};
createSpy(0);
createSpy(1);
createSpy(2);
createSpy(3);
proGulp.task("task_0", spies[0].fn);
proGulp.task("task_1", spies[1].fn);
proGulp.task("task_2", spies[2].fn);
proGulp.task("task_3", spies[3].fn);
var ret = proGulp.sequence([
    "task_0",
    "task_1",
    "task_2",
    "task_3"
]);
return ret().then(function () {
    // Check they have been called
    spies[0].fn.called.should.equal(true);
    spies[1].fn.called.should.equal(true);
    spies[2].fn.called.should.equal(true);
    spies[3].fn.called.should.equal(true);
    // Check they have been called in the right order
    (spies[0].start < spies[0].end).should.equal(true);
    (spies[0].end < spies[1].start).should.equal(true);
    (spies[1].start < spies[1].end).should.equal(true);
    (spies[1].end < spies[2].start).should.equal(true);
    (spies[2].start < spies[2].end).should.equal(true);
    (spies[2].end < spies[3].start).should.equal(true);
    (spies[3].start < spies[3].end).should.equal(true);
});

var ctx = {};
log.start.call(ctx);
ctx.start.should.be.instanceOf(Date);

log.start.call({});
util.log.calledWithMatch(/Starting/).should.equal(true);

var ctx = {
    start: new Date()
};
log.end.call(ctx);
ctx.end.should.be.instanceOf(Date);

log.end.call({});
util.log.calledWithMatch(/Finished/).should.equal(true);

var ret = promisify();
ret.should.be.of.type("function");

var spy = sinon.spy();
var fn = promisify(spy);
fn();
spy.called.should.equal(true);

var spy = sinon.spy();
var fn = promisify(spy);
var ret = fn();
ret.should.be.a.Promise;

var stream = new events.EventEmitter();
stream.pipe = function noop () {};
var fn = promisify(function () {
    return stream;
});
var ret = fn();
stream.emit("end");
return ret.should.be.fulfilled;

var stream = new events.EventEmitter();
stream.pipe = function noop () {};
var fn = promisify(function () {
    return stream;
});
var ret = fn();
stream.emit("error");
return ret.should.be.rejected;

var promise = BPromise.resolve();
var fn = promisify(function () {
    return promise;
});
var ret = fn();
ret.should.equal(promise);

var value = {};
var fn = promisify(function () {
    return value;
});
var ret = fn();
return ret.should.eventually.equal(value);

var error = new Error();
var fn = promisify(function () {
    throw error;
});
fn.should.throw(error);