OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2013, Google Inc. All rights reserved. | 2 * Copyright (c) 2013, Google Inc. All rights reserved. |
3 * | 3 * |
4 * Redistribution and use in source and binary forms, with or without | 4 * Redistribution and use in source and binary forms, with or without |
5 * modification, are permitted provided that the following conditions are | 5 * modification, are permitted provided that the following conditions are |
6 * met: | 6 * met: |
7 * | 7 * |
8 * * Redistributions of source code must retain the above copyright | 8 * * Redistributions of source code must retain the above copyright |
9 * notice, this list of conditions and the following disclaimer. | 9 * notice, this list of conditions and the following disclaimer. |
10 * * Redistributions in binary form must reproduce the above | 10 * * Redistributions in binary form must reproduce the above |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
65 blink::WebTimeRanges webRanges(static_cast<size_t>(2)); | 65 blink::WebTimeRanges webRanges(static_cast<size_t>(2)); |
66 webRanges[0].start = 0; | 66 webRanges[0].start = 0; |
67 webRanges[0].end = 1; | 67 webRanges[0].end = 1; |
68 webRanges[1].start = 2; | 68 webRanges[1].start = 2; |
69 webRanges[1].end = 3; | 69 webRanges[1].end = 3; |
70 ASSERT_RANGE("{ [0,1) [2,3) }", TimeRanges::create(webRanges)); | 70 ASSERT_RANGE("{ [0,1) [2,3) }", TimeRanges::create(webRanges)); |
71 } | 71 } |
72 | 72 |
73 TEST(TimeRangesTest, AddOrder) | 73 TEST(TimeRangesTest, AddOrder) |
74 { | 74 { |
75 RefPtrWillBeRawPtr<TimeRanges> rangeA = TimeRanges::create(); | 75 TimeRanges* rangeA = TimeRanges::create(); |
76 RefPtrWillBeRawPtr<TimeRanges> rangeB = TimeRanges::create(); | 76 TimeRanges* rangeB = TimeRanges::create(); |
77 | 77 |
78 rangeA->add(0, 2); | 78 rangeA->add(0, 2); |
79 rangeA->add(3, 4); | 79 rangeA->add(3, 4); |
80 rangeA->add(5, 100); | 80 rangeA->add(5, 100); |
81 | 81 |
82 std::string expected = "{ [0,2) [3,4) [5,100) }"; | 82 std::string expected = "{ [0,2) [3,4) [5,100) }"; |
83 ASSERT_RANGE(expected, rangeA); | 83 ASSERT_RANGE(expected, rangeA); |
84 | 84 |
85 // Add the values in rangeA to rangeB in reverse order. | 85 // Add the values in rangeA to rangeB in reverse order. |
86 for (int i = rangeA->length() - 1; i >= 0; --i) | 86 for (int i = rangeA->length() - 1; i >= 0; --i) |
87 rangeB->add(rangeA->start(i, IGNORE_EXCEPTION), rangeA->end(i, IGNORE_EX
CEPTION)); | 87 rangeB->add(rangeA->start(i, IGNORE_EXCEPTION), rangeA->end(i, IGNORE_EX
CEPTION)); |
88 | 88 |
89 ASSERT_RANGE(expected, rangeB); | 89 ASSERT_RANGE(expected, rangeB); |
90 } | 90 } |
91 | 91 |
92 TEST(TimeRangesTest, OverlappingAdds) | 92 TEST(TimeRangesTest, OverlappingAdds) |
93 { | 93 { |
94 RefPtrWillBeRawPtr<TimeRanges> ranges = TimeRanges::create(); | 94 TimeRanges* ranges = TimeRanges::create(); |
95 | 95 |
96 ranges->add(0, 2); | 96 ranges->add(0, 2); |
97 ranges->add(10, 11); | 97 ranges->add(10, 11); |
98 ASSERT_RANGE("{ [0,2) [10,11) }", ranges); | 98 ASSERT_RANGE("{ [0,2) [10,11) }", ranges); |
99 | 99 |
100 ranges->add(0, 2); | 100 ranges->add(0, 2); |
101 ASSERT_RANGE("{ [0,2) [10,11) }", ranges); | 101 ASSERT_RANGE("{ [0,2) [10,11) }", ranges); |
102 | 102 |
103 ranges->add(2, 3); | 103 ranges->add(2, 3); |
104 ASSERT_RANGE("{ [0,3) [10,11) }", ranges); | 104 ASSERT_RANGE("{ [0,3) [10,11) }", ranges); |
105 | 105 |
106 ranges->add(2, 6); | 106 ranges->add(2, 6); |
107 ASSERT_RANGE("{ [0,6) [10,11) }", ranges); | 107 ASSERT_RANGE("{ [0,6) [10,11) }", ranges); |
108 | 108 |
109 ranges->add(9, 10); | 109 ranges->add(9, 10); |
110 ASSERT_RANGE("{ [0,6) [9,11) }", ranges); | 110 ASSERT_RANGE("{ [0,6) [9,11) }", ranges); |
111 | 111 |
112 ranges->add(8, 10); | 112 ranges->add(8, 10); |
113 ASSERT_RANGE("{ [0,6) [8,11) }", ranges); | 113 ASSERT_RANGE("{ [0,6) [8,11) }", ranges); |
114 | 114 |
115 ranges->add(-1, 7); | 115 ranges->add(-1, 7); |
116 ASSERT_RANGE("{ [-1,7) [8,11) }", ranges); | 116 ASSERT_RANGE("{ [-1,7) [8,11) }", ranges); |
117 | 117 |
118 ranges->add(6, 9); | 118 ranges->add(6, 9); |
119 ASSERT_RANGE("{ [-1,11) }", ranges); | 119 ASSERT_RANGE("{ [-1,11) }", ranges); |
120 } | 120 } |
121 | 121 |
122 TEST(TimeRangesTest, IntersectWith_Self) | 122 TEST(TimeRangesTest, IntersectWith_Self) |
123 { | 123 { |
124 RefPtrWillBeRawPtr<TimeRanges> ranges = TimeRanges::create(0, 2); | 124 TimeRanges* ranges = TimeRanges::create(0, 2); |
125 | 125 |
126 ASSERT_RANGE("{ [0,2) }", ranges); | 126 ASSERT_RANGE("{ [0,2) }", ranges); |
127 | 127 |
128 ranges->intersectWith(ranges.get()); | 128 ranges->intersectWith(ranges); |
129 | 129 |
130 ASSERT_RANGE("{ [0,2) }", ranges); | 130 ASSERT_RANGE("{ [0,2) }", ranges); |
131 } | 131 } |
132 | 132 |
133 TEST(TimeRangesTest, IntersectWith_IdenticalRange) | 133 TEST(TimeRangesTest, IntersectWith_IdenticalRange) |
134 { | 134 { |
135 RefPtrWillBeRawPtr<TimeRanges> rangesA = TimeRanges::create(0, 2); | 135 TimeRanges* rangesA = TimeRanges::create(0, 2); |
136 RefPtrWillBeRawPtr<TimeRanges> rangesB = rangesA->copy(); | 136 TimeRanges* rangesB = rangesA->copy(); |
137 | 137 |
138 ASSERT_RANGE("{ [0,2) }", rangesA); | 138 ASSERT_RANGE("{ [0,2) }", rangesA); |
139 ASSERT_RANGE("{ [0,2) }", rangesB); | 139 ASSERT_RANGE("{ [0,2) }", rangesB); |
140 | 140 |
141 rangesA->intersectWith(rangesB.get()); | 141 rangesA->intersectWith(rangesB); |
142 | 142 |
143 ASSERT_RANGE("{ [0,2) }", rangesA); | 143 ASSERT_RANGE("{ [0,2) }", rangesA); |
144 ASSERT_RANGE("{ [0,2) }", rangesB); | 144 ASSERT_RANGE("{ [0,2) }", rangesB); |
145 } | 145 } |
146 | 146 |
147 TEST(TimeRangesTest, IntersectWith_Empty) | 147 TEST(TimeRangesTest, IntersectWith_Empty) |
148 { | 148 { |
149 RefPtrWillBeRawPtr<TimeRanges> rangesA = TimeRanges::create(0, 2); | 149 TimeRanges* rangesA = TimeRanges::create(0, 2); |
150 RefPtrWillBeRawPtr<TimeRanges> rangesB = TimeRanges::create(); | 150 TimeRanges* rangesB = TimeRanges::create(); |
151 | 151 |
152 ASSERT_RANGE("{ [0,2) }", rangesA); | 152 ASSERT_RANGE("{ [0,2) }", rangesA); |
153 ASSERT_RANGE("{ }", rangesB); | 153 ASSERT_RANGE("{ }", rangesB); |
154 | 154 |
155 rangesA->intersectWith(rangesB.get()); | 155 rangesA->intersectWith(rangesB); |
156 | 156 |
157 ASSERT_RANGE("{ }", rangesA); | 157 ASSERT_RANGE("{ }", rangesA); |
158 ASSERT_RANGE("{ }", rangesB); | 158 ASSERT_RANGE("{ }", rangesB); |
159 } | 159 } |
160 | 160 |
161 TEST(TimeRangesTest, IntersectWith_DisjointRanges1) | 161 TEST(TimeRangesTest, IntersectWith_DisjointRanges1) |
162 { | 162 { |
163 RefPtrWillBeRawPtr<TimeRanges> rangesA = TimeRanges::create(); | 163 TimeRanges* rangesA = TimeRanges::create(); |
164 RefPtrWillBeRawPtr<TimeRanges> rangesB = TimeRanges::create(); | 164 TimeRanges* rangesB = TimeRanges::create(); |
165 | 165 |
166 rangesA->add(0, 1); | 166 rangesA->add(0, 1); |
167 rangesA->add(4, 5); | 167 rangesA->add(4, 5); |
168 | 168 |
169 rangesB->add(2, 3); | 169 rangesB->add(2, 3); |
170 rangesB->add(6, 7); | 170 rangesB->add(6, 7); |
171 | 171 |
172 ASSERT_RANGE("{ [0,1) [4,5) }", rangesA); | 172 ASSERT_RANGE("{ [0,1) [4,5) }", rangesA); |
173 ASSERT_RANGE("{ [2,3) [6,7) }", rangesB); | 173 ASSERT_RANGE("{ [2,3) [6,7) }", rangesB); |
174 | 174 |
175 rangesA->intersectWith(rangesB.get()); | 175 rangesA->intersectWith(rangesB); |
176 | 176 |
177 ASSERT_RANGE("{ }", rangesA); | 177 ASSERT_RANGE("{ }", rangesA); |
178 ASSERT_RANGE("{ [2,3) [6,7) }", rangesB); | 178 ASSERT_RANGE("{ [2,3) [6,7) }", rangesB); |
179 } | 179 } |
180 | 180 |
181 TEST(TimeRangesTest, IntersectWith_DisjointRanges2) | 181 TEST(TimeRangesTest, IntersectWith_DisjointRanges2) |
182 { | 182 { |
183 RefPtrWillBeRawPtr<TimeRanges> rangesA = TimeRanges::create(); | 183 TimeRanges* rangesA = TimeRanges::create(); |
184 RefPtrWillBeRawPtr<TimeRanges> rangesB = TimeRanges::create(); | 184 TimeRanges* rangesB = TimeRanges::create(); |
185 | 185 |
186 rangesA->add(0, 1); | 186 rangesA->add(0, 1); |
187 rangesA->add(4, 5); | 187 rangesA->add(4, 5); |
188 | 188 |
189 rangesB->add(1, 4); | 189 rangesB->add(1, 4); |
190 rangesB->add(5, 7); | 190 rangesB->add(5, 7); |
191 | 191 |
192 ASSERT_RANGE("{ [0,1) [4,5) }", rangesA); | 192 ASSERT_RANGE("{ [0,1) [4,5) }", rangesA); |
193 ASSERT_RANGE("{ [1,4) [5,7) }", rangesB); | 193 ASSERT_RANGE("{ [1,4) [5,7) }", rangesB); |
194 | 194 |
195 rangesA->intersectWith(rangesB.get()); | 195 rangesA->intersectWith(rangesB); |
196 | 196 |
197 ASSERT_RANGE("{ }", rangesA); | 197 ASSERT_RANGE("{ }", rangesA); |
198 ASSERT_RANGE("{ [1,4) [5,7) }", rangesB); | 198 ASSERT_RANGE("{ [1,4) [5,7) }", rangesB); |
199 } | 199 } |
200 | 200 |
201 TEST(TimeRangesTest, IntersectWith_CompleteOverlap1) | 201 TEST(TimeRangesTest, IntersectWith_CompleteOverlap1) |
202 { | 202 { |
203 RefPtrWillBeRawPtr<TimeRanges> rangesA = TimeRanges::create(); | 203 TimeRanges* rangesA = TimeRanges::create(); |
204 RefPtrWillBeRawPtr<TimeRanges> rangesB = TimeRanges::create(); | 204 TimeRanges* rangesB = TimeRanges::create(); |
205 | 205 |
206 rangesA->add(1, 3); | 206 rangesA->add(1, 3); |
207 rangesA->add(4, 5); | 207 rangesA->add(4, 5); |
208 rangesA->add(6, 9); | 208 rangesA->add(6, 9); |
209 | 209 |
210 rangesB->add(0, 10); | 210 rangesB->add(0, 10); |
211 | 211 |
212 ASSERT_RANGE("{ [1,3) [4,5) [6,9) }", rangesA); | 212 ASSERT_RANGE("{ [1,3) [4,5) [6,9) }", rangesA); |
213 ASSERT_RANGE("{ [0,10) }", rangesB); | 213 ASSERT_RANGE("{ [0,10) }", rangesB); |
214 | 214 |
215 rangesA->intersectWith(rangesB.get()); | 215 rangesA->intersectWith(rangesB); |
216 | 216 |
217 ASSERT_RANGE("{ [1,3) [4,5) [6,9) }", rangesA); | 217 ASSERT_RANGE("{ [1,3) [4,5) [6,9) }", rangesA); |
218 ASSERT_RANGE("{ [0,10) }", rangesB); | 218 ASSERT_RANGE("{ [0,10) }", rangesB); |
219 } | 219 } |
220 | 220 |
221 TEST(TimeRangesTest, IntersectWith_CompleteOverlap2) | 221 TEST(TimeRangesTest, IntersectWith_CompleteOverlap2) |
222 { | 222 { |
223 RefPtrWillBeRawPtr<TimeRanges> rangesA = TimeRanges::create(); | 223 TimeRanges* rangesA = TimeRanges::create(); |
224 RefPtrWillBeRawPtr<TimeRanges> rangesB = TimeRanges::create(); | 224 TimeRanges* rangesB = TimeRanges::create(); |
225 | 225 |
226 rangesA->add(1, 3); | 226 rangesA->add(1, 3); |
227 rangesA->add(4, 5); | 227 rangesA->add(4, 5); |
228 rangesA->add(6, 9); | 228 rangesA->add(6, 9); |
229 | 229 |
230 rangesB->add(1, 9); | 230 rangesB->add(1, 9); |
231 | 231 |
232 ASSERT_RANGE("{ [1,3) [4,5) [6,9) }", rangesA); | 232 ASSERT_RANGE("{ [1,3) [4,5) [6,9) }", rangesA); |
233 ASSERT_RANGE("{ [1,9) }", rangesB); | 233 ASSERT_RANGE("{ [1,9) }", rangesB); |
234 | 234 |
235 rangesA->intersectWith(rangesB.get()); | 235 rangesA->intersectWith(rangesB); |
236 | 236 |
237 ASSERT_RANGE("{ [1,3) [4,5) [6,9) }", rangesA); | 237 ASSERT_RANGE("{ [1,3) [4,5) [6,9) }", rangesA); |
238 ASSERT_RANGE("{ [1,9) }", rangesB); | 238 ASSERT_RANGE("{ [1,9) }", rangesB); |
239 } | 239 } |
240 | 240 |
241 TEST(TimeRangesTest, IntersectWith_Gaps1) | 241 TEST(TimeRangesTest, IntersectWith_Gaps1) |
242 { | 242 { |
243 RefPtrWillBeRawPtr<TimeRanges> rangesA = TimeRanges::create(); | 243 TimeRanges* rangesA = TimeRanges::create(); |
244 RefPtrWillBeRawPtr<TimeRanges> rangesB = TimeRanges::create(); | 244 TimeRanges* rangesB = TimeRanges::create(); |
245 | 245 |
246 rangesA->add(0, 2); | 246 rangesA->add(0, 2); |
247 rangesA->add(4, 6); | 247 rangesA->add(4, 6); |
248 | 248 |
249 rangesB->add(1, 5); | 249 rangesB->add(1, 5); |
250 | 250 |
251 ASSERT_RANGE("{ [0,2) [4,6) }", rangesA); | 251 ASSERT_RANGE("{ [0,2) [4,6) }", rangesA); |
252 ASSERT_RANGE("{ [1,5) }", rangesB); | 252 ASSERT_RANGE("{ [1,5) }", rangesB); |
253 | 253 |
254 rangesA->intersectWith(rangesB.get()); | 254 rangesA->intersectWith(rangesB); |
255 | 255 |
256 ASSERT_RANGE("{ [1,2) [4,5) }", rangesA); | 256 ASSERT_RANGE("{ [1,2) [4,5) }", rangesA); |
257 ASSERT_RANGE("{ [1,5) }", rangesB); | 257 ASSERT_RANGE("{ [1,5) }", rangesB); |
258 } | 258 } |
259 | 259 |
260 TEST(TimeRangesTest, IntersectWith_Gaps2) | 260 TEST(TimeRangesTest, IntersectWith_Gaps2) |
261 { | 261 { |
262 RefPtrWillBeRawPtr<TimeRanges> rangesA = TimeRanges::create(); | 262 TimeRanges* rangesA = TimeRanges::create(); |
263 RefPtrWillBeRawPtr<TimeRanges> rangesB = TimeRanges::create(); | 263 TimeRanges* rangesB = TimeRanges::create(); |
264 | 264 |
265 rangesA->add(0, 2); | 265 rangesA->add(0, 2); |
266 rangesA->add(4, 6); | 266 rangesA->add(4, 6); |
267 rangesA->add(8, 10); | 267 rangesA->add(8, 10); |
268 | 268 |
269 rangesB->add(1, 9); | 269 rangesB->add(1, 9); |
270 | 270 |
271 ASSERT_RANGE("{ [0,2) [4,6) [8,10) }", rangesA); | 271 ASSERT_RANGE("{ [0,2) [4,6) [8,10) }", rangesA); |
272 ASSERT_RANGE("{ [1,9) }", rangesB); | 272 ASSERT_RANGE("{ [1,9) }", rangesB); |
273 | 273 |
274 rangesA->intersectWith(rangesB.get()); | 274 rangesA->intersectWith(rangesB); |
275 | 275 |
276 ASSERT_RANGE("{ [1,2) [4,6) [8,9) }", rangesA); | 276 ASSERT_RANGE("{ [1,2) [4,6) [8,9) }", rangesA); |
277 ASSERT_RANGE("{ [1,9) }", rangesB); | 277 ASSERT_RANGE("{ [1,9) }", rangesB); |
278 } | 278 } |
279 | 279 |
280 TEST(TimeRangesTest, IntersectWith_Gaps3) | 280 TEST(TimeRangesTest, IntersectWith_Gaps3) |
281 { | 281 { |
282 RefPtrWillBeRawPtr<TimeRanges> rangesA = TimeRanges::create(); | 282 TimeRanges* rangesA = TimeRanges::create(); |
283 RefPtrWillBeRawPtr<TimeRanges> rangesB = TimeRanges::create(); | 283 TimeRanges* rangesB = TimeRanges::create(); |
284 | 284 |
285 rangesA->add(0, 2); | 285 rangesA->add(0, 2); |
286 rangesA->add(4, 7); | 286 rangesA->add(4, 7); |
287 rangesA->add(8, 10); | 287 rangesA->add(8, 10); |
288 | 288 |
289 rangesB->add(1, 5); | 289 rangesB->add(1, 5); |
290 rangesB->add(6, 9); | 290 rangesB->add(6, 9); |
291 | 291 |
292 ASSERT_RANGE("{ [0,2) [4,7) [8,10) }", rangesA); | 292 ASSERT_RANGE("{ [0,2) [4,7) [8,10) }", rangesA); |
293 ASSERT_RANGE("{ [1,5) [6,9) }", rangesB); | 293 ASSERT_RANGE("{ [1,5) [6,9) }", rangesB); |
294 | 294 |
295 rangesA->intersectWith(rangesB.get()); | 295 rangesA->intersectWith(rangesB); |
296 | 296 |
297 ASSERT_RANGE("{ [1,2) [4,5) [6,7) [8,9) }", rangesA); | 297 ASSERT_RANGE("{ [1,2) [4,5) [6,7) [8,9) }", rangesA); |
298 ASSERT_RANGE("{ [1,5) [6,9) }", rangesB); | 298 ASSERT_RANGE("{ [1,5) [6,9) }", rangesB); |
299 } | 299 } |
300 | 300 |
301 TEST(TimeRangesTest, Nearest) | 301 TEST(TimeRangesTest, Nearest) |
302 { | 302 { |
303 RefPtrWillBeRawPtr<TimeRanges> ranges = TimeRanges::create(); | 303 TimeRanges* ranges = TimeRanges::create(); |
304 ranges->add(0, 2); | 304 ranges->add(0, 2); |
305 ranges->add(5, 7); | 305 ranges->add(5, 7); |
306 | 306 |
307 ASSERT_EQ(0, ranges->nearest(0, 0)); | 307 ASSERT_EQ(0, ranges->nearest(0, 0)); |
308 ASSERT_EQ(1, ranges->nearest(1, 0)); | 308 ASSERT_EQ(1, ranges->nearest(1, 0)); |
309 ASSERT_EQ(2, ranges->nearest(2, 0)); | 309 ASSERT_EQ(2, ranges->nearest(2, 0)); |
310 ASSERT_EQ(2, ranges->nearest(3, 0)); | 310 ASSERT_EQ(2, ranges->nearest(3, 0)); |
311 ASSERT_EQ(5, ranges->nearest(4, 0)); | 311 ASSERT_EQ(5, ranges->nearest(4, 0)); |
312 ASSERT_EQ(5, ranges->nearest(5, 0)); | 312 ASSERT_EQ(5, ranges->nearest(5, 0)); |
313 ASSERT_EQ(7, ranges->nearest(8, 0)); | 313 ASSERT_EQ(7, ranges->nearest(8, 0)); |
314 | 314 |
315 ranges->add(9, 11); | 315 ranges->add(9, 11); |
316 ASSERT_EQ(7, ranges->nearest(8, 6)); | 316 ASSERT_EQ(7, ranges->nearest(8, 6)); |
317 ASSERT_EQ(7, ranges->nearest(8, 8)); | 317 ASSERT_EQ(7, ranges->nearest(8, 8)); |
318 ASSERT_EQ(9, ranges->nearest(8, 10)); | 318 ASSERT_EQ(9, ranges->nearest(8, 10)); |
319 } | 319 } |
320 | 320 |
321 } // namespace blink | 321 } // namespace blink |
OLD | NEW |