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

Parser combinators

'use strict';

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

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

var _index2 = _interopRequireDefault(_index);

var _token = require('../../lib/genlex/token');

var _token2 = _interopRequireDefault(_token);

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 (literal) to be rejected when empty stream': function expectLiteralToBeRejectedWhenEmptyStream(test) {
        test.expect(1);
        // tests here
        test.equal(_token2.default.parser.keyword.parse(_index2.default.ofArray([]), 0).isAccepted(), false, 'should be rejected.');
        test.done();
    },

    'expect (keyword) to be accepted': function expectKeywordToBeAccepted(test) {
        test.expect(1);
        // tests here
        test.equal(_token2.default.parser.keyword.parse(_index2.default.ofArray([_token2.default.builder.keyword('')]), 0).isAccepted(), true, 'should be accepted.');
        test.done();
    },

    'expect (ident) to be accepted': function expectIdentToBeAccepted(test) {
        test.expect(1);
        // tests here
        test.equal(_token2.default.parser.ident.parse(_index2.default.ofArray([_token2.default.builder.ident('')]), 0).isAccepted(), true, 'should be accepted.');
        test.done();
    },

    'expect (number) to be accepted': function expectNumberToBeAccepted(test) {
        test.expect(1);
        // tests here
        test.equal(_token2.default.parser.number.parse(_index2.default.ofArray([_token2.default.builder.number('')]), 0).isAccepted(), true, 'should be accepted.');
        test.done();
    },

    'expect (string) to be accepted': function expectStringToBeAccepted(test) {
        test.expect(1);
        // tests here
        test.equal(_token2.default.parser.string.parse(_index2.default.ofArray([_token2.default.builder.string('')]), 0).isAccepted(), true, 'should be accepted.');
        test.done();
    },

    'expect (char) to be accepted': function expectCharToBeAccepted(test) {
        test.expect(1);
        // tests here
        test.equal(_token2.default.parser.char.parse(_index2.default.ofArray([_token2.default.builder.char('')]), 0).isAccepted(), true, 'should be accepted.');
        test.done();
    },

    'expect (keyword) to be rejected': function expectKeywordToBeRejected(test) {
        test.expect(1);
        // tests here
        test.equal(_token2.default.parser.keyword.parse(_index2.default.ofArray([_token2.default.builder.ident('')]), 0).isAccepted(), false, 'should be rejected.');
        test.done();
    },

    'expect (ident) to be rejected': function expectIdentToBeRejected(test) {
        test.expect(1);
        // tests here
        test.equal(_token2.default.parser.ident.parse(_index2.default.ofArray([_token2.default.builder.number('')]), 0).isAccepted(), false, 'should be rejected.');
        test.done();
    },

    'expect (number) to be rejected': function expectNumberToBeRejected(test) {
        test.expect(1);
        // tests here
        test.equal(_token2.default.parser.number.parse(_index2.default.ofArray([_token2.default.builder.string('')]), 0).isAccepted(), false, 'should be rejected.');
        test.done();
    },

    'expect (string) to be rejected': function expectStringToBeRejected(test) {
        test.expect(1);
        // tests here
        test.equal(_token2.default.parser.string.parse(_index2.default.ofArray([_token2.default.builder.char('')]), 0).isAccepted(), false, 'should be rejected.');
        test.done();
    },

    'expect (char) to be rejected': function expectCharToBeRejected(test) {
        test.expect(1);
        // tests here
        test.equal(_token2.default.parser.char.parse(_index2.default.ofArray([_token2.default.builder.keyword('')]), 0).isAccepted(), false, 'should be rejected.');
        test.done();
    }
};
//# sourceMappingURL=token_test.js.map