| OLD | NEW |
|---|
| (Empty) |
| 1 <!DOCTYPE html> | |
| 2 <!-- | |
| 3 Copyright (c) 2014 The Chromium Authors. All rights reserved. | |
| 4 Use of this source code is governed by a BSD-style license that can be | |
| 5 found in the LICENSE file. | |
| 6 --> | |
| 7 | |
| 8 <link rel="import" href="/tracing/base/range.html"> | |
| 9 | |
| 10 <script> | |
| 11 'use strict'; | |
| 12 | |
| 13 tr.b.unittest.testSuite(function() { | |
| 14 var Range = tr.b.Range; | |
| 15 | |
| 16 test('addValue', function() { | |
| 17 var range = new Range(); | |
| 18 assert.isTrue(range.isEmpty); | |
| 19 range.addValue(1); | |
| 20 assert.isFalse(range.isEmpty); | |
| 21 assert.equal(1, range.min); | |
| 22 assert.equal(1, range.max); | |
| 23 | |
| 24 range.addValue(2); | |
| 25 assert.isFalse(range.isEmpty); | |
| 26 assert.equal(1, range.min); | |
| 27 assert.equal(2, range.max); | |
| 28 }); | |
| 29 | |
| 30 test('addNonEmptyRange', function() { | |
| 31 var r1 = new Range(); | |
| 32 r1.addValue(1); | |
| 33 r1.addValue(2); | |
| 34 | |
| 35 var r = new Range(); | |
| 36 r.addRange(r1); | |
| 37 assert.equal(1, r.min); | |
| 38 assert.equal(2, r.max); | |
| 39 | |
| 40 var r2 = Range.fromDict(r.toJSON()); | |
| 41 assert.equal(r2.isEmpty, r.isEmpty); | |
| 42 assert.equal(r2.max, r.max); | |
| 43 assert.equal(r2.min, r.min); | |
| 44 }); | |
| 45 | |
| 46 test('addEmptyRange', function() { | |
| 47 var r1 = new Range(); | |
| 48 | |
| 49 var r = new Range(); | |
| 50 r.addRange(r1); | |
| 51 assert.isTrue(r.isEmpty); | |
| 52 assert.isUndefined(r.min); | |
| 53 assert.isUndefined(r.max); | |
| 54 | |
| 55 var r2 = Range.fromDict(r.toJSON()); | |
| 56 assert.equal(r2.isEmpty, r.isEmpty); | |
| 57 assert.isUndefined(r2.max); | |
| 58 assert.isUndefined(r2.min); | |
| 59 }); | |
| 60 | |
| 61 test('addRangeToRange', function() { | |
| 62 var r1 = new Range(); | |
| 63 r1.addValue(1); | |
| 64 r1.addValue(2); | |
| 65 | |
| 66 var r = new Range(); | |
| 67 r.addValue(3); | |
| 68 r.addRange(r1); | |
| 69 | |
| 70 assert.isFalse(r.isEmpty); | |
| 71 assert.equal(1, r.min); | |
| 72 assert.equal(3, r.max); | |
| 73 }); | |
| 74 | |
| 75 test('containsRange', function() { | |
| 76 var r1 = Range.fromExplicitRange(0, 3); | |
| 77 var r2 = Range.fromExplicitRange(1, 2); | |
| 78 | |
| 79 assert.isTrue(r1.containsRangeInclusive(r2)); | |
| 80 assert.isFalse(r2.containsRangeInclusive(r1)); | |
| 81 assert.isTrue(r1.containsRangeExclusive(r2)); | |
| 82 assert.isFalse(r2.containsRangeExclusive(r1)); | |
| 83 }); | |
| 84 | |
| 85 test('containsRange_emptyRange', function() { | |
| 86 var r1 = Range.fromExplicitRange(0, 3); | |
| 87 var r2 = new Range(); | |
| 88 | |
| 89 assert.isFalse(r1.containsRangeInclusive(r2)); | |
| 90 assert.isFalse(r2.containsRangeInclusive(r1)); | |
| 91 assert.isFalse(r1.containsRangeExclusive(r2)); | |
| 92 assert.isFalse(r2.containsRangeExclusive(r1)); | |
| 93 }); | |
| 94 | |
| 95 test('containsRange_overlapping', function() { | |
| 96 var r1 = Range.fromExplicitRange(0, 3); | |
| 97 var r2 = Range.fromExplicitRange(2, 4); | |
| 98 | |
| 99 assert.isFalse(r1.containsRangeInclusive(r2)); | |
| 100 assert.isFalse(r2.containsRangeInclusive(r1)); | |
| 101 assert.isFalse(r1.containsRangeExclusive(r2)); | |
| 102 assert.isFalse(r2.containsRangeExclusive(r1)); | |
| 103 }); | |
| 104 | |
| 105 test('containsRange_disjoint', function() { | |
| 106 var r1 = Range.fromExplicitRange(0, 2); | |
| 107 var r2 = Range.fromExplicitRange(3, 5); | |
| 108 | |
| 109 assert.isFalse(r1.containsRangeInclusive(r2)); | |
| 110 assert.isFalse(r2.containsRangeInclusive(r1)); | |
| 111 assert.isFalse(r1.containsRangeExclusive(r2)); | |
| 112 assert.isFalse(r2.containsRangeExclusive(r1)); | |
| 113 }); | |
| 114 | |
| 115 test('containsRange_singlePointRange', function() { | |
| 116 var r1 = Range.fromExplicitRange(0, 2); | |
| 117 var r2 = Range.fromExplicitRange(1, 1); | |
| 118 | |
| 119 assert.isTrue(r1.containsRangeInclusive(r2)); | |
| 120 assert.isFalse(r2.containsRangeInclusive(r1)); | |
| 121 assert.isTrue(r1.containsRangeExclusive(r2)); | |
| 122 assert.isFalse(r2.containsRangeExclusive(r1)); | |
| 123 }); | |
| 124 | |
| 125 test('containsRange_singlePointRangeAtBorder', function() { | |
| 126 var r1 = Range.fromExplicitRange(0, 2); | |
| 127 var r2 = Range.fromExplicitRange(2, 2); | |
| 128 | |
| 129 assert.isTrue(r1.containsRangeInclusive(r2)); | |
| 130 assert.isFalse(r2.containsRangeInclusive(r1)); | |
| 131 assert.isFalse(r1.containsRangeExclusive(r2)); | |
| 132 assert.isFalse(r2.containsRangeExclusive(r1)); | |
| 133 }); | |
| 134 | |
| 135 test('containsExplicitRange', function() { | |
| 136 var r1 = Range.fromExplicitRange(0, 3); | |
| 137 var r2 = Range.fromExplicitRange(1, 2); | |
| 138 | |
| 139 assert.isTrue(r1.containsExplicitRangeInclusive(1, 2)); | |
| 140 assert.isFalse(r2.containsExplicitRangeInclusive(0, 3)); | |
| 141 assert.isTrue(r1.containsExplicitRangeExclusive(1, 2)); | |
| 142 assert.isFalse(r2.containsExplicitRangeExclusive(0, 3)); | |
| 143 }); | |
| 144 | |
| 145 test('containsExplicitRange_overlapping', function() { | |
| 146 var r1 = Range.fromExplicitRange(0, 3); | |
| 147 var r2 = Range.fromExplicitRange(2, 4); | |
| 148 | |
| 149 assert.isFalse(r1.containsExplicitRangeInclusive(2, 4)); | |
| 150 assert.isFalse(r2.containsExplicitRangeInclusive(0, 3)); | |
| 151 assert.isFalse(r1.containsExplicitRangeExclusive(2, 4)); | |
| 152 assert.isFalse(r2.containsExplicitRangeExclusive(0, 3)); | |
| 153 }); | |
| 154 | |
| 155 test('containsExplicitRange_disjoint', function() { | |
| 156 var r1 = Range.fromExplicitRange(0, 2); | |
| 157 var r2 = Range.fromExplicitRange(3, 5); | |
| 158 | |
| 159 assert.isFalse(r1.containsExplicitRangeInclusive(3, 5)); | |
| 160 assert.isFalse(r2.containsExplicitRangeInclusive(0, 2)); | |
| 161 assert.isFalse(r1.containsExplicitRangeExclusive(3, 5)); | |
| 162 assert.isFalse(r2.containsExplicitRangeExclusive(0, 2)); | |
| 163 }); | |
| 164 | |
| 165 test('containsExplicitRange_singlePointRange', function() { | |
| 166 var r1 = Range.fromExplicitRange(0, 2); | |
| 167 var r2 = Range.fromExplicitRange(1, 1); | |
| 168 | |
| 169 assert.isTrue(r1.containsExplicitRangeInclusive(1, 1)); | |
| 170 assert.isFalse(r2.containsExplicitRangeInclusive(0, 2)); | |
| 171 assert.isTrue(r1.containsExplicitRangeExclusive(1, 1)); | |
| 172 assert.isFalse(r2.containsExplicitRangeExclusive(0, 2)); | |
| 173 }); | |
| 174 | |
| 175 test('containsExplicitRange_singlePointRangeAtBorder', function() { | |
| 176 var r1 = Range.fromExplicitRange(0, 2); | |
| 177 var r2 = Range.fromExplicitRange(2, 2); | |
| 178 | |
| 179 assert.isTrue(r1.containsExplicitRangeInclusive(2, 2)); | |
| 180 assert.isFalse(r2.containsExplicitRangeInclusive(0, 2)); | |
| 181 assert.isFalse(r1.containsExplicitRangeExclusive(2, 2)); | |
| 182 assert.isFalse(r2.containsExplicitRangeExclusive(0, 2)); | |
| 183 }); | |
| 184 | |
| 185 test('intersectsRange', function() { | |
| 186 var r1 = Range.fromExplicitRange(0, 3); | |
| 187 var r2 = Range.fromExplicitRange(1, 2); | |
| 188 | |
| 189 assert.isTrue(r1.intersectsRangeInclusive(r2)); | |
| 190 assert.isTrue(r2.intersectsRangeInclusive(r1)); | |
| 191 assert.isTrue(r1.intersectsRangeExclusive(r2)); | |
| 192 assert.isTrue(r2.intersectsRangeExclusive(r1)); | |
| 193 }); | |
| 194 | |
| 195 test('intersectsRange_emptyRange', function() { | |
| 196 var r1 = Range.fromExplicitRange(0, 3); | |
| 197 var r2 = new Range(); | |
| 198 | |
| 199 assert.isFalse(r1.intersectsRangeInclusive(r2)); | |
| 200 assert.isFalse(r2.intersectsRangeInclusive(r1)); | |
| 201 assert.isFalse(r1.intersectsRangeExclusive(r2)); | |
| 202 assert.isFalse(r2.intersectsRangeExclusive(r1)); | |
| 203 }); | |
| 204 | |
| 205 test('intersectsRange_overlapping', function() { | |
| 206 var r1 = Range.fromExplicitRange(0, 3); | |
| 207 var r2 = Range.fromExplicitRange(2, 4); | |
| 208 | |
| 209 assert.isTrue(r1.intersectsRangeInclusive(r2)); | |
| 210 assert.isTrue(r2.intersectsRangeInclusive(r1)); | |
| 211 assert.isTrue(r1.intersectsRangeExclusive(r2)); | |
| 212 assert.isTrue(r2.intersectsRangeExclusive(r1)); | |
| 213 }); | |
| 214 | |
| 215 test('intersectsRange_disjoint', function() { | |
| 216 var r1 = Range.fromExplicitRange(0, 2); | |
| 217 var r2 = Range.fromExplicitRange(3, 5); | |
| 218 | |
| 219 assert.isFalse(r1.intersectsRangeInclusive(r2)); | |
| 220 assert.isFalse(r2.intersectsRangeInclusive(r1)); | |
| 221 assert.isFalse(r1.intersectsRangeExclusive(r2)); | |
| 222 assert.isFalse(r2.intersectsRangeExclusive(r1)); | |
| 223 }); | |
| 224 | |
| 225 test('intersectsRange_singlePointRange', function() { | |
| 226 var r1 = Range.fromExplicitRange(0, 2); | |
| 227 var r2 = Range.fromExplicitRange(1, 1); | |
| 228 | |
| 229 assert.isTrue(r1.intersectsRangeInclusive(r2)); | |
| 230 assert.isTrue(r2.intersectsRangeInclusive(r1)); | |
| 231 assert.isTrue(r1.intersectsRangeExclusive(r2)); | |
| 232 assert.isTrue(r2.intersectsRangeExclusive(r1)); | |
| 233 }); | |
| 234 | |
| 235 test('intersectsRange_singlePointRangeAtBorder', function() { | |
| 236 var r1 = Range.fromExplicitRange(0, 2); | |
| 237 var r2 = Range.fromExplicitRange(2, 2); | |
| 238 | |
| 239 assert.isTrue(r1.intersectsRangeInclusive(r2)); | |
| 240 assert.isTrue(r2.intersectsRangeInclusive(r1)); | |
| 241 assert.isFalse(r1.intersectsRangeExclusive(r2)); | |
| 242 assert.isFalse(r2.intersectsRangeExclusive(r1)); | |
| 243 }); | |
| 244 | |
| 245 test('intersectsExplicitRange', function() { | |
| 246 var r1 = Range.fromExplicitRange(0, 3); | |
| 247 var r2 = Range.fromExplicitRange(1, 2); | |
| 248 | |
| 249 assert.isTrue(r1.intersectsExplicitRangeInclusive(1, 2)); | |
| 250 assert.isTrue(r2.intersectsExplicitRangeInclusive(0, 3)); | |
| 251 assert.isTrue(r1.intersectsExplicitRangeExclusive(1, 2)); | |
| 252 assert.isTrue(r2.intersectsExplicitRangeExclusive(0, 3)); | |
| 253 }); | |
| 254 | |
| 255 test('intersectsExplicitRange_overlapping', function() { | |
| 256 var r1 = Range.fromExplicitRange(0, 3); | |
| 257 var r2 = Range.fromExplicitRange(2, 4); | |
| 258 | |
| 259 assert.isTrue(r1.intersectsExplicitRangeInclusive(2, 4)); | |
| 260 assert.isTrue(r2.intersectsExplicitRangeInclusive(0, 3)); | |
| 261 assert.isTrue(r1.intersectsExplicitRangeExclusive(2, 4)); | |
| 262 assert.isTrue(r2.intersectsExplicitRangeExclusive(0, 3)); | |
| 263 }); | |
| 264 | |
| 265 test('intersectsExplicitRange_disjoint', function() { | |
| 266 var r1 = Range.fromExplicitRange(0, 2); | |
| 267 var r2 = Range.fromExplicitRange(3, 5); | |
| 268 | |
| 269 assert.isFalse(r1.intersectsExplicitRangeInclusive(3, 5)); | |
| 270 assert.isFalse(r2.intersectsExplicitRangeInclusive(0, 2)); | |
| 271 assert.isFalse(r1.intersectsExplicitRangeExclusive(3, 5)); | |
| 272 assert.isFalse(r2.intersectsExplicitRangeExclusive(0, 2)); | |
| 273 }); | |
| 274 | |
| 275 test('intersectsExplicitRange_singlePointRange', function() { | |
| 276 var r1 = Range.fromExplicitRange(0, 2); | |
| 277 var r2 = Range.fromExplicitRange(1, 1); | |
| 278 | |
| 279 assert.isTrue(r1.intersectsExplicitRangeInclusive(1, 1)); | |
| 280 assert.isTrue(r2.intersectsExplicitRangeInclusive(0, 2)); | |
| 281 assert.isTrue(r1.intersectsExplicitRangeExclusive(1, 1)); | |
| 282 assert.isTrue(r2.intersectsExplicitRangeExclusive(0, 2)); | |
| 283 }); | |
| 284 | |
| 285 test('intersectsExplicitRange_singlePointRangeAtBorder', function() { | |
| 286 var r1 = Range.fromExplicitRange(0, 2); | |
| 287 var r2 = Range.fromExplicitRange(2, 2); | |
| 288 | |
| 289 assert.isTrue(r1.intersectsExplicitRangeInclusive(2, 2)); | |
| 290 assert.isTrue(r2.intersectsExplicitRangeInclusive(0, 2)); | |
| 291 assert.isFalse(r1.intersectsExplicitRangeExclusive(2, 2)); | |
| 292 assert.isFalse(r2.intersectsExplicitRangeExclusive(0, 2)); | |
| 293 }); | |
| 294 | |
| 295 test('duration', function() { | |
| 296 assert.equal(Range.fromExplicitRange(2, 4).duration, 2); | |
| 297 }); | |
| 298 | |
| 299 test('duration_singlePointRange', function() { | |
| 300 assert.equal(Range.fromExplicitRange(2, 2).duration, 0); | |
| 301 }); | |
| 302 | |
| 303 test('duration_emptyRange', function() { | |
| 304 assert.equal(new Range().duration, 0); | |
| 305 }); | |
| 306 | |
| 307 test('findIntersection_overlapping', function() { | |
| 308 var r1 = Range.fromExplicitRange(0, 2); | |
| 309 var r2 = Range.fromExplicitRange(1, 3); | |
| 310 | |
| 311 var result = Range.fromExplicitRange(1, 2); | |
| 312 assert.deepEqual(r1.findIntersection(r2), result); | |
| 313 assert.deepEqual(r2.findIntersection(r1), result); | |
| 314 }); | |
| 315 | |
| 316 test('findIntersection_bordering', function() { | |
| 317 var r1 = Range.fromExplicitRange(0, 2); | |
| 318 var r2 = Range.fromExplicitRange(2, 4); | |
| 319 | |
| 320 var result = Range.fromExplicitRange(2, 2); | |
| 321 assert.deepEqual(r1.findIntersection(r2), result); | |
| 322 assert.deepEqual(r2.findIntersection(r1), result); | |
| 323 }); | |
| 324 | |
| 325 test('findIntersection_singlePointRange', function() { | |
| 326 var r1 = Range.fromExplicitRange(0, 2); | |
| 327 var r2 = Range.fromExplicitRange(2, 2); | |
| 328 | |
| 329 var result = Range.fromExplicitRange(2, 2); | |
| 330 assert.deepEqual(r1.findIntersection(r2), result); | |
| 331 assert.deepEqual(r2.findIntersection(r1), result); | |
| 332 }); | |
| 333 | |
| 334 test('findIntersection_disjoint', function() { | |
| 335 var r1 = Range.fromExplicitRange(0, 2); | |
| 336 var r2 = Range.fromExplicitRange(3, 5); | |
| 337 | |
| 338 assert.isTrue(r1.findIntersection(r2).isEmpty); | |
| 339 assert.isTrue(r2.findIntersection(r1).isEmpty); | |
| 340 }); | |
| 341 | |
| 342 test('findIntersection_emptyRange', function() { | |
| 343 var r1 = Range.fromExplicitRange(0, 2); | |
| 344 var r2 = new Range(); | |
| 345 | |
| 346 assert.isTrue(r1.findIntersection(r2).isEmpty); | |
| 347 assert.isTrue(r2.findIntersection(r1).isEmpty); | |
| 348 }); | |
| 349 | |
| 350 test('findExplicitIntersectionDuration_overlapping', function() { | |
| 351 var r = Range.fromExplicitRange(2, 4); | |
| 352 assert.equal(1, r.findExplicitIntersectionDuration(1, 3)); | |
| 353 assert.equal(1, r.findExplicitIntersectionDuration(3, 5)); | |
| 354 assert.equal(2, r.findExplicitIntersectionDuration(0, 5)); | |
| 355 }); | |
| 356 | |
| 357 test('findExplicitIntersectionDuration_invalidOtherRange', function() { | |
| 358 var r = Range.fromExplicitRange(2, 4); | |
| 359 assert.equal(0, r.findExplicitIntersectionDuration(3, 1)); | |
| 360 assert.equal(0, r.findExplicitIntersectionDuration(5, 3)); | |
| 361 }); | |
| 362 | |
| 363 test('findExplicitIntersectionDuration_disjoint', function() { | |
| 364 var r = Range.fromExplicitRange(2, 4); | |
| 365 assert.equal(0, r.findExplicitIntersectionDuration(0, 1)); | |
| 366 assert.equal(0, r.findExplicitIntersectionDuration(4.5, 5)); | |
| 367 }); | |
| 368 | |
| 369 test('filter_numericField', function() { | |
| 370 var r = Range.fromExplicitRange(2, 3); | |
| 371 var array = [{start: 1}, | |
| 372 {start: 2}, | |
| 373 {start: 3}, | |
| 374 {start: 4}]; | |
| 375 assert.deepEqual([{start: 2}, {start: 3}], r.filterArray( | |
| 376 array, function(value) {return value.start;})); | |
| 377 }); | |
| 378 | |
| 379 test('filter_noNumericField', function() { | |
| 380 var r = Range.fromExplicitRange(2, 3); | |
| 381 assert.deepEqual([2, 3], r.filterArray([1, 2, 3, 4])); | |
| 382 }); | |
| 383 | |
| 384 test('filter_empty', function() { | |
| 385 var r = new Range(); | |
| 386 assert.deepEqual([], r.filterArray([1, 2, 3, 4])); | |
| 387 }); | |
| 388 | |
| 389 test('filter_oneSided', function() { | |
| 390 var r = new Range(); | |
| 391 r.min = 2; | |
| 392 assert.deepEqual([2, 3, 4], r.filterArray([1, 2, 3, 4])); | |
| 393 }); | |
| 394 | |
| 395 test('left_boundary_corner_case1', function() { | |
| 396 var r = Range.fromExplicitRange(1, 2); | |
| 397 var array = [{start: 1}, | |
| 398 {start: 2}, | |
| 399 {start: 3}, | |
| 400 {start: 4}]; | |
| 401 assert.deepEqual([{start: 1}, {start: 2}], r.filterArray( | |
| 402 array, function(value) {return value.start;})); | |
| 403 }); | |
| 404 | |
| 405 test('left_boundary_corner_case2', function() { | |
| 406 var r = Range.fromExplicitRange(0, 2); | |
| 407 var array = [{start: 1}, | |
| 408 {start: 2}, | |
| 409 {start: 3}, | |
| 410 {start: 4}]; | |
| 411 assert.deepEqual([{start: 1}, {start: 2}], r.filterArray( | |
| 412 array, function(value) {return value.start;})); | |
| 413 }); | |
| 414 | |
| 415 test('left_boundary_corner_case3', function() { | |
| 416 var r = Range.fromExplicitRange(1, 1); | |
| 417 var array = [{start: 1}, | |
| 418 {start: 2}, | |
| 419 {start: 3}, | |
| 420 {start: 4}]; | |
| 421 assert.deepEqual([{start: 1}], r.filterArray( | |
| 422 array, function(value) {return value.start;})); | |
| 423 }); | |
| 424 | |
| 425 test('left_boundary_corner_case4', function() { | |
| 426 var r = Range.fromExplicitRange(0, 0); | |
| 427 var array = [{start: 1}, | |
| 428 {start: 2}, | |
| 429 {start: 3}, | |
| 430 {start: 4}]; | |
| 431 assert.deepEqual([], r.filterArray( | |
| 432 array, function(value) {return value.start;})); | |
| 433 }); | |
| 434 | |
| 435 test('right_boundary_corner_case1', function() { | |
| 436 var r = Range.fromExplicitRange(4, 5); | |
| 437 var array = [{start: 1}, | |
| 438 {start: 2}, | |
| 439 {start: 3}, | |
| 440 {start: 4}]; | |
| 441 assert.deepEqual([{start: 4}], r.filterArray( | |
| 442 array, function(value) {return value.start;})); | |
| 443 }); | |
| 444 | |
| 445 test('right_boundary_corner_case2', function() { | |
| 446 var r = Range.fromExplicitRange(4, 4); | |
| 447 var array = [{start: 1}, | |
| 448 {start: 2}, | |
| 449 {start: 3}, | |
| 450 {start: 4}]; | |
| 451 assert.deepEqual([{start: 4}], r.filterArray( | |
| 452 array, function(value) {return value.start;})); | |
| 453 }); | |
| 454 | |
| 455 test('right_boundary_corner_case3', function() { | |
| 456 var r = Range.fromExplicitRange(5, 5); | |
| 457 var array = [{start: 1}, | |
| 458 {start: 2}, | |
| 459 {start: 3}, | |
| 460 {start: 4}]; | |
| 461 assert.deepEqual([], r.filterArray( | |
| 462 array, function(value) {return value.start;})); | |
| 463 }); | |
| 464 }); | |
| 465 </script> | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2771723003:
[tracing] Move math utilities from base into their own subdirectory (attempt 2) (Closed)
