1 /*
2 * Copyright (C) 2010 Google Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
15 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
16 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
18 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
19 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
20 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
21 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26 // Tests for the interval tree class.
27
28 #include "third_party/blink/renderer/platform/wtf/pod_interval_tree.h"
29
30 #include "testing/gtest/include/gtest/gtest.h"
31 #include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"
32 #include "third_party/blink/renderer/platform/wtf/pod_tree_test_helpers.h"
33 #include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"
34 #include "third_party/blink/renderer/platform/wtf/vector.h"
35
36 namespace WTF {
37
38 using tree_test_helpers::InitRandom;
39 using tree_test_helpers::NextRandom;
40
41 #ifndef NDEBUG
42 template <>
43 struct ValueToString<void*> {
ToStringWTF::ValueToString44 static String ToString(void* const& value) {
45 return String::Format("0x%p", value);
46 }
47 };
48 #endif
49
TEST(PODIntervalTreeTest,TestInsertion)50 TEST(PODIntervalTreeTest, TestInsertion) {
51 PODIntervalTree<float> tree;
52 tree.Add(PODInterval<float>(2, 4));
53 ASSERT_TRUE(tree.CheckInvariants());
54 }
55
TEST(PODIntervalTreeTest,TestInsertionAndQuery)56 TEST(PODIntervalTreeTest, TestInsertionAndQuery) {
57 PODIntervalTree<float> tree;
58 tree.Add(PODInterval<float>(2, 4));
59 ASSERT_TRUE(tree.CheckInvariants());
60 Vector<PODInterval<float>> overlap =
61 tree.AllOverlaps(PODInterval<float>(1, 3));
62 EXPECT_EQ(1U, overlap.size());
63 EXPECT_EQ(2, overlap[0].Low());
64 EXPECT_EQ(4, overlap[0].High());
65
66 auto next_point = tree.NextIntervalPoint(1);
67 EXPECT_TRUE(next_point.has_value());
68 EXPECT_EQ(2, next_point.value());
69
70 next_point = tree.NextIntervalPoint(2);
71 EXPECT_TRUE(next_point.has_value());
72 EXPECT_EQ(4, next_point.value());
73
74 next_point = tree.NextIntervalPoint(3);
75 EXPECT_TRUE(next_point.has_value());
76 EXPECT_EQ(4, next_point.value());
77
78 next_point = tree.NextIntervalPoint(4);
79 EXPECT_FALSE(next_point.has_value());
80 }
81
TEST(PODIntervalTreeTest,TestQueryAgainstZeroSizeInterval)82 TEST(PODIntervalTreeTest, TestQueryAgainstZeroSizeInterval) {
83 PODIntervalTree<float> tree;
84 tree.Add(PODInterval<float>(1, 2.5));
85 tree.Add(PODInterval<float>(3.5, 5));
86 tree.Add(PODInterval<float>(2, 4));
87 ASSERT_TRUE(tree.CheckInvariants());
88 Vector<PODInterval<float>> result =
89 tree.AllOverlaps(PODInterval<float>(3, 3));
90 EXPECT_EQ(1U, result.size());
91 EXPECT_EQ(2, result[0].Low());
92 EXPECT_EQ(4, result[0].High());
93 }
94
95 #ifndef NDEBUG
96 template <>
97 struct ValueToString<int*> {
ToStringWTF::ValueToString98 static String ToString(int* const& value) {
99 return String::Format("0x%p", value);
100 }
101 };
102 #endif
103
TEST(PODIntervalTreeTest,TestDuplicateElementInsertion)104 TEST(PODIntervalTreeTest, TestDuplicateElementInsertion) {
105 PODIntervalTree<float, int*> tree;
106 int tmp1 = 1;
107 int tmp2 = 2;
108 typedef PODIntervalTree<float, int*>::IntervalType IntervalType;
109 IntervalType interval1(1, 3, &tmp1);
110 IntervalType interval2(1, 3, &tmp2);
111 tree.Add(interval1);
112 tree.Add(interval2);
113 ASSERT_TRUE(tree.CheckInvariants());
114 EXPECT_TRUE(tree.Contains(interval1));
115 EXPECT_TRUE(tree.Contains(interval2));
116 EXPECT_TRUE(tree.Remove(interval1));
117 EXPECT_TRUE(tree.Contains(interval2));
118 EXPECT_FALSE(tree.Contains(interval1));
119 EXPECT_TRUE(tree.Remove(interval2));
120 EXPECT_EQ(0, tree.size());
121 }
122
123 namespace {
124
125 struct UserData1 {
126 public:
UserData1WTF::__anonf32ced1b0111::UserData1127 UserData1() : a(0), b(1) {}
128
129 float a;
130 int b;
131 };
132
133 } // anonymous namespace
134
135 #ifndef NDEBUG
136 template <>
137 struct ValueToString<UserData1> {
ToStringWTF::ValueToString138 static String ToString(const UserData1& value) {
139 return String("[UserData1 a=") + String::Number(value.a) +
140 " b=" + String::Number(value.b) + "]";
141 }
142 };
143 #endif
144
TEST(PODIntervalTreeTest,TestInsertionOfComplexUserData)145 TEST(PODIntervalTreeTest, TestInsertionOfComplexUserData) {
146 PODIntervalTree<float, UserData1> tree;
147 UserData1 data1;
148 data1.a = 5;
149 data1.b = 6;
150 tree.Add(tree.CreateInterval(2, 4, data1));
151 ASSERT_TRUE(tree.CheckInvariants());
152 }
153
TEST(PODIntervalTreeTest,TestQueryingOfComplexUserData)154 TEST(PODIntervalTreeTest, TestQueryingOfComplexUserData) {
155 PODIntervalTree<float, UserData1> tree;
156 UserData1 data1;
157 data1.a = 5;
158 data1.b = 6;
159 tree.Add(tree.CreateInterval(2, 4, data1));
160 ASSERT_TRUE(tree.CheckInvariants());
161 Vector<PODInterval<float, UserData1>> overlaps =
162 tree.AllOverlaps(tree.CreateInterval(3, 5, data1));
163 EXPECT_EQ(1U, overlaps.size());
164 EXPECT_EQ(5, overlaps[0].Data().a);
165 EXPECT_EQ(6, overlaps[0].Data().b);
166 }
167
168 namespace {
169
170 class EndpointType1 {
171 STACK_ALLOCATED();
172
173 public:
EndpointType1(int value)174 explicit EndpointType1(int value) : value_(value) {}
175
Value() const176 int Value() const { return value_; }
177
operator <(const EndpointType1 & other) const178 bool operator<(const EndpointType1& other) const {
179 return value_ < other.value_;
180 }
operator ==(const EndpointType1 & other) const181 bool operator==(const EndpointType1& other) const {
182 return value_ == other.value_;
183 }
184
185 private:
186 int value_;
187 // These operators should not be called by the interval tree.
188 bool operator>(const EndpointType1& other);
189 bool operator<=(const EndpointType1& other);
190 bool operator>=(const EndpointType1& other);
191 bool operator!=(const EndpointType1& other);
192 };
193
194 } // anonymous namespace
195
196 #ifndef NDEBUG
197 template <>
198 struct ValueToString<EndpointType1> {
ToStringWTF::ValueToString199 static String ToString(const EndpointType1& value) {
200 return String("[EndpointType1 value=") + String::Number(value.Value()) +
201 "]";
202 }
203 };
204 #endif
205
TEST(PODIntervalTreeTest,TestTreeDoesNotRequireMostOperators)206 TEST(PODIntervalTreeTest, TestTreeDoesNotRequireMostOperators) {
207 PODIntervalTree<EndpointType1> tree;
208 tree.Add(tree.CreateInterval(EndpointType1(1), EndpointType1(2)));
209 ASSERT_TRUE(tree.CheckInvariants());
210 }
211
212 // Uncomment to debug a failure of the insertion and deletion test. Won't work
213 // in release builds.
214 // #define DEBUG_INSERTION_AND_DELETION_TEST
215
216 namespace {
217
TreeInsertionAndDeletionTest(int32_t seed,int tree_size)218 void TreeInsertionAndDeletionTest(int32_t seed, int tree_size) {
219 InitRandom(seed);
220 int maximum_value = tree_size;
221 // Build the tree
222 PODIntervalTree<int> tree;
223 Vector<PODInterval<int>> added_elements;
224 Vector<PODInterval<int>> removed_elements;
225 for (int i = 0; i < tree_size; i++) {
226 int left = NextRandom(maximum_value);
227 int length = NextRandom(maximum_value);
228 PODInterval<int> interval(left, left + length);
229 tree.Add(interval);
230 #ifdef DEBUG_INSERTION_AND_DELETION_TEST
231 DLOG(ERROR) << "*** Adding element "
232 << ValueToString<PODInterval<int>>::ToString(interval);
233 #endif
234 added_elements.push_back(interval);
235 }
236 // Churn the tree's contents.
237 // First remove half of the elements in random order.
238 for (int i = 0; i < tree_size / 2; i++) {
239 int index = NextRandom(added_elements.size());
240 #ifdef DEBUG_INSERTION_AND_DELETION_TEST
241 DLOG(ERROR) << "*** Removing element "
242 << ValueToString<PODInterval<int>>::ToString(
243 added_elements[index]);
244 #endif
245 ASSERT_TRUE(tree.Contains(added_elements[index]))
246 << "Test failed for seed " << seed;
247 tree.Remove(added_elements[index]);
248 removed_elements.push_back(added_elements[index]);
249 added_elements.EraseAt(index);
250 ASSERT_TRUE(tree.CheckInvariants()) << "Test failed for seed " << seed;
251 }
252 // Now randomly add or remove elements.
253 for (int i = 0; i < 2 * tree_size; i++) {
254 bool add = false;
255 if (!added_elements.size())
256 add = true;
257 else if (!removed_elements.size())
258 add = false;
259 else
260 add = (NextRandom(2) == 1);
261 if (add) {
262 int index = NextRandom(removed_elements.size());
263 #ifdef DEBUG_INSERTION_AND_DELETION_TEST
264 DLOG(ERROR) << "*** Adding element "
265 << ValueToString<PODInterval<int>>::ToString(
266 removed_elements[index]);
267 #endif
268 tree.Add(removed_elements[index]);
269 added_elements.push_back(removed_elements[index]);
270 removed_elements.EraseAt(index);
271 } else {
272 int index = NextRandom(added_elements.size());
273 #ifdef DEBUG_INSERTION_AND_DELETION_TEST
274 DLOG(ERROR) << "*** Removing element "
275 << ValueToString<PODInterval<int>>::ToString(
276 added_elements[index]);
277 #endif
278 ASSERT_TRUE(tree.Contains(added_elements[index]))
279 << "Test failed for seed " << seed;
280 ASSERT_TRUE(tree.Remove(added_elements[index]))
281 << "Test failed for seed " << seed;
282 removed_elements.push_back(added_elements[index]);
283 added_elements.EraseAt(index);
284 }
285 ASSERT_TRUE(tree.CheckInvariants()) << "Test failed for seed " << seed;
286 }
287 }
288
289 } // anonymous namespace
290
TEST(PODIntervalTreeTest,RandomDeletionAndInsertionRegressionTest1)291 TEST(PODIntervalTreeTest, RandomDeletionAndInsertionRegressionTest1) {
292 TreeInsertionAndDeletionTest(13972, 100);
293 }
294
TEST(PODIntervalTreeTest,RandomDeletionAndInsertionRegressionTest2)295 TEST(PODIntervalTreeTest, RandomDeletionAndInsertionRegressionTest2) {
296 TreeInsertionAndDeletionTest(1283382113, 10);
297 }
298
TEST(PODIntervalTreeTest,RandomDeletionAndInsertionRegressionTest3)299 TEST(PODIntervalTreeTest, RandomDeletionAndInsertionRegressionTest3) {
300 // This is the sequence of insertions and deletions that triggered
301 // the failure in RandomDeletionAndInsertionRegressionTest2.
302 PODIntervalTree<int> tree;
303 tree.Add(tree.CreateInterval(0, 5));
304 ASSERT_TRUE(tree.CheckInvariants());
305 tree.Add(tree.CreateInterval(4, 5));
306 ASSERT_TRUE(tree.CheckInvariants());
307 tree.Add(tree.CreateInterval(8, 9));
308 ASSERT_TRUE(tree.CheckInvariants());
309 tree.Add(tree.CreateInterval(1, 4));
310 ASSERT_TRUE(tree.CheckInvariants());
311 tree.Add(tree.CreateInterval(3, 5));
312 ASSERT_TRUE(tree.CheckInvariants());
313 tree.Add(tree.CreateInterval(4, 12));
314 ASSERT_TRUE(tree.CheckInvariants());
315 tree.Add(tree.CreateInterval(0, 2));
316 ASSERT_TRUE(tree.CheckInvariants());
317 tree.Add(tree.CreateInterval(0, 2));
318 ASSERT_TRUE(tree.CheckInvariants());
319 tree.Add(tree.CreateInterval(9, 13));
320 ASSERT_TRUE(tree.CheckInvariants());
321 tree.Add(tree.CreateInterval(0, 1));
322 ASSERT_TRUE(tree.CheckInvariants());
323 tree.Remove(tree.CreateInterval(0, 2));
324 ASSERT_TRUE(tree.CheckInvariants());
325 tree.Remove(tree.CreateInterval(9, 13));
326 ASSERT_TRUE(tree.CheckInvariants());
327 tree.Remove(tree.CreateInterval(0, 2));
328 ASSERT_TRUE(tree.CheckInvariants());
329 tree.Remove(tree.CreateInterval(0, 1));
330 ASSERT_TRUE(tree.CheckInvariants());
331 tree.Remove(tree.CreateInterval(4, 5));
332 ASSERT_TRUE(tree.CheckInvariants());
333 tree.Remove(tree.CreateInterval(4, 12));
334 ASSERT_TRUE(tree.CheckInvariants());
335 }
336
TEST(PODIntervalTreeTest,RandomDeletionAndInsertionRegressionTest4)337 TEST(PODIntervalTreeTest, RandomDeletionAndInsertionRegressionTest4) {
338 // Even further reduced test case for
339 // RandomDeletionAndInsertionRegressionTest3.
340 PODIntervalTree<int> tree;
341 tree.Add(tree.CreateInterval(0, 5));
342 ASSERT_TRUE(tree.CheckInvariants());
343 tree.Add(tree.CreateInterval(8, 9));
344 ASSERT_TRUE(tree.CheckInvariants());
345 tree.Add(tree.CreateInterval(1, 4));
346 ASSERT_TRUE(tree.CheckInvariants());
347 tree.Add(tree.CreateInterval(3, 5));
348 ASSERT_TRUE(tree.CheckInvariants());
349 tree.Add(tree.CreateInterval(4, 12));
350 ASSERT_TRUE(tree.CheckInvariants());
351 tree.Remove(tree.CreateInterval(4, 12));
352 ASSERT_TRUE(tree.CheckInvariants());
353 }
354
355 } // namespace WTF
356