joepie91/pegjs
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity
pegjs/test/unit/compiler/passes/report-infinite-recursion.spec.js

120 lines
4.1 KiB
JavaScript
Raw Normal View History

Convert PEG.js code to strict mode * Issues #323
2015-06-08 20:21:19 +02:00
"use strict";
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
let chai = require("chai");
let helpers = require("./helpers");
Tests: Require specific modules instead of the whole library Requiring the whole library was a relict from the time where the tests were exercising the browser build when run in the browser.
2016-12-16 13:21:48 +01:00
let pass = require("../../../../lib/compiler/passes/report-infinite-recursion");
Pass spec code through Babel before serving it to the browser This will allow to use ES2015 constructs in spec code. The change required introducing a small server, which serves both PEG.js and spec code passed through Babel and bundled together. This allowed to convert the specs to regular modules and get rid of the hackery that was previously needed to make them run both in Node.js and in the browser. Note the specs no longer exercise the browser version. This will allow to spec PEG.js internals in the future. See #442.
2016-09-08 13:29:06 +02:00
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
chai.use(helpers);
let expect = chai.expect;
Align names of compiler passes that detect infinite loops Rename compiler passes as follows: reportLeftRecursion -> reportInfiniteRecursion reportInfiniteLoops -> reportInfiniteRepetition This reflects the fact that both passes detect different ways of causing the same problem (possible infinite loop when parsing).
2016-07-29 18:06:16 +02:00
describe("compiler pass |reportInfiniteRecursion|", function() {
Specs cleanup: Simplify compiler passes specs After 898a7b5a2d0438aecfca9d0ec548ff60fcb00747 the specs mostly tested the visitor implementation, not actual code in the passes.
2014-06-07 09:11:00 +02:00
it("reports direct left recursion", function() {
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.reportError("start = start", {
Avoid aligning object keys The only exception left are objects representing a mapping with simple keys and values -- essentially tables written as object literals. See #443.
2016-09-22 05:25:09 +02:00
message: "Possible infinite loop when parsing (left recursion: start -> start).",
Add location information to |GrammarError| This means all errors thrown by |PEG.buildParser| now have associated location information.
2015-04-06 10:34:07 +02:00
location: {
Avoid aligning object keys The only exception left are objects representing a mapping with simple keys and values -- essentially tables written as object literals. See #443.
2016-09-22 05:25:09 +02:00
start: { offset: 8, line: 1, column: 9 },
end: { offset: 13, line: 1, column: 14 }
Add location information to |GrammarError| This means all errors thrown by |PEG.buildParser| now have associated location information.
2015-04-06 10:34:07 +02:00
}
Jasmine: Convert |reportLeftRecursion| compiler pass tests
2012-04-30 13:42:13 +02:00
});
});
it("reports indirect left recursion", function() {
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.reportError([
Use only double quotes for strings See #443
2016-09-21 15:06:56 +02:00
"start = stop",
Avoid aligning "=" The only exception left are instances where aligning "=" helps to express symmetry between lines. See #443.
2016-09-22 09:25:31 +02:00
"stop = start"
Specs cleanup: Simplify compiler passes specs After 898a7b5a2d0438aecfca9d0ec548ff60fcb00747 the specs mostly tested the visitor implementation, not actual code in the passes.
2014-06-07 09:11:00 +02:00
].join("\n"), {
Avoid aligning object keys The only exception left are objects representing a mapping with simple keys and values -- essentially tables written as object literals. See #443.
2016-09-22 05:25:09 +02:00
message: "Possible infinite loop when parsing (left recursion: start -> stop -> start).",
Add location information to |GrammarError| This means all errors thrown by |PEG.buildParser| now have associated location information.
2015-04-06 10:34:07 +02:00
location: {
Avoid aligning "=" The only exception left are instances where aligning "=" helps to express symmetry between lines. See #443.
2016-09-22 09:25:31 +02:00
start: { offset: 20, line: 2, column: 8 },
end: { offset: 25, line: 2, column: 13 }
Add location information to |GrammarError| This means all errors thrown by |PEG.buildParser| now have associated location information.
2015-04-06 10:34:07 +02:00
}
Specs cleanup: Simplify compiler passes specs After 898a7b5a2d0438aecfca9d0ec548ff60fcb00747 the specs mostly tested the visitor implementation, not actual code in the passes.
2014-06-07 09:11:00 +02:00
});
});
describe("in sequences", function() {
Fix left recursion detection So far, left recursion detector assumed that left recursion occurs only when the recursive rule is at the very left-hand side of rule's expression: start = start This didn't catch cases like this: start = "a"? start In general, if a rule reference can be reached without consuming any input, it can lead to left recursion. This commit fixes the detector to consider that. Fixes #190.
2015-03-31 19:02:59 +02:00
it("reports left recursion if all preceding elements match empty string", function() {
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.reportError("start = '' '' '' start");
Fix left recursion detection So far, left recursion detector assumed that left recursion occurs only when the recursive rule is at the very left-hand side of rule's expression: start = start This didn't catch cases like this: start = "a"? start In general, if a rule reference can be reached without consuming any input, it can lead to left recursion. This commit fixes the detector to consider that. Fixes #190.
2015-03-31 19:02:59 +02:00
});
it("doesn't report left recursion if some preceding element doesn't match empty string", function() {
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.not.reportError("start = 'a' '' '' start");
expect(pass).to.not.reportError("start = '' 'a' '' start");
expect(pass).to.not.reportError("start = '' '' 'a' start");
Fix left recursion detection So far, left recursion detector assumed that left recursion occurs only when the recursive rule is at the very left-hand side of rule's expression: start = start This didn't catch cases like this: start = "a"? start In general, if a rule reference can be reached without consuming any input, it can lead to left recursion. This commit fixes the detector to consider that. Fixes #190.
2015-03-31 19:02:59 +02:00
});
Use only "//" comments See #443.
2016-09-17 16:28:28 +02:00
// Regression test for #359.
Fix left recursion detection in sequences Report left recursion also in cases where the recursive rule invocation is not a direct element of a sequence, but is wrapped inside an expression. Fixes #359.
2015-08-17 10:58:37 +02:00
it("reports left recursion when rule reference is wrapped in an expression", function() {
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.reportError("start = '' start?");
Fix left recursion detection in sequences Report left recursion also in cases where the recursive rule invocation is not a direct element of a sequence, but is wrapped inside an expression. Fixes #359.
2015-08-17 10:58:37 +02:00
});
s/alwaysAdvancesOnSuccess/alwaysConsumesOnSuccess/ Matches terminology change from the previous commit.
2015-09-04 17:35:37 +02:00
it("computes expressions that always consume input on success correctly", function() {
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.reportError([
Use only double quotes for strings See #443
2016-09-21 15:06:56 +02:00
"start = a start",
"a 'a' = ''"
].join("\n"));
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.not.reportError([
Use only double quotes for strings See #443
2016-09-21 15:06:56 +02:00
"start = a start",
"a 'a' = 'a'"
].join("\n"));
Make infinite loop and left recursion detectors work with named rules Add missing |named| case to the visitor in lib/compiler/asts.js, which makes the infinite loop and left recursion detectors work correctly with named rules. The missing case caused |make parser| to fail with: 140:34: Infinite loop detected. make: *** [parser] Error 1
2015-08-03 16:56:57 +02:00
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.reportError("start = ('' / 'a' / 'b') start");
expect(pass).to.reportError("start = ('a' / '' / 'b') start");
expect(pass).to.reportError("start = ('a' / 'b' / '') start");
expect(pass).to.not.reportError("start = ('a' / 'b' / 'c') start");
Fix left recursion detection So far, left recursion detector assumed that left recursion occurs only when the recursive rule is at the very left-hand side of rule's expression: start = start This didn't catch cases like this: start = "a"? start In general, if a rule reference can be reached without consuming any input, it can lead to left recursion. This commit fixes the detector to consider that. Fixes #190.
2015-03-31 19:02:59 +02:00
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.reportError("start = ('' { }) start");
expect(pass).to.not.reportError("start = ('a' { }) start");
Fix left recursion detection So far, left recursion detector assumed that left recursion occurs only when the recursive rule is at the very left-hand side of rule's expression: start = start This didn't catch cases like this: start = "a"? start In general, if a rule reference can be reached without consuming any input, it can lead to left recursion. This commit fixes the detector to consider that. Fixes #190.
2015-03-31 19:02:59 +02:00
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.reportError("start = ('' '' '') start");
expect(pass).to.not.reportError("start = ('a' '' '') start");
expect(pass).to.not.reportError("start = ('' 'a' '') start");
expect(pass).to.not.reportError("start = ('' '' 'a') start");
Fix left recursion detection So far, left recursion detector assumed that left recursion occurs only when the recursive rule is at the very left-hand side of rule's expression: start = start This didn't catch cases like this: start = "a"? start In general, if a rule reference can be reached without consuming any input, it can lead to left recursion. This commit fixes the detector to consider that. Fixes #190.
2015-03-31 19:02:59 +02:00
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.reportError("start = a:'' start");
expect(pass).to.not.reportError("start = a:'a' start");
Fix left recursion detection So far, left recursion detector assumed that left recursion occurs only when the recursive rule is at the very left-hand side of rule's expression: start = start This didn't catch cases like this: start = "a"? start In general, if a rule reference can be reached without consuming any input, it can lead to left recursion. This commit fixes the detector to consider that. Fixes #190.
2015-03-31 19:02:59 +02:00
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.reportError("start = $'' start");
expect(pass).to.not.reportError("start = $'a' start");
Fix left recursion detection So far, left recursion detector assumed that left recursion occurs only when the recursive rule is at the very left-hand side of rule's expression: start = start This didn't catch cases like this: start = "a"? start In general, if a rule reference can be reached without consuming any input, it can lead to left recursion. This commit fixes the detector to consider that. Fixes #190.
2015-03-31 19:02:59 +02:00
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.reportError("start = &'' start");
expect(pass).to.reportError("start = &'a' start");
Fix left recursion detection So far, left recursion detector assumed that left recursion occurs only when the recursive rule is at the very left-hand side of rule's expression: start = start This didn't catch cases like this: start = "a"? start In general, if a rule reference can be reached without consuming any input, it can lead to left recursion. This commit fixes the detector to consider that. Fixes #190.
2015-03-31 19:02:59 +02:00
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.reportError("start = !'' start");
expect(pass).to.reportError("start = !'a' start");
Fix left recursion detection So far, left recursion detector assumed that left recursion occurs only when the recursive rule is at the very left-hand side of rule's expression: start = start This didn't catch cases like this: start = "a"? start In general, if a rule reference can be reached without consuming any input, it can lead to left recursion. This commit fixes the detector to consider that. Fixes #190.
2015-03-31 19:02:59 +02:00
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.reportError("start = ''? start");
expect(pass).to.reportError("start = 'a'? start");
Fix left recursion detection So far, left recursion detector assumed that left recursion occurs only when the recursive rule is at the very left-hand side of rule's expression: start = start This didn't catch cases like this: start = "a"? start In general, if a rule reference can be reached without consuming any input, it can lead to left recursion. This commit fixes the detector to consider that. Fixes #190.
2015-03-31 19:02:59 +02:00
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.reportError("start = ''* start");
expect(pass).to.reportError("start = 'a'* start");
Fix left recursion detection So far, left recursion detector assumed that left recursion occurs only when the recursive rule is at the very left-hand side of rule's expression: start = start This didn't catch cases like this: start = "a"? start In general, if a rule reference can be reached without consuming any input, it can lead to left recursion. This commit fixes the detector to consider that. Fixes #190.
2015-03-31 19:02:59 +02:00
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.reportError("start = ''+ start");
expect(pass).to.not.reportError("start = 'a'+ start");
Fix left recursion detection So far, left recursion detector assumed that left recursion occurs only when the recursive rule is at the very left-hand side of rule's expression: start = start This didn't catch cases like this: start = "a"? start In general, if a rule reference can be reached without consuming any input, it can lead to left recursion. This commit fixes the detector to consider that. Fixes #190.
2015-03-31 19:02:59 +02:00
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.reportError("start = ('') start");
expect(pass).to.not.reportError("start = ('a') start");
Fix labels leaking to outer scope Labels in expressions like "(a:"a")" or "(a:"a" b:"b" c:"c")" were visible to the outside despite being wrapped in parens. This commit makes them invisible, as they should be. Note this required introduction of a new "group" AST node, whose purpose is purely to provide label scope isolation. This was necessary because "label" and "sequence" nodes don't (and can't!) provide this isolation themselves. Part of a fix of #396.
2016-03-11 16:18:29 +01:00
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.reportError("start = &{ } start");
Fix left recursion detection So far, left recursion detector assumed that left recursion occurs only when the recursive rule is at the very left-hand side of rule's expression: start = start This didn't catch cases like this: start = "a"? start In general, if a rule reference can be reached without consuming any input, it can lead to left recursion. This commit fixes the detector to consider that. Fixes #190.
2015-03-31 19:02:59 +02:00
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.reportError("start = !{ } start");
Fix left recursion detection So far, left recursion detector assumed that left recursion occurs only when the recursive rule is at the very left-hand side of rule's expression: start = start This didn't catch cases like this: start = "a"? start In general, if a rule reference can be reached without consuming any input, it can lead to left recursion. This commit fixes the detector to consider that. Fixes #190.
2015-03-31 19:02:59 +02:00
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.reportError([
Use only double quotes for strings See #443
2016-09-21 15:06:56 +02:00
"start = a start",
"a = ''"
].join("\n"));
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.not.reportError([
Use only double quotes for strings See #443
2016-09-21 15:06:56 +02:00
"start = a start",
"a = 'a'"
].join("\n"));
Fix left recursion detection So far, left recursion detector assumed that left recursion occurs only when the recursive rule is at the very left-hand side of rule's expression: start = start This didn't catch cases like this: start = "a"? start In general, if a rule reference can be reached without consuming any input, it can lead to left recursion. This commit fixes the detector to consider that. Fixes #190.
2015-03-31 19:02:59 +02:00
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.reportError("start = '' start");
expect(pass).to.not.reportError("start = 'a' start");
Fix left recursion detection So far, left recursion detector assumed that left recursion occurs only when the recursive rule is at the very left-hand side of rule's expression: start = start This didn't catch cases like this: start = "a"? start In general, if a rule reference can be reached without consuming any input, it can lead to left recursion. This commit fixes the detector to consider that. Fixes #190.
2015-03-31 19:02:59 +02:00
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.not.reportError("start = [a-d] start");
Specs cleanup: Simplify compiler passes specs After 898a7b5a2d0438aecfca9d0ec548ff60fcb00747 the specs mostly tested the visitor implementation, not actual code in the passes.
2014-06-07 09:11:00 +02:00
Switch from Jasmine to Mocha & Chai The switch is mostly mechanical, with assertions translated 1:1. The biggest non-mechanical part is rewriting Jasmine custom matchers as Chai helpers. The matchers were streamlined and simplified in the process and their messages were made more in line with messages produced by built-in Chai helpers. Fixes #409.
2016-12-08 08:59:04 +01:00
expect(pass).to.not.reportError("start = . start");
Specs cleanup: Simplify compiler passes specs After 898a7b5a2d0438aecfca9d0ec548ff60fcb00747 the specs mostly tested the visitor implementation, not actual code in the passes.
2014-06-07 09:11:00 +02:00
});
Jasmine: Convert |reportLeftRecursion| compiler pass tests
2012-04-30 13:42:13 +02:00
});
});
Reference in a new issue Copy permalink