parser-combinator/build/test/data/try_test.js

Parser combinators

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _try = require('../../lib/data/try');

var _try2 = _interopRequireDefault(_try);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/*
  ======== A Handy Little Nodeunit Reference ========
  https://github.com/caolan/nodeunit

  Test methods:
    test.expect(numAssertions)
    test.done()
  Test assertions:
    test.ok(value, [message])
    test.equal(actual, expected, [message])
    test.notEqual(actual, expected, [message])
    test.deepEqual(actual, expected, [message])
    test.notDeepEqual(actual, expected, [message])
    test.strictEqual(actual, expected, [message])
    test.notStrictEqual(actual, expected, [message])
    test.throws(block, [error], [message])
    test.doesNotThrow(block, [error], [message])
    test.ifError(value)
*/

exports.default = {
    setUp: function setUp(done) {
        done();
    },

    'atry success': function atrySuccess(test) {
        test.expect(1);
        // tests here
        test.ok(_try2.default.success(1).isSuccess(), 'should be success.');
        test.done();
    },

    'atry failure': function atryFailure(test) {
        test.expect(1);
        // tests here
        test.ok(_try2.default.failure(1).isFailure(), 'should be failure.');
        test.done();
    },

    'atry success map can be a success': function atrySuccessMapCanBeASuccess(test) {
        test.expect(1);
        // tests here
        test.ok(_try2.default.success(1).map(function (i) {
            return i + 1;
        }).isSuccess(), 'should be success.');
        test.done();
    },

    'atry success map can be a failure': function atrySuccessMapCanBeAFailure(test) {
        test.expect(1);
        // tests here
        test.ok(_try2.default.success(1).map(function () {
            throw new Error();
        }).isFailure(), 'should be failure.');
        test.done();
    },

    'atry success map': function atrySuccessMap(test) {
        test.expect(1);
        // tests here
        test.equal(_try2.default.success(1).map(function (i) {
            return i + 1;
        }).success(), 2, 'should be success.');
        test.done();
    },

    'atry failure map is a failure': function atryFailureMapIsAFailure(test) {
        test.expect(1);
        // tests here
        test.ok(_try2.default.failure(1).map(function (i) {
            return i + 1;
        }).isFailure(), 'should be failure.');
        test.done();
    },

    'atry failure map': function atryFailureMap(test) {
        test.expect(1);
        // tests here
        test.equal(_try2.default.failure(1).map(function (i) {
            return i + 1;
        }).failure(), 1, 'should be failure.');
        test.done();
    },

    'atry success flatmap of atry': function atrySuccessFlatmapOfAtry(test) {
        test.expect(1);
        // tests here
        test.equal(_try2.default.success(1).flatmap(function (i) {
            return _try2.default.success(i + 1);
        }).success(), 2, 'should be success.');
        test.done();
    },

    'atry failure flatmap of int': function atryFailureFlatmapOfInt(test) {
        test.expect(1);
        // tests here
        test.equal(_try2.default.failure(1).flatmap(function (i) {
            return i + 1;
        }).failure(), 1, 'should be failure.');
        test.done();
    },

    'atry failure flatmap of Error': function atryFailureFlatmapOfError(test) {
        test.expect(1);
        // tests here
        test.equal(_try2.default.success(1).flatmap(function () {
            throw 1;
        }).failure(), 1, 'should be failure.');
        test.done();
    },

    'atry success recoverWith': function atrySuccessRecoverWith(test) {
        test.expect(1);
        // tests here
        test.equal(_try2.default.success(1).recoverWith(2), 1, 'should be success.');
        test.done();
    },

    'atry failure recoverWith': function atryFailureRecoverWith(test) {
        test.expect(1);
        // tests here
        test.equal(_try2.default.failure(1).recoverWith(2), 2, 'should be failure.');
        test.done();
    },

    'atry success lazyRecoverWith': function atrySuccessLazyRecoverWith(test) {
        test.expect(1);
        // tests here
        test.equal(_try2.default.success(1).lazyRecoverWith(function () {
            return 2;
        }), 1, 'should be success.');
        test.done();
    },

    'atry failure lazyRecoverWith': function atryFailureLazyRecoverWith(test) {
        test.expect(1);
        // tests here
        test.equal(_try2.default.failure(1).lazyRecoverWith(function () {
            return 2;
        }), 2, 'should be failure.');
        test.done();
    },

    'atry success filter': function atrySuccessFilter(test) {
        test.expect(1);
        // tests here
        test.equal(_try2.default.success(1).filter(function (v) {
            return v === 1;
        }).isSuccess(), true, 'should be success.');
        test.done();
    },

    'atry success wrong filter': function atrySuccessWrongFilter(test) {
        test.expect(1);
        // tests here
        test.equal(_try2.default.success(1).filter(function (v) {
            return v === 2;
        }).isFailure(), true, 'should be failure.');
        test.done();
    },

    'atry failure filter': function atryFailureFilter(test) {
        test.expect(1);
        // tests here
        test.equal(_try2.default.failure(1).filter(function (v) {
            return v === 1;
        }).isFailure(), true, 'should be failure.');
        test.done();
    },

    'atry success onSuccess': function atrySuccessOnSuccess(test) {
        test.expect(1);
        // tests here
        var success = false;
        _try2.default.success(1).onSuccess(function () {
            success = true;
        });
        test.equal(success, true, 'should be true.');
        test.done();
    },

    'atry failure onSuccess': function atryFailureOnSuccess(test) {
        test.expect(1);
        // tests here
        var success = false;
        _try2.default.failure().onSuccess(function () {
            success = true;
        });
        test.equal(success, false, 'should be false.');
        test.done();
    },

    'atry success onFailure': function atrySuccessOnFailure(test) {
        test.expect(1);
        // tests here
        var failure = false;
        _try2.default.success(1).onFailure(function () {
            failure = true;
        });
        test.equal(failure, false, 'should be false.');
        test.done();
    },

    'atry failure onFailure': function atryFailureOnFailure(test) {
        test.expect(1);
        // tests here
        var failure = false;
        _try2.default.failure().onFailure(function () {
            failure = true;
        });
        test.equal(failure, true, 'should be true.');
        test.done();
    }
};
//# sourceMappingURL=try_test.js.map