| // Copyright 2017-2020 The Verible Authors. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include "common/analysis/matcher/matcher_builders.h" |
| |
| #include <memory> |
| |
| #include "common/analysis/matcher/bound_symbol_manager.h" |
| #include "common/analysis/matcher/matcher.h" |
| #include "common/analysis/matcher/matcher_test_utils.h" |
| #include "common/text/concrete_syntax_leaf.h" |
| #include "common/text/concrete_syntax_tree.h" |
| #include "common/text/symbol.h" |
| #include "common/text/tree_builder_test_util.h" |
| #include "gtest/gtest.h" |
| |
| namespace verible { |
| namespace matcher { |
| namespace { |
| |
| // Collection of simple matchers used in test cases |
| const TagMatchBuilder<SymbolKind::kNode, int, 5> Node5; |
| const TagMatchBuilder<SymbolKind::kNode, int, 1> Node1; |
| const TagMatchBuilder<SymbolKind::kLeaf, int, 1> Leaf1; |
| const DynamicTagMatchBuilder DNode5{SymbolTag{SymbolKind::kNode, 5}}; |
| const DynamicTagMatchBuilder DNode1{SymbolTag{SymbolKind::kNode, 1}}; |
| const DynamicTagMatchBuilder DLeaf1{SymbolTag{SymbolKind::kLeaf, 1}}; |
| const auto Path543 = MakePathMatcher({NodeTag(3), NodeTag(4), LeafTag(10)}); |
| const auto PathNode1 = MakePathMatcher({NodeTag(1)}); |
| const auto PathLeaf1 = MakePathMatcher({LeafTag(1)}); |
| |
| TEST(MatcherBuildersTest, MatcherTestCases) { |
| const MatcherTestCase test_cases[] = { |
| // Test cases with embedded nulls in structure |
| {Node5(), TNode(5, nullptr), true, {}}, |
| {Node5().Bind("foo"), TNode(5, nullptr), true, {{"foo", NodeTag(5)}}}, |
| {Node5(), TNode(6, nullptr), false, {}}, |
| {Node5(PathNode1()), TNode(5, nullptr, TNode(1, nullptr)), true, {}}, |
| {Node5(PathNode1()), TNode(5, nullptr, TNode(4, nullptr)), false, {}}, |
| {Node5(PathNode1(Node1(PathNode1(Node1())))), |
| TNode(5, nullptr, TNode(1, nullptr)), |
| false, |
| {}}, |
| {Node5(Path543().Bind("inner")).Bind("outer"), |
| TNode(5, nullptr, TNode(3, nullptr, TNode(4, nullptr, XLeaf(10)))), |
| true, |
| {{"inner", LeafTag(10)}, {"outer", NodeTag(5)}}}, |
| |
| {Node5(), TNode(5), true, {}}, |
| {Node5().Bind("foo"), TNode(5), true, {{"foo", NodeTag(5)}}}, |
| {Node5(), TNode(6), false, {}}, |
| {Node5(Path543().Bind("inner")).Bind("outer"), |
| TNode(5, TNode(3, TNode(4, XLeaf(10)))), |
| true, |
| {{"inner", LeafTag(10)}, {"outer", NodeTag(5)}}}, |
| {Node5(Path543().Bind("inner")).Bind("outer"), |
| TNode(6, TNode(3, TNode(4, XLeaf(10)))), |
| false, |
| {}}, |
| {Node5(PathNode1()), TNode(5, TNode(1)), true, {}}, |
| {Node5(PathNode1()), TNode(5, TNode(4)), false, {}}, |
| {Node5(PathNode1(Node1(PathNode1(Node1())))), |
| TNode(5, TNode(1)), |
| false, |
| {}}, |
| // Complicated nested statement |
| {Node5(PathNode1(Node1(PathNode1(Node1())))), |
| TNode(5, TNode(1, TNode(1))), |
| true, |
| {}}, |
| // A complicated nested statement with many binds |
| {Node5(PathNode1(Node1(PathLeaf1(Leaf1().Bind("leaf1")).Bind("pleaf1")) |
| .Bind("node1")) |
| .Bind("pnode1")) |
| .Bind("node5"), |
| TNode(5, TNode(1, XLeaf(1))), |
| true, |
| {{"node5", NodeTag(5)}, |
| {"leaf1", LeafTag(1)}, |
| {"pleaf1", LeafTag(1)}, |
| {"node1", NodeTag(1)}, |
| {"pnode1", NodeTag(1)}}}, |
| // TODO(jeremycs): update this when we add branching |
| // Examines simple branching behavior |
| {Node5(PathNode1().Bind("node1")), |
| TNode(5, TNode(1), TNode(1)), |
| true, |
| {{"node1", NodeTag(1)}}}, |
| // Repeated traversal to downward to leaves should fail |
| {Node5(PathLeaf1(PathLeaf1())), TNode(5, XLeaf(1), XLeaf(1)), false, {}}, |
| }; |
| |
| for (const auto& test_case : test_cases) { |
| RunMatcherTestCase(test_case); |
| } |
| } |
| |
| TEST(MatcherBuildersTest, DynamicMatcherTestCases) { |
| const MatcherTestCase test_cases[] = { |
| // Test cases with embedded nulls in structure |
| {DNode5(), TNode(5, nullptr), true, {}}, |
| {DNode5().Bind("foo"), TNode(5, nullptr), true, {{"foo", NodeTag(5)}}}, |
| {DNode5(), TNode(6, nullptr), false, {}}, |
| {DNode5(PathNode1()), TNode(5, nullptr, TNode(1, nullptr)), true, {}}, |
| {DNode5(PathNode1()), TNode(5, nullptr, TNode(4, nullptr)), false, {}}, |
| {DNode5(PathNode1(DNode1(PathNode1(DNode1())))), |
| TNode(5, nullptr, TNode(1, nullptr)), |
| false, |
| {}}, |
| {DNode5(Path543().Bind("inner")).Bind("outer"), |
| TNode(5, nullptr, TNode(3, nullptr, TNode(4, nullptr, XLeaf(10)))), |
| true, |
| {{"inner", LeafTag(10)}, {"outer", NodeTag(5)}}}, |
| |
| {DNode5(), TNode(5), true, {}}, |
| {DNode5().Bind("foo"), TNode(5), true, {{"foo", NodeTag(5)}}}, |
| {DNode5(), TNode(6), false, {}}, |
| {DNode5(Path543().Bind("inner")).Bind("outer"), |
| TNode(5, TNode(3, TNode(4, XLeaf(10)))), |
| true, |
| {{"inner", LeafTag(10)}, {"outer", NodeTag(5)}}}, |
| {DNode5(Path543().Bind("inner")).Bind("outer"), |
| TNode(6, TNode(3, TNode(4, XLeaf(10)))), |
| false, |
| {}}, |
| {DNode5(PathNode1()), TNode(5, TNode(1)), true, {}}, |
| {DNode5(PathNode1()), TNode(5, TNode(4)), false, {}}, |
| {DNode5(PathNode1(DNode1(PathNode1(DNode1())))), |
| TNode(5, TNode(1)), |
| false, |
| {}}, |
| // Complicated nested statement |
| {DNode5(PathNode1(DNode1(PathNode1(DNode1())))), |
| TNode(5, TNode(1, TNode(1))), |
| true, |
| {}}, |
| // A complicated nested statement with many binds |
| {DNode5(PathNode1(DNode1(PathLeaf1(DLeaf1().Bind("leaf1")).Bind("pleaf1")) |
| .Bind("node1")) |
| .Bind("pnode1")) |
| .Bind("node5"), |
| TNode(5, TNode(1, XLeaf(1))), |
| true, |
| {{"node5", NodeTag(5)}, |
| {"leaf1", LeafTag(1)}, |
| {"pleaf1", LeafTag(1)}, |
| {"node1", NodeTag(1)}, |
| {"pnode1", NodeTag(1)}}}, |
| // TODO(jeremycs): update this when we add branching |
| // Examines simple branching behavior |
| {DNode5(PathNode1().Bind("node1")), |
| TNode(5, TNode(1), TNode(1)), |
| true, |
| {{"node1", NodeTag(1)}}}, |
| // Repeated traversal to downward to leaves should fail |
| {DNode5(PathLeaf1(PathLeaf1())), TNode(5, XLeaf(1), XLeaf(1)), false, {}}, |
| }; |
| |
| for (const auto& test_case : test_cases) { |
| RunMatcherTestCase(test_case); |
| } |
| } |
| |
| // Basic test case for matching on a single node |
| TEST(MatcherBuildersTest, MatchTagSimple) { |
| auto matcher = Node5(); |
| BoundSymbolManager bound_symbol_manager; |
| |
| auto should_match = TNode(5); |
| EXPECT_TRUE(matcher.Matches(*should_match, &bound_symbol_manager)); |
| |
| auto no_match = TNode(6); |
| EXPECT_FALSE(matcher.Matches(*no_match, &bound_symbol_manager)); |
| } |
| |
| // Basic test case for pathed descent |
| TEST(MatcherBuildersTest, MatchPathSimple) { |
| auto matcher = Node5(Path543().Bind("inner")).Bind("outer"); |
| BoundSymbolManager bound_symbol_manager; |
| |
| auto should_match = TNode(5, TNode(3, TNode(4, XLeaf(10)))); |
| EXPECT_TRUE(matcher.Matches(*should_match, &bound_symbol_manager)); |
| EXPECT_TRUE(bound_symbol_manager.ContainsSymbol("outer")); |
| EXPECT_TRUE(bound_symbol_manager.ContainsSymbol("inner")); |
| |
| const auto* outer_match = down_cast<const SyntaxTreeNode*>( |
| bound_symbol_manager.FindSymbol("outer")); |
| const auto* inner_match = down_cast<const SyntaxTreeLeaf*>( |
| bound_symbol_manager.FindSymbol("inner")); |
| ASSERT_NE(outer_match, nullptr); |
| ASSERT_NE(inner_match, nullptr); |
| EXPECT_EQ(outer_match->Tag(), NodeTag(5)); |
| EXPECT_EQ(inner_match->Tag(), LeafTag(10)); |
| |
| bound_symbol_manager.Clear(); |
| |
| auto no_match = TNode(6); |
| EXPECT_FALSE(matcher.Matches(*no_match, &bound_symbol_manager)); |
| EXPECT_EQ(bound_symbol_manager.Size(), 0); |
| } |
| |
| } // namespace |
| } // namespace matcher |
| } // namespace verible |
