Function testError

test/utils/evaluate-testcase.js:312–374

(testCase)

    }

    function testError(testCase) {
        'use strict';
        var sourceType, i, options, exception, expected, code, actual, err, handleInvalidRegexFlag, tokenize;

        // Different parsing options should give the same error.
        sourceType = testCase.key.match(/\.module$/) ? 'module' : 'script';
        options = [
            { jsx: true, sourceType: sourceType },
            { jsx: true, comment: true, sourceType: sourceType },
            { jsx: true, raw: true, sourceType: sourceType },
            { jsx: true, raw: true, comment: true, sourceType: sourceType }
        ];

        // If handleInvalidRegexFlag is true, an invalid flag in a regular expression
        // will throw an exception. In some old version of V8, this is not the case
        // and hence handleInvalidRegexFlag is false.
        handleInvalidRegexFlag = false;
        try {
            'test'.match(new RegExp('[a-z]', 'x'));
        } catch (e) {
            handleInvalidRegexFlag = true;
        }

        exception = testCase.failure;
        exception.description = exception.message.replace(/Error: Line [0-9]+: /, '');

        if (exception.tokenize) {
            tokenize = true;
            exception.tokenize = undefined;
        }

        expected = JSON.stringify(exception);

        code = testCase.case || testCase.source || '';

        for (i = 0; i < options.length; i += 1) {

            try {
                if (tokenize) {
                    esprima.tokenize(code, options[i]);
                } else {
                    esprima.parse(code, options[i]);
                }
            } catch (e) {
                err = errorToObject(e);
                err.description = e.description;
                actual = JSON.stringify(err);
            }

            if (expected !== actual) {

                // Compensate for old V8 which does not handle invalid flag.
                if (exception.message.indexOf('Invalid regular expression') > 0) {
                    if (typeof actual === 'undefined' && !handleInvalidRegexFlag) {
                        return;
                    }
                }