1 // Copyright 2017 The PDFium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "xfa/fxfa/parser/cxfa_nodeiteratortemplate.h"
6
7 #include <memory>
8 #include <vector>
9
10 #include "testing/gtest/include/gtest/gtest.h"
11
12 class CXFA_NodeIteratorTemplateTest : public testing::Test {
13 public:
14 class Node {
15 public:
16 class Strategy {
17 public:
GetFirstChild(Node * pNode)18 static Node* GetFirstChild(Node* pNode) {
19 return pNode && !pNode->children_.empty() ? pNode->children_.front()
20 : nullptr;
21 }
GetNextSibling(Node * pNode)22 static Node* GetNextSibling(Node* pNode) {
23 return pNode ? pNode->next_sibling_ : nullptr;
24 }
GetParent(Node * pNode)25 static Node* GetParent(Node* pNode) {
26 return pNode ? pNode->parent_ : nullptr;
27 }
28 };
29
Node(Node * parent)30 explicit Node(Node* parent) : parent_(parent) {
31 if (parent) {
32 if (!parent->children_.empty())
33 parent->children_.back()->next_sibling_ = this;
34 parent->children_.push_back(this);
35 }
36 }
37
38 private:
39 Node* const parent_;
40 Node* next_sibling_ = nullptr;
41 std::vector<Node*> children_;
42 };
43
44 using Iterator = CXFA_NodeIteratorTemplate<Node, Node::Strategy>;
45
46 // Builds a tree along the lines of:
47 //
48 // root
49 // |
50 // child1--child2
51 // |
52 // child3------------child7--child9
53 // | |
54 // child4--child6 child8
55 // |
56 // child5
57 //
SetUp()58 void SetUp() override {
59 root_ = std::make_unique<Node>(nullptr);
60 child1_ = std::make_unique<Node>(root_.get());
61 child2_ = std::make_unique<Node>(root_.get());
62 child3_ = std::make_unique<Node>(child2_.get());
63 child4_ = std::make_unique<Node>(child3_.get());
64 child5_ = std::make_unique<Node>(child4_.get());
65 child6_ = std::make_unique<Node>(child3_.get());
66 child7_ = std::make_unique<Node>(child2_.get());
67 child8_ = std::make_unique<Node>(child7_.get());
68 child9_ = std::make_unique<Node>(child2_.get());
69 }
70
root() const71 Node* root() const { return root_.get(); }
child1() const72 Node* child1() const { return child1_.get(); }
child2() const73 Node* child2() const { return child2_.get(); }
child3() const74 Node* child3() const { return child3_.get(); }
child4() const75 Node* child4() const { return child4_.get(); }
child5() const76 Node* child5() const { return child5_.get(); }
child6() const77 Node* child6() const { return child6_.get(); }
child7() const78 Node* child7() const { return child7_.get(); }
child8() const79 Node* child8() const { return child8_.get(); }
child9() const80 Node* child9() const { return child9_.get(); }
81
82 protected:
83 std::unique_ptr<Node> root_;
84 std::unique_ptr<Node> child1_;
85 std::unique_ptr<Node> child2_;
86 std::unique_ptr<Node> child3_;
87 std::unique_ptr<Node> child4_;
88 std::unique_ptr<Node> child5_;
89 std::unique_ptr<Node> child6_;
90 std::unique_ptr<Node> child7_;
91 std::unique_ptr<Node> child8_;
92 std::unique_ptr<Node> child9_;
93 };
94
TEST_F(CXFA_NodeIteratorTemplateTest,Empty)95 TEST_F(CXFA_NodeIteratorTemplateTest, Empty) {
96 Iterator iter(nullptr);
97 EXPECT_FALSE(iter.GetRoot());
98 EXPECT_FALSE(iter.GetCurrent());
99 EXPECT_FALSE(iter.MoveToNext());
100 EXPECT_FALSE(iter.MoveToPrev());
101 EXPECT_FALSE(iter.SkipChildrenAndMoveToNext());
102 }
103
TEST_F(CXFA_NodeIteratorTemplateTest,Root)104 TEST_F(CXFA_NodeIteratorTemplateTest, Root) {
105 Iterator iter(root());
106 EXPECT_EQ(root(), iter.GetRoot());
107 EXPECT_EQ(root(), iter.GetCurrent());
108 }
109
TEST_F(CXFA_NodeIteratorTemplateTest,Current)110 TEST_F(CXFA_NodeIteratorTemplateTest, Current) {
111 Iterator iter(root());
112 iter.SetCurrent(child1());
113 EXPECT_EQ(root(), iter.GetRoot());
114 EXPECT_EQ(child1(), iter.GetCurrent());
115 }
116
TEST_F(CXFA_NodeIteratorTemplateTest,CurrentOutsideRootDisallowed)117 TEST_F(CXFA_NodeIteratorTemplateTest, CurrentOutsideRootDisallowed) {
118 Iterator iter(child1());
119 iter.SetCurrent(root());
120 EXPECT_EQ(child1(), iter.GetRoot());
121 EXPECT_FALSE(iter.GetCurrent());
122 }
123
TEST_F(CXFA_NodeIteratorTemplateTest,CurrentNull)124 TEST_F(CXFA_NodeIteratorTemplateTest, CurrentNull) {
125 Iterator iter(root());
126 EXPECT_EQ(child1(), iter.MoveToNext());
127
128 iter.SetCurrent(nullptr);
129 EXPECT_FALSE(iter.GetCurrent());
130
131 EXPECT_FALSE(iter.MoveToNext());
132 EXPECT_FALSE(iter.GetCurrent());
133 }
134
TEST_F(CXFA_NodeIteratorTemplateTest,MoveToPrev)135 TEST_F(CXFA_NodeIteratorTemplateTest, MoveToPrev) {
136 Iterator iter(root());
137 iter.SetCurrent(child9());
138
139 EXPECT_EQ(child8(), iter.MoveToPrev());
140 EXPECT_EQ(child8(), iter.GetCurrent());
141
142 EXPECT_EQ(child7(), iter.MoveToPrev());
143 EXPECT_EQ(child7(), iter.GetCurrent());
144
145 EXPECT_EQ(child6(), iter.MoveToPrev());
146 EXPECT_EQ(child6(), iter.GetCurrent());
147
148 EXPECT_EQ(child5(), iter.MoveToPrev());
149 EXPECT_EQ(child5(), iter.GetCurrent());
150
151 EXPECT_EQ(child4(), iter.MoveToPrev());
152 EXPECT_EQ(child4(), iter.GetCurrent());
153
154 EXPECT_EQ(child3(), iter.MoveToPrev());
155 EXPECT_EQ(child3(), iter.GetCurrent());
156
157 EXPECT_EQ(child2(), iter.MoveToPrev());
158 EXPECT_EQ(child2(), iter.GetCurrent());
159
160 EXPECT_EQ(child1(), iter.MoveToPrev());
161 EXPECT_EQ(child1(), iter.GetCurrent());
162
163 EXPECT_EQ(root(), iter.MoveToPrev());
164 EXPECT_EQ(root(), iter.GetCurrent());
165
166 EXPECT_FALSE(iter.MoveToPrev());
167 EXPECT_EQ(root(), iter.GetCurrent());
168
169 EXPECT_FALSE(iter.MoveToPrev());
170 EXPECT_EQ(root(), iter.GetCurrent());
171 }
172
TEST_F(CXFA_NodeIteratorTemplateTest,MoveToNext)173 TEST_F(CXFA_NodeIteratorTemplateTest, MoveToNext) {
174 Iterator iter(root());
175 iter.SetCurrent(child2());
176
177 EXPECT_EQ(child3(), iter.MoveToNext());
178 EXPECT_EQ(child3(), iter.GetCurrent());
179
180 EXPECT_EQ(child4(), iter.MoveToNext());
181 EXPECT_EQ(child4(), iter.GetCurrent());
182
183 EXPECT_EQ(child5(), iter.MoveToNext());
184 EXPECT_EQ(child5(), iter.GetCurrent());
185
186 EXPECT_EQ(child6(), iter.MoveToNext());
187 EXPECT_EQ(child6(), iter.GetCurrent());
188
189 EXPECT_EQ(child7(), iter.MoveToNext());
190 EXPECT_EQ(child7(), iter.GetCurrent());
191
192 EXPECT_EQ(child8(), iter.MoveToNext());
193 EXPECT_EQ(child8(), iter.GetCurrent());
194
195 EXPECT_EQ(child9(), iter.MoveToNext());
196 EXPECT_EQ(child9(), iter.GetCurrent());
197
198 EXPECT_FALSE(iter.MoveToNext());
199 EXPECT_FALSE(iter.GetCurrent());
200
201 EXPECT_FALSE(iter.MoveToNext());
202 EXPECT_FALSE(iter.GetCurrent());
203 }
204
TEST_F(CXFA_NodeIteratorTemplateTest,SkipChildrenAndMoveToNext)205 TEST_F(CXFA_NodeIteratorTemplateTest, SkipChildrenAndMoveToNext) {
206 Iterator iter(root());
207 iter.SetCurrent(child3());
208 EXPECT_EQ(child7(), iter.SkipChildrenAndMoveToNext());
209 EXPECT_EQ(child9(), iter.SkipChildrenAndMoveToNext());
210 EXPECT_FALSE(iter.SkipChildrenAndMoveToNext());
211 }
212
TEST_F(CXFA_NodeIteratorTemplateTest,BackAndForth)213 TEST_F(CXFA_NodeIteratorTemplateTest, BackAndForth) {
214 Iterator iter(root());
215 EXPECT_EQ(child1(), iter.MoveToNext());
216 EXPECT_EQ(child2(), iter.MoveToNext());
217 EXPECT_EQ(child3(), iter.MoveToNext());
218 EXPECT_EQ(child4(), iter.MoveToNext());
219 EXPECT_EQ(child5(), iter.MoveToNext());
220 EXPECT_EQ(child4(), iter.MoveToPrev());
221 EXPECT_EQ(child3(), iter.MoveToPrev());
222 EXPECT_EQ(child2(), iter.MoveToPrev());
223 EXPECT_EQ(child1(), iter.MoveToPrev());
224 }
225
TEST_F(CXFA_NodeIteratorTemplateTest,NextFromBeforeTheBeginning)226 TEST_F(CXFA_NodeIteratorTemplateTest, NextFromBeforeTheBeginning) {
227 Iterator iter(root());
228 EXPECT_FALSE(iter.MoveToPrev());
229 EXPECT_EQ(root(), iter.GetCurrent());
230 EXPECT_EQ(child1(), iter.MoveToNext());
231 }
232
TEST_F(CXFA_NodeIteratorTemplateTest,PrevFromAfterTheEnd)233 TEST_F(CXFA_NodeIteratorTemplateTest, PrevFromAfterTheEnd) {
234 Iterator iter(root());
235 iter.SetCurrent(child9());
236 EXPECT_FALSE(iter.MoveToNext());
237 EXPECT_EQ(child9(), iter.MoveToPrev());
238 }
239
TEST_F(CXFA_NodeIteratorTemplateTest,ChildAsRootPrev)240 TEST_F(CXFA_NodeIteratorTemplateTest, ChildAsRootPrev) {
241 Iterator iter(child3());
242 EXPECT_FALSE(iter.MoveToPrev());
243
244 iter.SetCurrent(child4());
245 EXPECT_EQ(child3(), iter.MoveToPrev());
246 EXPECT_FALSE(iter.MoveToPrev());
247 }
248
TEST_F(CXFA_NodeIteratorTemplateTest,ChildAsRootNext)249 TEST_F(CXFA_NodeIteratorTemplateTest, ChildAsRootNext) {
250 Iterator iter(child3());
251 iter.SetCurrent(child4());
252 EXPECT_EQ(child5(), iter.MoveToNext());
253 EXPECT_EQ(child6(), iter.MoveToNext());
254 EXPECT_FALSE(iter.MoveToNext());
255 }
256