parser-combinator/build/test/genlex/genlex_test.js

Parser combinators

'use strict';

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

var _index = require('../../lib/stream/index');

var _index2 = _interopRequireDefault(_index);

var _genlex = require('../../lib/genlex/genlex');

var _genlex2 = _interopRequireDefault(_genlex);

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();
    },

    'expect (space) to be accepted': function expectSpaceToBeAccepted(test) {
        test.expect(1);
        // tests here
        test.equal(_genlex2.default.generator().space().parse(_index2.default.ofString(' '), 0).isAccepted(), true, 'should be accepted.');
        test.done();
    },

    'expect (meta space) to be accepted': function expectMetaSpaceToBeAccepted(test) {
        test.expect(1);
        // tests here
        test.equal(_genlex2.default.generator().space().parse(_index2.default.ofString('\t'), 0).isAccepted(), true, 'should be accepted.');
        test.done();
    },

    'expect (spaces) to be accepted': function expectSpacesToBeAccepted(test) {
        test.expect(1);
        // tests here
        test.equal(_genlex2.default.generator().spaces().parse(_index2.default.ofString(' \n  '), 0).isAccepted(), true, 'should be accepted.');
        test.done();
    },

    'expect (spaces) to be skipped': function expectSpacesToBeSkipped(test) {
        test.expect(1);
        // tests here
        test.equal(_genlex2.default.generator().spaces().parse(_index2.default.ofString(' \n '), 0).offset, 3, 'should be skipped.');
        test.done();
    },

    'expect (keyword) to be accepted': function expectKeywordToBeAccepted(test) {
        test.expect(1);
        // tests here
        var factory = _genlex2.default.factory(function (s) {
            return s;
        }, null, null, null, null);

        test.equal(_genlex2.default.generator(['<-', '->']).keyword(factory).parse(_index2.default.ofString('a->b'), 1).isAccepted(), true, 'should be accepted.');
        test.done();
    },

    'expect (keyword) to return ->': function expectKeywordToReturn(test) {
        test.expect(1);
        // tests here
        var factory = _genlex2.default.factory(function (s) {
            return s;
        }, null, null, null, null);

        test.equal(_genlex2.default.generator(['<-', '->']).keyword(factory).parse(_index2.default.ofString('a->b'), 1).value, '->', 'should be accepted.');
        test.done();
    },

    'expect (keyword) to be rejected': function expectKeywordToBeRejected(test) {
        test.expect(1);
        // tests here
        var factory = _genlex2.default.factory(function (s) {
            return s;
        }, null, null, null, null);

        test.equal(_genlex2.default.generator([]).keyword(factory).parse(_index2.default.ofString('->'), 1).isAccepted(), false, 'should be rejected.');
        test.done();
    },

    'expect (ident) to be accepted': function expectIdentToBeAccepted(test) {
        test.expect(1);
        // tests here
        var factory = _genlex2.default.factory(null, function (s) {
            return s;
        }, null, null, null);

        test.equal(_genlex2.default.generator([]).ident(factory).parse(_index2.default.ofString('smith '), 0).isAccepted(), true, 'should be accepted.');
        test.done();
    },

    'expect (ident) to return smith': function expectIdentToReturnSmith(test) {
        test.expect(1);
        // tests here
        var factory = _genlex2.default.factory(null, function (s) {
            return s;
        }, null, null, null);

        test.equal(_genlex2.default.generator([]).ident(factory).parse(_index2.default.ofString('smith '), 0).value, 'smith', 'should be smith.');
        test.done();
    },

    'expect (number) to be accepted': function expectNumberToBeAccepted(test) {
        test.expect(1);
        // tests here
        var factory = _genlex2.default.factory(null, null, function (s) {
            return s;
        }, null, null);

        test.equal(_genlex2.default.generator([]).number(factory).parse(_index2.default.ofString('42'), 0).isAccepted(), true, 'should be accepted.');
        test.done();
    },

    'expect (number) to return 42': function expectNumberToReturn42(test) {
        test.expect(1);
        // tests here
        var factory = _genlex2.default.factory(null, null, function (s) {
            return s;
        }, null, null);

        test.equal(_genlex2.default.generator([]).number(factory).parse(_index2.default.ofString('42'), 0).value, 42, 'should be 42.');
        test.done();
    },

    'expect (string) to be accepted': function expectStringToBeAccepted(test) {
        test.expect(1);
        // tests here
        var factory = _genlex2.default.factory(null, null, null, function (s) {
            return s;
        }, null);

        test.equal(_genlex2.default.generator([]).string(factory).parse(_index2.default.ofString('"smith"'), 0).isAccepted(), true, 'should be accepted.');
        test.done();
    },

    'expect (string) to return smith': function expectStringToReturnSmith(test) {
        test.expect(1);
        // tests here
        var factory = _genlex2.default.factory(null, null, null, function (s) {
            return s;
        }, null);

        test.equal(_genlex2.default.generator([]).string(factory).parse(_index2.default.ofString('"smith"'), 0).value, 'smith', 'should be smith.');
        test.done();
    },

    'expect (char) to be accepted': function expectCharToBeAccepted(test) {
        test.expect(1);
        // tests here
        var factory = _genlex2.default.factory(null, null, null, null, function (s) {
            return s;
        });

        test.equal(_genlex2.default.generator([]).char(factory).parse(_index2.default.ofString("'s'"), 0).isAccepted(), true, 'should be accepted.');
        test.done();
    },

    'expect (char) to return j': function expectCharToReturnJ(test) {
        test.expect(1);
        // tests here
        var factory = _genlex2.default.factory(null, null, null, null, function (s) {
            return s;
        });

        test.equal(_genlex2.default.generator([]).char(factory).parse(_index2.default.ofString("'s'"), 0).value, 's', 'should be s.');
        test.done();
    },

    'expect (token) to return keyword': function expectTokenToReturnKeyword(test) {
        test.expect(1);
        // tests here
        var factory = _genlex2.default.factory(function (s) {
            return s;
        }, null, null, null, null);

        test.equal(_genlex2.default.generator(['<-']).token(factory).parse(_index2.default.ofString('a<-b'), 1).value, '<-', 'should be <-.');
        test.done();
    },

    'expect (token) to return ident': function expectTokenToReturnIdent(test) {
        test.expect(1);
        // tests here
        var factory = _genlex2.default.factory(null, function (s) {
            return s;
        }, null, null, null);

        test.equal(_genlex2.default.generator(['<-']).token(factory).parse(_index2.default.ofString('hello'), 0).value, 'hello', 'should be hello.');
        test.done();
    },

    'expect (token) to return number': function expectTokenToReturnNumber(test) {
        test.expect(1);
        // tests here
        var factory = _genlex2.default.factory(null, null, function (s) {
            return s;
        }, null, null);

        test.equal(_genlex2.default.generator(['<-']).token(factory).parse(_index2.default.ofString('123'), 0).value, 123, 'should be 123.');
        test.done();
    },

    'expect (token) to return string': function expectTokenToReturnString(test) {
        test.expect(1);
        // tests here
        var factory = _genlex2.default.factory(null, null, null, function (s) {
            return s;
        }, null);

        test.equal(_genlex2.default.generator(['<-']).token(factory).parse(_index2.default.ofString('"123"'), 0).value, '123', 'should be 123.');
        test.done();
    },

    'expect (token) to return char': function expectTokenToReturnChar(test) {
        test.expect(1);
        // tests here
        var factory = _genlex2.default.factory(null, null, null, null, function (s) {
            return s;
        });

        test.equal(_genlex2.default.generator(['<-']).token(factory).parse(_index2.default.ofString("'a'"), 0).value, 'a', 'should be a.');
        test.done();
    },

    'expect (tokens) to return ["a","->","b"]': function expectTokensToReturnAB(test) {
        test.expect(1);
        // tests here
        var factory = _genlex2.default.factory(function (s) {
            return s;
        }, function (s) {
            return s;
        }, function (s) {
            return s;
        }, function (s) {
            return s;
        }, function (s) {
            return s;
        });

        test.deepEqual(_genlex2.default.generator(['->']).tokens(factory).parse(_index2.default.ofString('a -> b'), 0).value, ['a', '->', 'b'], 'should be [a,->,b].');
        test.done();
    }
};
//# sourceMappingURL=genlex_test.js.map