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