traxys/tree-sitter
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Reduce nesting in parse-stack spec

Browse source
This commit is contained in:
Max Brunsfeld 2015-07-10 17:50:38 -07:00
parent 6846b1316e
commit 8c5c695f5a
1 changed files with 147 additions and 125 deletions
Download patch file Download diff file Expand all files Collapse all files

272
spec/runtime/parse_stack_spec.cc
View file

@ -32,7 +32,7 @@ describe("ParseStack", [&]() {
ts_tree_release(trees[i]);
});
describe("push(head_index, state, tree)", [&]() {
describe("pushing entries to the stack", [&]() {
it("adds entries to the stack", [&]() {
AssertThat(ts_parse_stack_head_count(stack), Equals(1));
AssertThat(ts_parse_stack_head(stack, 0), Equals<const ParseStackEntry *>(nullptr));
@ -66,7 +66,7 @@ describe("ParseStack", [&]() {
});
});
describe("pop(head_index, count, should_count_extra)", [&]() {
describe("popping nodes from the stack", [&]() {
ParseStackPopResultList pop;
before_each([&]() {
@ -122,7 +122,7 @@ describe("ParseStack", [&]() {
});
});
describe("split(head_index)", [&]() {
describe("splitting the stack", [&]() {
it("creates a new independent head with the same entries", [&]() {
/*
* A0__B1__C2.
@ -157,142 +157,164 @@ describe("ParseStack", [&]() {
AssertThat(*ts_parse_stack_head(stack, 0), Equals<ParseStackEntry>({trees[3], stateD}));
AssertThat(*ts_parse_stack_head(stack, 1), Equals<ParseStackEntry>({trees[3], stateF}));
});
});
describe("when same state is pushed onto two heads", [&]() {
bool merged;
describe("pushing the same state onto two different heads of the stack", [&]() {
before_each([&]() {
/*
* A0__B1__C2__D3.
* \__E4__F5.
*/
ts_parse_stack_push(stack, 0, stateA, trees[0]);
ts_parse_stack_push(stack, 0, stateB, trees[1]);
ts_parse_stack_split(stack, 0);
ts_parse_stack_push(stack, 0, stateC, trees[2]);
ts_parse_stack_push(stack, 0, stateD, trees[3]);
ts_parse_stack_push(stack, 1, stateE, trees[4]);
ts_parse_stack_push(stack, 1, stateF, trees[5]);
before_each([&]() {
AssertThat(ts_parse_stack_head_count(stack), Equals(2));
AssertThat(*ts_parse_stack_head(stack, 0), Equals<ParseStackEntry>({trees[3], stateD}));
AssertThat(*ts_parse_stack_head(stack, 1), Equals<ParseStackEntry>({trees[5], stateF}));
});
describe("when the trees are identical", [&]() {
it("merges the heads", [&]() {
/*
* A0__B1__C2__D3__G6.
* \__E4__F5__/
*/
bool merged = ts_parse_stack_push(stack, 0, stateG, trees[6]);
AssertThat(merged, IsFalse());
merged = ts_parse_stack_push(stack, 1, stateG, trees[6]);
AssertThat(merged, IsTrue());
AssertThat(ts_parse_stack_head_count(stack), Equals(1));
const ParseStackEntry *entry1 = ts_parse_stack_head(stack, 0);
AssertThat(*entry1, Equals<ParseStackEntry>({trees[6], stateG}));
AssertThat(ts_parse_stack_entry_next_count(entry1), Equals(2));
AssertThat(*ts_parse_stack_entry_next(entry1, 0), Equals<ParseStackEntry>({trees[3], stateD}));
AssertThat(*ts_parse_stack_entry_next(entry1, 1), Equals<ParseStackEntry>({trees[5], stateF}));
});
});
describe("when the trees are different", [&]() {
it("merges the heads by creating an ambiguity node", [&]() {
/*
* A0__B1__C2__D3__G(6|7)
* \__E4__F5____/
*/
bool merged = ts_parse_stack_push(stack, 0, stateG, trees[6]);
AssertThat(merged, IsFalse());
merged = ts_parse_stack_push(stack, 1, stateG, trees[7]);
AssertThat(merged, IsTrue());
AssertThat(ts_parse_stack_head_count(stack), Equals(1));
AssertThat(*ts_parse_stack_head(stack, 0), Equals<ParseStackEntry>({
ts_tree_make_ambiguity(trees[6], trees[7]),
stateG
}));
});
});
});
describe("popping from a stack head that has been merged", [&]() {
before_each([&]() {
/*
* A0__B1__C2__D3__G6.
* \__E4__F5__/
*/
ts_parse_stack_push(stack, 0, stateA, trees[0]);
ts_parse_stack_push(stack, 0, stateB, trees[1]);
ts_parse_stack_split(stack, 0);
ts_parse_stack_push(stack, 0, stateC, trees[2]);
ts_parse_stack_push(stack, 0, stateD, trees[3]);
ts_parse_stack_push(stack, 0, stateG, trees[6]);
ts_parse_stack_push(stack, 1, stateE, trees[4]);
ts_parse_stack_push(stack, 1, stateF, trees[5]);
ts_parse_stack_push(stack, 1, stateG, trees[6]);
});
describe("when there are two paths that lead to two different heads", [&]() {
it("returns an entry for each revealed head", [&]() {
/*
* A0__B1__C2.
* \__E4.
*/
ts_parse_stack_push(stack, 0, stateA, trees[0]);
ts_parse_stack_push(stack, 0, stateB, trees[1]);
ts_parse_stack_push(stack, 0, stateC, trees[2]);
ParseStackPopResultList pop = ts_parse_stack_pop(stack, 0, 2, false);
AssertThat(pop.size, Equals(2));
ParseStackPopResult pop1 = pop.contents[0];
AssertThat(pop1.index, Equals(0));
AssertThat(pop1.tree_count, Equals(2));
AssertThat(pop1.trees[0], Equals(trees[3]));
AssertThat(pop1.trees[1], Equals(trees[6]));
ParseStackPopResult pop2 = pop.contents[1];
AssertThat(pop2.index, Equals(1));
AssertThat(pop2.tree_count, Equals(2));
AssertThat(pop2.trees[0], Equals(trees[5]));
AssertThat(pop2.trees[1], Equals(trees[6]));
AssertThat(ts_parse_stack_head_count(stack), Equals(2));
AssertThat(*ts_parse_stack_head(stack, 0), Equals<ParseStackEntry>({trees[2], stateC}));
AssertThat(*ts_parse_stack_head(stack, 1), Equals<ParseStackEntry>({trees[4], stateE}));
});
});
describe("when there is one path, leading to one head", [&]() {
it("returns a single entry", [&]() {
/*
* A0__B1__C2__D3__G6__H7.
* \__E4__F5__/
*/
bool merged = ts_parse_stack_push(stack, 0, stateH, trees[7]);
AssertThat(merged, IsFalse());
AssertThat(ts_parse_stack_head_count(stack), Equals(1));
/*
* A0__B1__C2__D3__G6.
* \__E4__F5__/
*/
ParseStackPopResultList pop = ts_parse_stack_pop(stack, 0, 1, false);
AssertThat(pop.size, Equals(1));
AssertThat(ts_parse_stack_head_count(stack), Equals(1));
});
});
describe("when there is one path that leads to two different heads", [&]() {
it("returns two entries with the same array of trees", [&]() {
/*
* A0__B1__C2__D3.
* \__E4__F5.
*/
ts_parse_stack_split(stack, 0);
ts_parse_stack_push(stack, 0, stateD, trees[3]);
ts_parse_stack_pop(stack, 1, 1, false);
ts_parse_stack_push(stack, 1, stateE, trees[4]);
ts_parse_stack_push(stack, 1, stateF, trees[5]);
ParseStackPopResultList pop = ts_parse_stack_pop(stack, 0, 1, false);
AssertThat(ts_parse_stack_head_count(stack), Equals(2));
AssertThat(*ts_parse_stack_head(stack, 0), Equals<ParseStackEntry>({trees[3], stateD}));
AssertThat(*ts_parse_stack_head(stack, 1), Equals<ParseStackEntry>({trees[5], stateF}));
AssertThat(pop.size, Equals(2));
AssertThat(pop.contents[0].index, Equals(0));
AssertThat(pop.contents[1].index, Equals(1));
AssertThat(pop.contents[0].trees, Equals(pop.contents[1].trees));
});
});
describe("when the trees are identical", [&]() {
before_each([&]() {
/*
* A0__B1__C2__D3__G6.
* \__E4__F5__/
*/
merged = ts_parse_stack_push(stack, 0, stateG, trees[6]);
AssertThat(merged, IsFalse());
merged = ts_parse_stack_push(stack, 1, stateG, trees[6]);
AssertThat(merged, IsTrue());
});
describe("when there are two paths that converge at the same head", [&]() {
it("returns two entries for that head", [&]() {
/*
* A0__B1.
*/
ParseStackPopResultList pop = ts_parse_stack_pop(stack, 0, 3, false);
AssertThat(ts_parse_stack_head_count(stack), Equals(1));
AssertThat(*ts_parse_stack_head(stack, 0), Equals<ParseStackEntry>({trees[1], stateB}));
it("merges the heads", [&]() {
AssertThat(ts_parse_stack_head_count(stack), Equals(1));
const ParseStackEntry *entry1 = ts_parse_stack_head(stack, 0);
AssertThat(*entry1, Equals<ParseStackEntry>({trees[6], stateG}));
AssertThat(ts_parse_stack_entry_next_count(entry1), Equals(2));
AssertThat(*ts_parse_stack_entry_next(entry1, 0), Equals<ParseStackEntry>({trees[3], stateD}));
AssertThat(*ts_parse_stack_entry_next(entry1, 1), Equals<ParseStackEntry>({trees[5], stateF}));
});
it("removes nodes along both heads on subsequent pop operations", [&]() {
/*
* A0__B1__C2.
* \__E4.
*/
ParseStackPopResultList pop = ts_parse_stack_pop(stack, 0, 2, false);
AssertThat(pop.size, Equals(2));
AssertThat(pop.contents[0].tree_count, Equals(2));
AssertThat(pop.contents[0].trees[0], Equals(trees[3]));
AssertThat(pop.contents[0].trees[1], Equals(trees[6]));
AssertThat(pop.contents[1].tree_count, Equals(2));
AssertThat(pop.contents[1].trees[0], Equals(trees[5]));
AssertThat(pop.contents[1].trees[1], Equals(trees[6]));
AssertThat(ts_parse_stack_head_count(stack), Equals(2));
AssertThat(*ts_parse_stack_head(stack, 0), Equals<ParseStackEntry>({trees[2], stateC}));
AssertThat(*ts_parse_stack_head(stack, 1), Equals<ParseStackEntry>({trees[4], stateE}));
});
it("pops only one path if the split is hidden under sufficiently many nodes", [&]() {
/*
* A0__B1__C2__D3__G6__H7.
* \__E4__F5__/
*/
merged = ts_parse_stack_push(stack, 0, stateH, trees[7]);
AssertThat(merged, IsFalse());
AssertThat(ts_parse_stack_head_count(stack), Equals(1));
/*
* A0__B1__C2__D3__G6.
* \__E4__F5__/
*/
ParseStackPopResultList pop = ts_parse_stack_pop(stack, 0, 1, false);
AssertThat(pop.size, Equals(1));
AssertThat(ts_parse_stack_head_count(stack), Equals(1));
});
it("can pop one branch that reveals two head", [&]() {
/*
* A0__B1__C2__D3.
* \__E4__F5.
*/
ParseStackPopResultList pop = ts_parse_stack_pop(stack, 0, 1, false);
AssertThat(ts_parse_stack_head_count(stack), Equals(2));
AssertThat(pop.size, Equals(2));
AssertThat(pop.contents[0].index, Equals(0));
AssertThat(pop.contents[1].index, Equals(1));
AssertThat(pop.contents[0].trees, Equals(pop.contents[1].trees));
});
it("can pop two branches that converge at the same head", [&]() {
/*
* A0__B1.
*/
ParseStackPopResultList pop = ts_parse_stack_pop(stack, 0, 3, false);
AssertThat(ts_parse_stack_head_count(stack), Equals(1));
AssertThat(*ts_parse_stack_head(stack, 0), Equals<ParseStackEntry>({trees[1], stateB}));
AssertThat(pop.size, Equals(2));
AssertThat(pop.contents[0].tree_count, Equals(3));
AssertThat(pop.contents[0].index, Equals(0));
AssertThat(pop.contents[0].trees[0], Equals(trees[2]));
AssertThat(pop.contents[1].tree_count, Equals(3));
AssertThat(pop.contents[1].index, Equals(0));
AssertThat(pop.contents[1].trees[0], Equals(trees[4]));
});
});
describe("when the trees are different", [&]() {
it("merges the heads by creating an ambiguity node", [&]() {
/*
* A0__B1__C2__D3__G(6|7)
* \__E4__F5____/
*/
merged = ts_parse_stack_push(stack, 0, stateG, trees[6]);
AssertThat(merged, IsFalse());
merged = ts_parse_stack_push(stack, 1, stateG, trees[7]);
AssertThat(merged, IsTrue());
AssertThat(ts_parse_stack_head_count(stack), Equals(1));
AssertThat(*ts_parse_stack_head(stack, 0), Equals<ParseStackEntry>({
ts_tree_make_ambiguity(trees[6], trees[7]),
stateG
}));
});
AssertThat(pop.size, Equals(2));
AssertThat(pop.contents[0].tree_count, Equals(3));
AssertThat(pop.contents[0].index, Equals(0));
AssertThat(pop.contents[0].trees[0], Equals(trees[2]));
AssertThat(pop.contents[1].tree_count, Equals(3));
AssertThat(pop.contents[1].index, Equals(0));
AssertThat(pop.contents[1].trees[0], Equals(trees[4]));
});
});
});