| Index: trunk/phase3/resources/jquery/jquery.qunit.js |
| — | — | @@ -1,1442 +0,0 @@ |
| 2 | | -/** |
| 3 | | - * QUnit - A JavaScript Unit Testing Framework |
| 4 | | - * |
| 5 | | - * http://docs.jquery.com/QUnit |
| 6 | | - * |
| 7 | | - * Copyright (c) 2011 John Resig, Jörn Zaefferer |
| 8 | | - * Dual licensed under the MIT (MIT-LICENSE.txt) |
| 9 | | - * or GPL (GPL-LICENSE.txt) licenses. |
| 10 | | - */ |
| 11 | | - |
| 12 | | -(function(window) { |
| 13 | | - |
| 14 | | -var defined = { |
| 15 | | - setTimeout: typeof window.setTimeout !== "undefined", |
| 16 | | - sessionStorage: (function() { |
| 17 | | - try { |
| 18 | | - return !!sessionStorage.getItem; |
| 19 | | - } catch(e){ |
| 20 | | - return false; |
| 21 | | - } |
| 22 | | - })() |
| 23 | | -}; |
| 24 | | - |
| 25 | | -var testId = 0; |
| 26 | | - |
| 27 | | -var Test = function(name, testName, expected, testEnvironmentArg, async, callback) { |
| 28 | | - this.name = name; |
| 29 | | - this.testName = testName; |
| 30 | | - this.expected = expected; |
| 31 | | - this.testEnvironmentArg = testEnvironmentArg; |
| 32 | | - this.async = async; |
| 33 | | - this.callback = callback; |
| 34 | | - this.assertions = []; |
| 35 | | -}; |
| 36 | | -Test.prototype = { |
| 37 | | - init: function() { |
| 38 | | - var tests = id("qunit-tests"); |
| 39 | | - if (tests) { |
| 40 | | - var b = document.createElement("strong"); |
| 41 | | - b.innerHTML = "Running " + this.name; |
| 42 | | - var li = document.createElement("li"); |
| 43 | | - li.appendChild( b ); |
| 44 | | - li.className = "running"; |
| 45 | | - li.id = this.id = "test-output" + testId++; |
| 46 | | - tests.appendChild( li ); |
| 47 | | - } |
| 48 | | - }, |
| 49 | | - setup: function() { |
| 50 | | - if (this.module != config.previousModule) { |
| 51 | | - if ( config.previousModule ) { |
| 52 | | - QUnit.moduleDone( { |
| 53 | | - name: config.previousModule, |
| 54 | | - failed: config.moduleStats.bad, |
| 55 | | - passed: config.moduleStats.all - config.moduleStats.bad, |
| 56 | | - total: config.moduleStats.all |
| 57 | | - } ); |
| 58 | | - } |
| 59 | | - config.previousModule = this.module; |
| 60 | | - config.moduleStats = { all: 0, bad: 0 }; |
| 61 | | - QUnit.moduleStart( { |
| 62 | | - name: this.module |
| 63 | | - } ); |
| 64 | | - } |
| 65 | | - |
| 66 | | - config.current = this; |
| 67 | | - this.testEnvironment = extend({ |
| 68 | | - setup: function() {}, |
| 69 | | - teardown: function() {} |
| 70 | | - }, this.moduleTestEnvironment); |
| 71 | | - if (this.testEnvironmentArg) { |
| 72 | | - extend(this.testEnvironment, this.testEnvironmentArg); |
| 73 | | - } |
| 74 | | - |
| 75 | | - QUnit.testStart( { |
| 76 | | - name: this.testName |
| 77 | | - } ); |
| 78 | | - |
| 79 | | - // allow utility functions to access the current test environment |
| 80 | | - // TODO why?? |
| 81 | | - QUnit.current_testEnvironment = this.testEnvironment; |
| 82 | | - |
| 83 | | - try { |
| 84 | | - if ( !config.pollution ) { |
| 85 | | - saveGlobal(); |
| 86 | | - } |
| 87 | | - |
| 88 | | - this.testEnvironment.setup.call(this.testEnvironment); |
| 89 | | - } catch(e) { |
| 90 | | - QUnit.ok( false, "Setup failed on " + this.testName + ": " + e.message ); |
| 91 | | - } |
| 92 | | - }, |
| 93 | | - run: function() { |
| 94 | | - if ( this.async ) { |
| 95 | | - QUnit.stop(); |
| 96 | | - } |
| 97 | | - |
| 98 | | - if ( config.notrycatch ) { |
| 99 | | - this.callback.call(this.testEnvironment); |
| 100 | | - return; |
| 101 | | - } |
| 102 | | - try { |
| 103 | | - this.callback.call(this.testEnvironment); |
| 104 | | - } catch(e) { |
| 105 | | - fail("Test " + this.testName + " died, exception and test follows", e, this.callback); |
| 106 | | - QUnit.ok( false, "Died on test #" + (this.assertions.length + 1) + ": " + e.message + " - " + QUnit.jsDump.parse(e) ); |
| 107 | | - // else next test will carry the responsibility |
| 108 | | - saveGlobal(); |
| 109 | | - |
| 110 | | - // Restart the tests if they're blocking |
| 111 | | - if ( config.blocking ) { |
| 112 | | - start(); |
| 113 | | - } |
| 114 | | - } |
| 115 | | - }, |
| 116 | | - teardown: function() { |
| 117 | | - try { |
| 118 | | - checkPollution(); |
| 119 | | - this.testEnvironment.teardown.call(this.testEnvironment); |
| 120 | | - } catch(e) { |
| 121 | | - QUnit.ok( false, "Teardown failed on " + this.testName + ": " + e.message ); |
| 122 | | - } |
| 123 | | - }, |
| 124 | | - finish: function() { |
| 125 | | - if ( this.expected && this.expected != this.assertions.length ) { |
| 126 | | - QUnit.ok( false, "Expected " + this.expected + " assertions, but " + this.assertions.length + " were run" ); |
| 127 | | - } |
| 128 | | - |
| 129 | | - var good = 0, bad = 0, |
| 130 | | - tests = id("qunit-tests"); |
| 131 | | - |
| 132 | | - config.stats.all += this.assertions.length; |
| 133 | | - config.moduleStats.all += this.assertions.length; |
| 134 | | - |
| 135 | | - if ( tests ) { |
| 136 | | - var ol = document.createElement("ol"); |
| 137 | | - |
| 138 | | - for ( var i = 0; i < this.assertions.length; i++ ) { |
| 139 | | - var assertion = this.assertions[i]; |
| 140 | | - |
| 141 | | - var li = document.createElement("li"); |
| 142 | | - li.className = assertion.result ? "pass" : "fail"; |
| 143 | | - li.innerHTML = assertion.message || (assertion.result ? "okay" : "failed"); |
| 144 | | - ol.appendChild( li ); |
| 145 | | - |
| 146 | | - if ( assertion.result ) { |
| 147 | | - good++; |
| 148 | | - } else { |
| 149 | | - bad++; |
| 150 | | - config.stats.bad++; |
| 151 | | - config.moduleStats.bad++; |
| 152 | | - } |
| 153 | | - } |
| 154 | | - |
| 155 | | - // store result when possible |
| 156 | | - if ( QUnit.config.reorder && defined.sessionStorage ) { |
| 157 | | - if (bad) { |
| 158 | | - sessionStorage.setItem("qunit-" + this.module + "-" + this.testName, bad); |
| 159 | | - } else { |
| 160 | | - sessionStorage.removeItem("qunit-" + this.module + "-" + this.testName); |
| 161 | | - } |
| 162 | | - } |
| 163 | | - |
| 164 | | - if (bad == 0) { |
| 165 | | - ol.style.display = "none"; |
| 166 | | - } |
| 167 | | - |
| 168 | | - var b = document.createElement("strong"); |
| 169 | | - b.innerHTML = this.name + " <b class='counts'>(<b class='failed'>" + bad + "</b>, <b class='passed'>" + good + "</b>, " + this.assertions.length + ")</b>"; |
| 170 | | - |
| 171 | | - var a = document.createElement("a"); |
| 172 | | - a.innerHTML = "Rerun"; |
| 173 | | - a.href = QUnit.url({ filter: getText([b]).replace(/\([^)]+\)$/, "").replace(/(^\s*|\s*$)/g, "") }); |
| 174 | | - |
| 175 | | - addEvent(b, "click", function() { |
| 176 | | - var next = b.nextSibling.nextSibling, |
| 177 | | - display = next.style.display; |
| 178 | | - next.style.display = display === "none" ? "block" : "none"; |
| 179 | | - }); |
| 180 | | - |
| 181 | | - addEvent(b, "dblclick", function(e) { |
| 182 | | - var target = e && e.target ? e.target : window.event.srcElement; |
| 183 | | - if ( target.nodeName.toLowerCase() == "span" || target.nodeName.toLowerCase() == "b" ) { |
| 184 | | - target = target.parentNode; |
| 185 | | - } |
| 186 | | - if ( window.location && target.nodeName.toLowerCase() === "strong" ) { |
| 187 | | - window.location = QUnit.url({ filter: getText([target]).replace(/\([^)]+\)$/, "").replace(/(^\s*|\s*$)/g, "") }); |
| 188 | | - } |
| 189 | | - }); |
| 190 | | - |
| 191 | | - var li = id(this.id); |
| 192 | | - li.className = bad ? "fail" : "pass"; |
| 193 | | - li.removeChild( li.firstChild ); |
| 194 | | - li.appendChild( b ); |
| 195 | | - li.appendChild( a ); |
| 196 | | - li.appendChild( ol ); |
| 197 | | - |
| 198 | | - } else { |
| 199 | | - for ( var i = 0; i < this.assertions.length; i++ ) { |
| 200 | | - if ( !this.assertions[i].result ) { |
| 201 | | - bad++; |
| 202 | | - config.stats.bad++; |
| 203 | | - config.moduleStats.bad++; |
| 204 | | - } |
| 205 | | - } |
| 206 | | - } |
| 207 | | - |
| 208 | | - try { |
| 209 | | - QUnit.reset(); |
| 210 | | - } catch(e) { |
| 211 | | - fail("reset() failed, following Test " + this.testName + ", exception and reset fn follows", e, QUnit.reset); |
| 212 | | - } |
| 213 | | - |
| 214 | | - QUnit.testDone( { |
| 215 | | - name: this.testName, |
| 216 | | - failed: bad, |
| 217 | | - passed: this.assertions.length - bad, |
| 218 | | - total: this.assertions.length |
| 219 | | - } ); |
| 220 | | - }, |
| 221 | | - |
| 222 | | - queue: function() { |
| 223 | | - var test = this; |
| 224 | | - synchronize(function() { |
| 225 | | - test.init(); |
| 226 | | - }); |
| 227 | | - function run() { |
| 228 | | - // each of these can by async |
| 229 | | - synchronize(function() { |
| 230 | | - test.setup(); |
| 231 | | - }); |
| 232 | | - synchronize(function() { |
| 233 | | - test.run(); |
| 234 | | - }); |
| 235 | | - synchronize(function() { |
| 236 | | - test.teardown(); |
| 237 | | - }); |
| 238 | | - synchronize(function() { |
| 239 | | - test.finish(); |
| 240 | | - }); |
| 241 | | - } |
| 242 | | - // defer when previous test run passed, if storage is available |
| 243 | | - var bad = QUnit.config.reorder && defined.sessionStorage && +sessionStorage.getItem("qunit-" + this.module + "-" + this.testName); |
| 244 | | - if (bad) { |
| 245 | | - run(); |
| 246 | | - } else { |
| 247 | | - synchronize(run); |
| 248 | | - }; |
| 249 | | - } |
| 250 | | - |
| 251 | | -}; |
| 252 | | - |
| 253 | | -var QUnit = { |
| 254 | | - |
| 255 | | - // call on start of module test to prepend name to all tests |
| 256 | | - module: function(name, testEnvironment) { |
| 257 | | - config.currentModule = name; |
| 258 | | - config.currentModuleTestEnviroment = testEnvironment; |
| 259 | | - }, |
| 260 | | - |
| 261 | | - asyncTest: function(testName, expected, callback) { |
| 262 | | - if ( arguments.length === 2 ) { |
| 263 | | - callback = expected; |
| 264 | | - expected = 0; |
| 265 | | - } |
| 266 | | - |
| 267 | | - QUnit.test(testName, expected, callback, true); |
| 268 | | - }, |
| 269 | | - |
| 270 | | - test: function(testName, expected, callback, async) { |
| 271 | | - var name = '<span class="test-name">' + testName + '</span>', testEnvironmentArg; |
| 272 | | - |
| 273 | | - if ( arguments.length === 2 ) { |
| 274 | | - callback = expected; |
| 275 | | - expected = null; |
| 276 | | - } |
| 277 | | - // is 2nd argument a testEnvironment? |
| 278 | | - if ( expected && typeof expected === 'object') { |
| 279 | | - testEnvironmentArg = expected; |
| 280 | | - expected = null; |
| 281 | | - } |
| 282 | | - |
| 283 | | - if ( config.currentModule ) { |
| 284 | | - name = '<span class="module-name">' + config.currentModule + "</span>: " + name; |
| 285 | | - } |
| 286 | | - |
| 287 | | - if ( !validTest(config.currentModule + ": " + testName) ) { |
| 288 | | - return; |
| 289 | | - } |
| 290 | | - |
| 291 | | - var test = new Test(name, testName, expected, testEnvironmentArg, async, callback); |
| 292 | | - test.module = config.currentModule; |
| 293 | | - test.moduleTestEnvironment = config.currentModuleTestEnviroment; |
| 294 | | - test.queue(); |
| 295 | | - }, |
| 296 | | - |
| 297 | | - /** |
| 298 | | - * Specify the number of expected assertions to gurantee that failed test (no assertions are run at all) don't slip through. |
| 299 | | - */ |
| 300 | | - expect: function(asserts) { |
| 301 | | - config.current.expected = asserts; |
| 302 | | - }, |
| 303 | | - |
| 304 | | - /** |
| 305 | | - * Asserts true. |
| 306 | | - * @example ok( "asdfasdf".length > 5, "There must be at least 5 chars" ); |
| 307 | | - */ |
| 308 | | - ok: function(a, msg) { |
| 309 | | - a = !!a; |
| 310 | | - var details = { |
| 311 | | - result: a, |
| 312 | | - message: msg |
| 313 | | - }; |
| 314 | | - msg = escapeHtml(msg); |
| 315 | | - QUnit.log(details); |
| 316 | | - config.current.assertions.push({ |
| 317 | | - result: a, |
| 318 | | - message: msg |
| 319 | | - }); |
| 320 | | - }, |
| 321 | | - |
| 322 | | - /** |
| 323 | | - * Checks that the first two arguments are equal, with an optional message. |
| 324 | | - * Prints out both actual and expected values. |
| 325 | | - * |
| 326 | | - * Prefered to ok( actual == expected, message ) |
| 327 | | - * |
| 328 | | - * @example equal( format("Received {0} bytes.", 2), "Received 2 bytes." ); |
| 329 | | - * |
| 330 | | - * @param Object actual |
| 331 | | - * @param Object expected |
| 332 | | - * @param String message (optional) |
| 333 | | - */ |
| 334 | | - equal: function(actual, expected, message) { |
| 335 | | - QUnit.push(expected == actual, actual, expected, message); |
| 336 | | - }, |
| 337 | | - |
| 338 | | - notEqual: function(actual, expected, message) { |
| 339 | | - QUnit.push(expected != actual, actual, expected, message); |
| 340 | | - }, |
| 341 | | - |
| 342 | | - deepEqual: function(actual, expected, message) { |
| 343 | | - QUnit.push(QUnit.equiv(actual, expected), actual, expected, message); |
| 344 | | - }, |
| 345 | | - |
| 346 | | - notDeepEqual: function(actual, expected, message) { |
| 347 | | - QUnit.push(!QUnit.equiv(actual, expected), actual, expected, message); |
| 348 | | - }, |
| 349 | | - |
| 350 | | - strictEqual: function(actual, expected, message) { |
| 351 | | - QUnit.push(expected === actual, actual, expected, message); |
| 352 | | - }, |
| 353 | | - |
| 354 | | - notStrictEqual: function(actual, expected, message) { |
| 355 | | - QUnit.push(expected !== actual, actual, expected, message); |
| 356 | | - }, |
| 357 | | - |
| 358 | | - raises: function(block, expected, message) { |
| 359 | | - var actual, ok = false; |
| 360 | | - |
| 361 | | - if (typeof expected === 'string') { |
| 362 | | - message = expected; |
| 363 | | - expected = null; |
| 364 | | - } |
| 365 | | - |
| 366 | | - try { |
| 367 | | - block(); |
| 368 | | - } catch (e) { |
| 369 | | - actual = e; |
| 370 | | - } |
| 371 | | - |
| 372 | | - if (actual) { |
| 373 | | - // we don't want to validate thrown error |
| 374 | | - if (!expected) { |
| 375 | | - ok = true; |
| 376 | | - // expected is a regexp |
| 377 | | - } else if (QUnit.objectType(expected) === "regexp") { |
| 378 | | - ok = expected.test(actual); |
| 379 | | - // expected is a constructor |
| 380 | | - } else if (actual instanceof expected) { |
| 381 | | - ok = true; |
| 382 | | - // expected is a validation function which returns true is validation passed |
| 383 | | - } else if (expected.call({}, actual) === true) { |
| 384 | | - ok = true; |
| 385 | | - } |
| 386 | | - } |
| 387 | | - |
| 388 | | - QUnit.ok(ok, message); |
| 389 | | - }, |
| 390 | | - |
| 391 | | - start: function() { |
| 392 | | - config.semaphore--; |
| 393 | | - if (config.semaphore > 0) { |
| 394 | | - // don't start until equal number of stop-calls |
| 395 | | - return; |
| 396 | | - } |
| 397 | | - if (config.semaphore < 0) { |
| 398 | | - // ignore if start is called more often then stop |
| 399 | | - config.semaphore = 0; |
| 400 | | - } |
| 401 | | - // A slight delay, to avoid any current callbacks |
| 402 | | - if ( defined.setTimeout ) { |
| 403 | | - window.setTimeout(function() { |
| 404 | | - if ( config.timeout ) { |
| 405 | | - clearTimeout(config.timeout); |
| 406 | | - } |
| 407 | | - |
| 408 | | - config.blocking = false; |
| 409 | | - process(); |
| 410 | | - }, 13); |
| 411 | | - } else { |
| 412 | | - config.blocking = false; |
| 413 | | - process(); |
| 414 | | - } |
| 415 | | - }, |
| 416 | | - |
| 417 | | - stop: function(timeout) { |
| 418 | | - config.semaphore++; |
| 419 | | - config.blocking = true; |
| 420 | | - |
| 421 | | - if ( timeout && defined.setTimeout ) { |
| 422 | | - clearTimeout(config.timeout); |
| 423 | | - config.timeout = window.setTimeout(function() { |
| 424 | | - QUnit.ok( false, "Test timed out" ); |
| 425 | | - QUnit.start(); |
| 426 | | - }, timeout); |
| 427 | | - } |
| 428 | | - } |
| 429 | | -}; |
| 430 | | - |
| 431 | | -// Backwards compatibility, deprecated |
| 432 | | -QUnit.equals = QUnit.equal; |
| 433 | | -QUnit.same = QUnit.deepEqual; |
| 434 | | - |
| 435 | | -// Maintain internal state |
| 436 | | -var config = { |
| 437 | | - // The queue of tests to run |
| 438 | | - queue: [], |
| 439 | | - |
| 440 | | - // block until document ready |
| 441 | | - blocking: true, |
| 442 | | - |
| 443 | | - // by default, run previously failed tests first |
| 444 | | - // very useful in combination with "Hide passed tests" checked |
| 445 | | - reorder: true, |
| 446 | | - |
| 447 | | - noglobals: false, |
| 448 | | - notrycatch: false |
| 449 | | -}; |
| 450 | | - |
| 451 | | -// Load paramaters |
| 452 | | -(function() { |
| 453 | | - var location = window.location || { search: "", protocol: "file:" }, |
| 454 | | - params = location.search.slice( 1 ).split( "&" ), |
| 455 | | - length = params.length, |
| 456 | | - urlParams = {}, |
| 457 | | - current; |
| 458 | | - |
| 459 | | - if ( params[ 0 ] ) { |
| 460 | | - for ( var i = 0; i < length; i++ ) { |
| 461 | | - current = params[ i ].split( "=" ); |
| 462 | | - current[ 0 ] = decodeURIComponent( current[ 0 ] ); |
| 463 | | - // allow just a key to turn on a flag, e.g., test.html?noglobals |
| 464 | | - current[ 1 ] = current[ 1 ] ? decodeURIComponent( current[ 1 ] ) : true; |
| 465 | | - urlParams[ current[ 0 ] ] = current[ 1 ]; |
| 466 | | - if ( current[ 0 ] in config ) { |
| 467 | | - config[ current[ 0 ] ] = current[ 1 ]; |
| 468 | | - } |
| 469 | | - } |
| 470 | | - } |
| 471 | | - |
| 472 | | - QUnit.urlParams = urlParams; |
| 473 | | - config.filter = urlParams.filter; |
| 474 | | - |
| 475 | | - // Figure out if we're running the tests from a server or not |
| 476 | | - QUnit.isLocal = !!(location.protocol === 'file:'); |
| 477 | | -})(); |
| 478 | | - |
| 479 | | -// Expose the API as global variables, unless an 'exports' |
| 480 | | -// object exists, in that case we assume we're in CommonJS |
| 481 | | -if ( typeof exports === "undefined" || typeof require === "undefined" ) { |
| 482 | | - extend(window, QUnit); |
| 483 | | - window.QUnit = QUnit; |
| 484 | | -} else { |
| 485 | | - extend(exports, QUnit); |
| 486 | | - exports.QUnit = QUnit; |
| 487 | | -} |
| 488 | | - |
| 489 | | -// define these after exposing globals to keep them in these QUnit namespace only |
| 490 | | -extend(QUnit, { |
| 491 | | - config: config, |
| 492 | | - |
| 493 | | - // Initialize the configuration options |
| 494 | | - init: function() { |
| 495 | | - extend(config, { |
| 496 | | - stats: { all: 0, bad: 0 }, |
| 497 | | - moduleStats: { all: 0, bad: 0 }, |
| 498 | | - started: +new Date, |
| 499 | | - updateRate: 1000, |
| 500 | | - blocking: false, |
| 501 | | - autostart: true, |
| 502 | | - autorun: false, |
| 503 | | - filter: "", |
| 504 | | - queue: [], |
| 505 | | - semaphore: 0 |
| 506 | | - }); |
| 507 | | - |
| 508 | | - var tests = id( "qunit-tests" ), |
| 509 | | - banner = id( "qunit-banner" ), |
| 510 | | - result = id( "qunit-testresult" ); |
| 511 | | - |
| 512 | | - if ( tests ) { |
| 513 | | - tests.innerHTML = ""; |
| 514 | | - } |
| 515 | | - |
| 516 | | - if ( banner ) { |
| 517 | | - banner.className = ""; |
| 518 | | - } |
| 519 | | - |
| 520 | | - if ( result ) { |
| 521 | | - result.parentNode.removeChild( result ); |
| 522 | | - } |
| 523 | | - |
| 524 | | - if ( tests ) { |
| 525 | | - result = document.createElement( "p" ); |
| 526 | | - result.id = "qunit-testresult"; |
| 527 | | - result.className = "result"; |
| 528 | | - tests.parentNode.insertBefore( result, tests ); |
| 529 | | - result.innerHTML = 'Running...<br/> '; |
| 530 | | - } |
| 531 | | - }, |
| 532 | | - |
| 533 | | - /** |
| 534 | | - * Resets the test setup. Useful for tests that modify the DOM. |
| 535 | | - * |
| 536 | | - * If jQuery is available, uses jQuery's html(), otherwise just innerHTML. |
| 537 | | - */ |
| 538 | | - reset: function() { |
| 539 | | - if ( window.jQuery ) { |
| 540 | | - jQuery( "#qunit-fixture" ).html( config.fixture ); |
| 541 | | - } else { |
| 542 | | - var main = id( 'qunit-fixture' ); |
| 543 | | - if ( main ) { |
| 544 | | - main.innerHTML = config.fixture; |
| 545 | | - } |
| 546 | | - } |
| 547 | | - }, |
| 548 | | - |
| 549 | | - /** |
| 550 | | - * Trigger an event on an element. |
| 551 | | - * |
| 552 | | - * @example triggerEvent( document.body, "click" ); |
| 553 | | - * |
| 554 | | - * @param DOMElement elem |
| 555 | | - * @param String type |
| 556 | | - */ |
| 557 | | - triggerEvent: function( elem, type, event ) { |
| 558 | | - if ( document.createEvent ) { |
| 559 | | - event = document.createEvent("MouseEvents"); |
| 560 | | - event.initMouseEvent(type, true, true, elem.ownerDocument.defaultView, |
| 561 | | - 0, 0, 0, 0, 0, false, false, false, false, 0, null); |
| 562 | | - elem.dispatchEvent( event ); |
| 563 | | - |
| 564 | | - } else if ( elem.fireEvent ) { |
| 565 | | - elem.fireEvent("on"+type); |
| 566 | | - } |
| 567 | | - }, |
| 568 | | - |
| 569 | | - // Safe object type checking |
| 570 | | - is: function( type, obj ) { |
| 571 | | - return QUnit.objectType( obj ) == type; |
| 572 | | - }, |
| 573 | | - |
| 574 | | - objectType: function( obj ) { |
| 575 | | - if (typeof obj === "undefined") { |
| 576 | | - return "undefined"; |
| 577 | | - |
| 578 | | - // consider: typeof null === object |
| 579 | | - } |
| 580 | | - if (obj === null) { |
| 581 | | - return "null"; |
| 582 | | - } |
| 583 | | - |
| 584 | | - var type = Object.prototype.toString.call( obj ) |
| 585 | | - .match(/^\[object\s(.*)\]$/)[1] || ''; |
| 586 | | - |
| 587 | | - switch (type) { |
| 588 | | - case 'Number': |
| 589 | | - if (isNaN(obj)) { |
| 590 | | - return "nan"; |
| 591 | | - } else { |
| 592 | | - return "number"; |
| 593 | | - } |
| 594 | | - case 'String': |
| 595 | | - case 'Boolean': |
| 596 | | - case 'Array': |
| 597 | | - case 'Date': |
| 598 | | - case 'RegExp': |
| 599 | | - case 'Function': |
| 600 | | - return type.toLowerCase(); |
| 601 | | - } |
| 602 | | - if (typeof obj === "object") { |
| 603 | | - return "object"; |
| 604 | | - } |
| 605 | | - return undefined; |
| 606 | | - }, |
| 607 | | - |
| 608 | | - push: function(result, actual, expected, message) { |
| 609 | | - var details = { |
| 610 | | - result: result, |
| 611 | | - message: message, |
| 612 | | - actual: actual, |
| 613 | | - expected: expected |
| 614 | | - }; |
| 615 | | - |
| 616 | | - message = escapeHtml(message) || (result ? "okay" : "failed"); |
| 617 | | - message = '<span class="test-message">' + message + "</span>"; |
| 618 | | - expected = escapeHtml(QUnit.jsDump.parse(expected)); |
| 619 | | - actual = escapeHtml(QUnit.jsDump.parse(actual)); |
| 620 | | - var output = message + '<table><tr class="test-expected"><th>Expected: </th><td><pre>' + expected + '</pre></td></tr>'; |
| 621 | | - if (actual != expected) { |
| 622 | | - output += '<tr class="test-actual"><th>Result: </th><td><pre>' + actual + '</pre></td></tr>'; |
| 623 | | - output += '<tr class="test-diff"><th>Diff: </th><td><pre>' + QUnit.diff(expected, actual) +'</pre></td></tr>'; |
| 624 | | - } |
| 625 | | - if (!result) { |
| 626 | | - var source = sourceFromStacktrace(); |
| 627 | | - if (source) { |
| 628 | | - details.source = source; |
| 629 | | - output += '<tr class="test-source"><th>Source: </th><td><pre>' + source +'</pre></td></tr>'; |
| 630 | | - } |
| 631 | | - } |
| 632 | | - output += "</table>"; |
| 633 | | - |
| 634 | | - QUnit.log(details); |
| 635 | | - |
| 636 | | - config.current.assertions.push({ |
| 637 | | - result: !!result, |
| 638 | | - message: output |
| 639 | | - }); |
| 640 | | - }, |
| 641 | | - |
| 642 | | - url: function( params ) { |
| 643 | | - params = extend( extend( {}, QUnit.urlParams ), params ); |
| 644 | | - var querystring = "?", |
| 645 | | - key; |
| 646 | | - for ( key in params ) { |
| 647 | | - querystring += encodeURIComponent( key ) + "=" + |
| 648 | | - encodeURIComponent( params[ key ] ) + "&"; |
| 649 | | - } |
| 650 | | - return window.location.pathname + querystring.slice( 0, -1 ); |
| 651 | | - }, |
| 652 | | - |
| 653 | | - // Logging callbacks; all receive a single argument with the listed properties |
| 654 | | - // run test/logs.html for any related changes |
| 655 | | - begin: function() {}, |
| 656 | | - // done: { failed, passed, total, runtime } |
| 657 | | - done: function() {}, |
| 658 | | - // log: { result, actual, expected, message } |
| 659 | | - log: function() {}, |
| 660 | | - // testStart: { name } |
| 661 | | - testStart: function() {}, |
| 662 | | - // testDone: { name, failed, passed, total } |
| 663 | | - testDone: function() {}, |
| 664 | | - // moduleStart: { name } |
| 665 | | - moduleStart: function() {}, |
| 666 | | - // moduleDone: { name, failed, passed, total } |
| 667 | | - moduleDone: function() {} |
| 668 | | -}); |
| 669 | | - |
| 670 | | -if ( typeof document === "undefined" || document.readyState === "complete" ) { |
| 671 | | - config.autorun = true; |
| 672 | | -} |
| 673 | | - |
| 674 | | -addEvent(window, "load", function() { |
| 675 | | - QUnit.begin({}); |
| 676 | | - |
| 677 | | - // Initialize the config, saving the execution queue |
| 678 | | - var oldconfig = extend({}, config); |
| 679 | | - QUnit.init(); |
| 680 | | - extend(config, oldconfig); |
| 681 | | - |
| 682 | | - config.blocking = false; |
| 683 | | - |
| 684 | | - var userAgent = id("qunit-userAgent"); |
| 685 | | - if ( userAgent ) { |
| 686 | | - userAgent.innerHTML = navigator.userAgent; |
| 687 | | - } |
| 688 | | - var banner = id("qunit-header"); |
| 689 | | - if ( banner ) { |
| 690 | | - banner.innerHTML = '<a href="' + QUnit.url({ filter: undefined }) + '"> ' + banner.innerHTML + '</a> ' + |
| 691 | | - '<label><input name="noglobals" type="checkbox"' + ( config.noglobals ? ' checked="checked"' : '' ) + '>noglobals</label>' + |
| 692 | | - '<label><input name="notrycatch" type="checkbox"' + ( config.notrycatch ? ' checked="checked"' : '' ) + '>notrycatch</label>'; |
| 693 | | - addEvent( banner, "change", function( event ) { |
| 694 | | - var params = {}; |
| 695 | | - params[ event.target.name ] = event.target.checked ? true : undefined; |
| 696 | | - window.location = QUnit.url( params ); |
| 697 | | - }); |
| 698 | | - } |
| 699 | | - |
| 700 | | - var toolbar = id("qunit-testrunner-toolbar"); |
| 701 | | - if ( toolbar ) { |
| 702 | | - var filter = document.createElement("input"); |
| 703 | | - filter.type = "checkbox"; |
| 704 | | - filter.id = "qunit-filter-pass"; |
| 705 | | - addEvent( filter, "click", function() { |
| 706 | | - var ol = document.getElementById("qunit-tests"); |
| 707 | | - if ( filter.checked ) { |
| 708 | | - ol.className = ol.className + " hidepass"; |
| 709 | | - } else { |
| 710 | | - var tmp = " " + ol.className.replace( /[\n\t\r]/g, " " ) + " "; |
| 711 | | - ol.className = tmp.replace(/ hidepass /, " "); |
| 712 | | - } |
| 713 | | - if ( defined.sessionStorage ) { |
| 714 | | - if (filter.checked) { |
| 715 | | - sessionStorage.setItem("qunit-filter-passed-tests", "true"); |
| 716 | | - } else { |
| 717 | | - sessionStorage.removeItem("qunit-filter-passed-tests"); |
| 718 | | - } |
| 719 | | - } |
| 720 | | - }); |
| 721 | | - if ( defined.sessionStorage && sessionStorage.getItem("qunit-filter-passed-tests") ) { |
| 722 | | - filter.checked = true; |
| 723 | | - var ol = document.getElementById("qunit-tests"); |
| 724 | | - ol.className = ol.className + " hidepass"; |
| 725 | | - } |
| 726 | | - toolbar.appendChild( filter ); |
| 727 | | - |
| 728 | | - var label = document.createElement("label"); |
| 729 | | - label.setAttribute("for", "qunit-filter-pass"); |
| 730 | | - label.innerHTML = "Hide passed tests"; |
| 731 | | - toolbar.appendChild( label ); |
| 732 | | - } |
| 733 | | - |
| 734 | | - var main = id('qunit-fixture'); |
| 735 | | - if ( main ) { |
| 736 | | - config.fixture = main.innerHTML; |
| 737 | | - } |
| 738 | | - |
| 739 | | - if (config.autostart) { |
| 740 | | - QUnit.start(); |
| 741 | | - } |
| 742 | | -}); |
| 743 | | - |
| 744 | | -function done() { |
| 745 | | - config.autorun = true; |
| 746 | | - |
| 747 | | - // Log the last module results |
| 748 | | - if ( config.currentModule ) { |
| 749 | | - QUnit.moduleDone( { |
| 750 | | - name: config.currentModule, |
| 751 | | - failed: config.moduleStats.bad, |
| 752 | | - passed: config.moduleStats.all - config.moduleStats.bad, |
| 753 | | - total: config.moduleStats.all |
| 754 | | - } ); |
| 755 | | - } |
| 756 | | - |
| 757 | | - var banner = id("qunit-banner"), |
| 758 | | - tests = id("qunit-tests"), |
| 759 | | - runtime = +new Date - config.started, |
| 760 | | - passed = config.stats.all - config.stats.bad, |
| 761 | | - html = [ |
| 762 | | - 'Tests completed in ', |
| 763 | | - runtime, |
| 764 | | - ' milliseconds.<br/>', |
| 765 | | - '<span class="passed">', |
| 766 | | - passed, |
| 767 | | - '</span> tests of <span class="total">', |
| 768 | | - config.stats.all, |
| 769 | | - '</span> passed, <span class="failed">', |
| 770 | | - config.stats.bad, |
| 771 | | - '</span> failed.' |
| 772 | | - ].join(''); |
| 773 | | - |
| 774 | | - if ( banner ) { |
| 775 | | - banner.className = (config.stats.bad ? "qunit-fail" : "qunit-pass"); |
| 776 | | - } |
| 777 | | - |
| 778 | | - if ( tests ) { |
| 779 | | - id( "qunit-testresult" ).innerHTML = html; |
| 780 | | - } |
| 781 | | - |
| 782 | | - QUnit.done( { |
| 783 | | - failed: config.stats.bad, |
| 784 | | - passed: passed, |
| 785 | | - total: config.stats.all, |
| 786 | | - runtime: runtime |
| 787 | | - } ); |
| 788 | | -} |
| 789 | | - |
| 790 | | -function validTest( name ) { |
| 791 | | - var filter = config.filter, |
| 792 | | - run = false; |
| 793 | | - |
| 794 | | - if ( !filter ) { |
| 795 | | - return true; |
| 796 | | - } |
| 797 | | - |
| 798 | | - not = filter.charAt( 0 ) === "!"; |
| 799 | | - if ( not ) { |
| 800 | | - filter = filter.slice( 1 ); |
| 801 | | - } |
| 802 | | - |
| 803 | | - if ( name.indexOf( filter ) !== -1 ) { |
| 804 | | - return !not; |
| 805 | | - } |
| 806 | | - |
| 807 | | - if ( not ) { |
| 808 | | - run = true; |
| 809 | | - } |
| 810 | | - |
| 811 | | - return run; |
| 812 | | -} |
| 813 | | - |
| 814 | | -// so far supports only Firefox, Chrome and Opera (buggy) |
| 815 | | -// could be extended in the future to use something like https://github.com/csnover/TraceKit |
| 816 | | -function sourceFromStacktrace() { |
| 817 | | - try { |
| 818 | | - throw new Error(); |
| 819 | | - } catch ( e ) { |
| 820 | | - if (e.stacktrace) { |
| 821 | | - // Opera |
| 822 | | - return e.stacktrace.split("\n")[6]; |
| 823 | | - } else if (e.stack) { |
| 824 | | - // Firefox, Chrome |
| 825 | | - return e.stack.split("\n")[4]; |
| 826 | | - } |
| 827 | | - } |
| 828 | | -} |
| 829 | | - |
| 830 | | -function escapeHtml(s) { |
| 831 | | - if (!s) { |
| 832 | | - return ""; |
| 833 | | - } |
| 834 | | - s = s + ""; |
| 835 | | - return s.replace(/[\&"<>\\]/g, function(s) { |
| 836 | | - switch(s) { |
| 837 | | - case "&": return "&"; |
| 838 | | - case "\\": return "\\\\"; |
| 839 | | - case '"': return '\"'; |
| 840 | | - case "<": return "<"; |
| 841 | | - case ">": return ">"; |
| 842 | | - default: return s; |
| 843 | | - } |
| 844 | | - }); |
| 845 | | -} |
| 846 | | - |
| 847 | | -function synchronize( callback ) { |
| 848 | | - config.queue.push( callback ); |
| 849 | | - |
| 850 | | - if ( config.autorun && !config.blocking ) { |
| 851 | | - process(); |
| 852 | | - } |
| 853 | | -} |
| 854 | | - |
| 855 | | -function process() { |
| 856 | | - var start = (new Date()).getTime(); |
| 857 | | - |
| 858 | | - while ( config.queue.length && !config.blocking ) { |
| 859 | | - if ( config.updateRate <= 0 || (((new Date()).getTime() - start) < config.updateRate) ) { |
| 860 | | - config.queue.shift()(); |
| 861 | | - } else { |
| 862 | | - window.setTimeout( process, 13 ); |
| 863 | | - break; |
| 864 | | - } |
| 865 | | - } |
| 866 | | - if (!config.blocking && !config.queue.length) { |
| 867 | | - done(); |
| 868 | | - } |
| 869 | | -} |
| 870 | | - |
| 871 | | -function saveGlobal() { |
| 872 | | - config.pollution = []; |
| 873 | | - |
| 874 | | - if ( config.noglobals ) { |
| 875 | | - for ( var key in window ) { |
| 876 | | - config.pollution.push( key ); |
| 877 | | - } |
| 878 | | - } |
| 879 | | -} |
| 880 | | - |
| 881 | | -function checkPollution( name ) { |
| 882 | | - var old = config.pollution; |
| 883 | | - saveGlobal(); |
| 884 | | - |
| 885 | | - var newGlobals = diff( config.pollution, old ); |
| 886 | | - if ( newGlobals.length > 0 ) { |
| 887 | | - ok( false, "Introduced global variable(s): " + newGlobals.join(", ") ); |
| 888 | | - } |
| 889 | | - |
| 890 | | - var deletedGlobals = diff( old, config.pollution ); |
| 891 | | - if ( deletedGlobals.length > 0 ) { |
| 892 | | - ok( false, "Deleted global variable(s): " + deletedGlobals.join(", ") ); |
| 893 | | - } |
| 894 | | -} |
| 895 | | - |
| 896 | | -// returns a new Array with the elements that are in a but not in b |
| 897 | | -function diff( a, b ) { |
| 898 | | - var result = a.slice(); |
| 899 | | - for ( var i = 0; i < result.length; i++ ) { |
| 900 | | - for ( var j = 0; j < b.length; j++ ) { |
| 901 | | - if ( result[i] === b[j] ) { |
| 902 | | - result.splice(i, 1); |
| 903 | | - i--; |
| 904 | | - break; |
| 905 | | - } |
| 906 | | - } |
| 907 | | - } |
| 908 | | - return result; |
| 909 | | -} |
| 910 | | - |
| 911 | | -function fail(message, exception, callback) { |
| 912 | | - if ( typeof console !== "undefined" && console.error && console.warn ) { |
| 913 | | - console.error(message); |
| 914 | | - console.error(exception); |
| 915 | | - console.warn(callback.toString()); |
| 916 | | - |
| 917 | | - } else if ( window.opera && opera.postError ) { |
| 918 | | - opera.postError(message, exception, callback.toString); |
| 919 | | - } |
| 920 | | -} |
| 921 | | - |
| 922 | | -function extend(a, b) { |
| 923 | | - for ( var prop in b ) { |
| 924 | | - if ( b[prop] === undefined ) { |
| 925 | | - delete a[prop]; |
| 926 | | - } else { |
| 927 | | - a[prop] = b[prop]; |
| 928 | | - } |
| 929 | | - } |
| 930 | | - |
| 931 | | - return a; |
| 932 | | -} |
| 933 | | - |
| 934 | | -function addEvent(elem, type, fn) { |
| 935 | | - if ( elem.addEventListener ) { |
| 936 | | - elem.addEventListener( type, fn, false ); |
| 937 | | - } else if ( elem.attachEvent ) { |
| 938 | | - elem.attachEvent( "on" + type, fn ); |
| 939 | | - } else { |
| 940 | | - fn(); |
| 941 | | - } |
| 942 | | -} |
| 943 | | - |
| 944 | | -function id(name) { |
| 945 | | - return !!(typeof document !== "undefined" && document && document.getElementById) && |
| 946 | | - document.getElementById( name ); |
| 947 | | -} |
| 948 | | - |
| 949 | | -// Test for equality any JavaScript type. |
| 950 | | -// Discussions and reference: http://philrathe.com/articles/equiv |
| 951 | | -// Test suites: http://philrathe.com/tests/equiv |
| 952 | | -// Author: Philippe Rathé <prathe@gmail.com> |
| 953 | | -QUnit.equiv = function () { |
| 954 | | - |
| 955 | | - var innerEquiv; // the real equiv function |
| 956 | | - var callers = []; // stack to decide between skip/abort functions |
| 957 | | - var parents = []; // stack to avoiding loops from circular referencing |
| 958 | | - |
| 959 | | - // Call the o related callback with the given arguments. |
| 960 | | - function bindCallbacks(o, callbacks, args) { |
| 961 | | - var prop = QUnit.objectType(o); |
| 962 | | - if (prop) { |
| 963 | | - if (QUnit.objectType(callbacks[prop]) === "function") { |
| 964 | | - return callbacks[prop].apply(callbacks, args); |
| 965 | | - } else { |
| 966 | | - return callbacks[prop]; // or undefined |
| 967 | | - } |
| 968 | | - } |
| 969 | | - } |
| 970 | | - |
| 971 | | - var callbacks = function () { |
| 972 | | - |
| 973 | | - // for string, boolean, number and null |
| 974 | | - function useStrictEquality(b, a) { |
| 975 | | - if (b instanceof a.constructor || a instanceof b.constructor) { |
| 976 | | - // to catch short annotaion VS 'new' annotation of a declaration |
| 977 | | - // e.g. var i = 1; |
| 978 | | - // var j = new Number(1); |
| 979 | | - return a == b; |
| 980 | | - } else { |
| 981 | | - return a === b; |
| 982 | | - } |
| 983 | | - } |
| 984 | | - |
| 985 | | - return { |
| 986 | | - "string": useStrictEquality, |
| 987 | | - "boolean": useStrictEquality, |
| 988 | | - "number": useStrictEquality, |
| 989 | | - "null": useStrictEquality, |
| 990 | | - "undefined": useStrictEquality, |
| 991 | | - |
| 992 | | - "nan": function (b) { |
| 993 | | - return isNaN(b); |
| 994 | | - }, |
| 995 | | - |
| 996 | | - "date": function (b, a) { |
| 997 | | - return QUnit.objectType(b) === "date" && a.valueOf() === b.valueOf(); |
| 998 | | - }, |
| 999 | | - |
| 1000 | | - "regexp": function (b, a) { |
| 1001 | | - return QUnit.objectType(b) === "regexp" && |
| 1002 | | - a.source === b.source && // the regex itself |
| 1003 | | - a.global === b.global && // and its modifers (gmi) ... |
| 1004 | | - a.ignoreCase === b.ignoreCase && |
| 1005 | | - a.multiline === b.multiline; |
| 1006 | | - }, |
| 1007 | | - |
| 1008 | | - // - skip when the property is a method of an instance (OOP) |
| 1009 | | - // - abort otherwise, |
| 1010 | | - // initial === would have catch identical references anyway |
| 1011 | | - "function": function () { |
| 1012 | | - var caller = callers[callers.length - 1]; |
| 1013 | | - return caller !== Object && |
| 1014 | | - typeof caller !== "undefined"; |
| 1015 | | - }, |
| 1016 | | - |
| 1017 | | - "array": function (b, a) { |
| 1018 | | - var i, j, loop; |
| 1019 | | - var len; |
| 1020 | | - |
| 1021 | | - // b could be an object literal here |
| 1022 | | - if ( ! (QUnit.objectType(b) === "array")) { |
| 1023 | | - return false; |
| 1024 | | - } |
| 1025 | | - |
| 1026 | | - len = a.length; |
| 1027 | | - if (len !== b.length) { // safe and faster |
| 1028 | | - return false; |
| 1029 | | - } |
| 1030 | | - |
| 1031 | | - //track reference to avoid circular references |
| 1032 | | - parents.push(a); |
| 1033 | | - for (i = 0; i < len; i++) { |
| 1034 | | - loop = false; |
| 1035 | | - for(j=0;j<parents.length;j++){ |
| 1036 | | - if(parents[j] === a[i]){ |
| 1037 | | - loop = true;//dont rewalk array |
| 1038 | | - } |
| 1039 | | - } |
| 1040 | | - if (!loop && ! innerEquiv(a[i], b[i])) { |
| 1041 | | - parents.pop(); |
| 1042 | | - return false; |
| 1043 | | - } |
| 1044 | | - } |
| 1045 | | - parents.pop(); |
| 1046 | | - return true; |
| 1047 | | - }, |
| 1048 | | - |
| 1049 | | - "object": function (b, a) { |
| 1050 | | - var i, j, loop; |
| 1051 | | - var eq = true; // unless we can proove it |
| 1052 | | - var aProperties = [], bProperties = []; // collection of strings |
| 1053 | | - |
| 1054 | | - // comparing constructors is more strict than using instanceof |
| 1055 | | - if ( a.constructor !== b.constructor) { |
| 1056 | | - return false; |
| 1057 | | - } |
| 1058 | | - |
| 1059 | | - // stack constructor before traversing properties |
| 1060 | | - callers.push(a.constructor); |
| 1061 | | - //track reference to avoid circular references |
| 1062 | | - parents.push(a); |
| 1063 | | - |
| 1064 | | - for (i in a) { // be strict: don't ensures hasOwnProperty and go deep |
| 1065 | | - loop = false; |
| 1066 | | - for(j=0;j<parents.length;j++){ |
| 1067 | | - if(parents[j] === a[i]) |
| 1068 | | - loop = true; //don't go down the same path twice |
| 1069 | | - } |
| 1070 | | - aProperties.push(i); // collect a's properties |
| 1071 | | - |
| 1072 | | - if (!loop && ! innerEquiv(a[i], b[i])) { |
| 1073 | | - eq = false; |
| 1074 | | - break; |
| 1075 | | - } |
| 1076 | | - } |
| 1077 | | - |
| 1078 | | - callers.pop(); // unstack, we are done |
| 1079 | | - parents.pop(); |
| 1080 | | - |
| 1081 | | - for (i in b) { |
| 1082 | | - bProperties.push(i); // collect b's properties |
| 1083 | | - } |
| 1084 | | - |
| 1085 | | - // Ensures identical properties name |
| 1086 | | - return eq && innerEquiv(aProperties.sort(), bProperties.sort()); |
| 1087 | | - } |
| 1088 | | - }; |
| 1089 | | - }(); |
| 1090 | | - |
| 1091 | | - innerEquiv = function () { // can take multiple arguments |
| 1092 | | - var args = Array.prototype.slice.apply(arguments); |
| 1093 | | - if (args.length < 2) { |
| 1094 | | - return true; // end transition |
| 1095 | | - } |
| 1096 | | - |
| 1097 | | - return (function (a, b) { |
| 1098 | | - if (a === b) { |
| 1099 | | - return true; // catch the most you can |
| 1100 | | - } else if (a === null || b === null || typeof a === "undefined" || typeof b === "undefined" || QUnit.objectType(a) !== QUnit.objectType(b)) { |
| 1101 | | - return false; // don't lose time with error prone cases |
| 1102 | | - } else { |
| 1103 | | - return bindCallbacks(a, callbacks, [b, a]); |
| 1104 | | - } |
| 1105 | | - |
| 1106 | | - // apply transition with (1..n) arguments |
| 1107 | | - })(args[0], args[1]) && arguments.callee.apply(this, args.splice(1, args.length -1)); |
| 1108 | | - }; |
| 1109 | | - |
| 1110 | | - return innerEquiv; |
| 1111 | | - |
| 1112 | | -}(); |
| 1113 | | - |
| 1114 | | -/** |
| 1115 | | - * jsDump |
| 1116 | | - * Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com | http://flesler.blogspot.com |
| 1117 | | - * Licensed under BSD (http://www.opensource.org/licenses/bsd-license.php) |
| 1118 | | - * Date: 5/15/2008 |
| 1119 | | - * @projectDescription Advanced and extensible data dumping for Javascript. |
| 1120 | | - * @version 1.0.0 |
| 1121 | | - * @author Ariel Flesler |
| 1122 | | - * @link {http://flesler.blogspot.com/2008/05/jsdump-pretty-dump-of-any-javascript.html} |
| 1123 | | - */ |
| 1124 | | -QUnit.jsDump = (function() { |
| 1125 | | - function quote( str ) { |
| 1126 | | - return '"' + str.toString().replace(/"/g, '\\"') + '"'; |
| 1127 | | - }; |
| 1128 | | - function literal( o ) { |
| 1129 | | - return o + ''; |
| 1130 | | - }; |
| 1131 | | - function join( pre, arr, post ) { |
| 1132 | | - var s = jsDump.separator(), |
| 1133 | | - base = jsDump.indent(), |
| 1134 | | - inner = jsDump.indent(1); |
| 1135 | | - if ( arr.join ) |
| 1136 | | - arr = arr.join( ',' + s + inner ); |
| 1137 | | - if ( !arr ) |
| 1138 | | - return pre + post; |
| 1139 | | - return [ pre, inner + arr, base + post ].join(s); |
| 1140 | | - }; |
| 1141 | | - function array( arr ) { |
| 1142 | | - var i = arr.length, ret = Array(i); |
| 1143 | | - this.up(); |
| 1144 | | - while ( i-- ) |
| 1145 | | - ret[i] = this.parse( arr[i] ); |
| 1146 | | - this.down(); |
| 1147 | | - return join( '[', ret, ']' ); |
| 1148 | | - }; |
| 1149 | | - |
| 1150 | | - var reName = /^function (\w+)/; |
| 1151 | | - |
| 1152 | | - var jsDump = { |
| 1153 | | - parse:function( obj, type ) { //type is used mostly internally, you can fix a (custom)type in advance |
| 1154 | | - var parser = this.parsers[ type || this.typeOf(obj) ]; |
| 1155 | | - type = typeof parser; |
| 1156 | | - |
| 1157 | | - return type == 'function' ? parser.call( this, obj ) : |
| 1158 | | - type == 'string' ? parser : |
| 1159 | | - this.parsers.error; |
| 1160 | | - }, |
| 1161 | | - typeOf:function( obj ) { |
| 1162 | | - var type; |
| 1163 | | - if ( obj === null ) { |
| 1164 | | - type = "null"; |
| 1165 | | - } else if (typeof obj === "undefined") { |
| 1166 | | - type = "undefined"; |
| 1167 | | - } else if (QUnit.is("RegExp", obj)) { |
| 1168 | | - type = "regexp"; |
| 1169 | | - } else if (QUnit.is("Date", obj)) { |
| 1170 | | - type = "date"; |
| 1171 | | - } else if (QUnit.is("Function", obj)) { |
| 1172 | | - type = "function"; |
| 1173 | | - } else if (typeof obj.setInterval !== undefined && typeof obj.document !== "undefined" && typeof obj.nodeType === "undefined") { |
| 1174 | | - type = "window"; |
| 1175 | | - } else if (obj.nodeType === 9) { |
| 1176 | | - type = "document"; |
| 1177 | | - } else if (obj.nodeType) { |
| 1178 | | - type = "node"; |
| 1179 | | - } else if (typeof obj === "object" && typeof obj.length === "number" && obj.length >= 0) { |
| 1180 | | - type = "array"; |
| 1181 | | - } else { |
| 1182 | | - type = typeof obj; |
| 1183 | | - } |
| 1184 | | - return type; |
| 1185 | | - }, |
| 1186 | | - separator:function() { |
| 1187 | | - return this.multiline ? this.HTML ? '<br />' : '\n' : this.HTML ? ' ' : ' '; |
| 1188 | | - }, |
| 1189 | | - indent:function( extra ) {// extra can be a number, shortcut for increasing-calling-decreasing |
| 1190 | | - if ( !this.multiline ) |
| 1191 | | - return ''; |
| 1192 | | - var chr = this.indentChar; |
| 1193 | | - if ( this.HTML ) |
| 1194 | | - chr = chr.replace(/\t/g,' ').replace(/ /g,' '); |
| 1195 | | - return Array( this._depth_ + (extra||0) ).join(chr); |
| 1196 | | - }, |
| 1197 | | - up:function( a ) { |
| 1198 | | - this._depth_ += a || 1; |
| 1199 | | - }, |
| 1200 | | - down:function( a ) { |
| 1201 | | - this._depth_ -= a || 1; |
| 1202 | | - }, |
| 1203 | | - setParser:function( name, parser ) { |
| 1204 | | - this.parsers[name] = parser; |
| 1205 | | - }, |
| 1206 | | - // The next 3 are exposed so you can use them |
| 1207 | | - quote:quote, |
| 1208 | | - literal:literal, |
| 1209 | | - join:join, |
| 1210 | | - // |
| 1211 | | - _depth_: 1, |
| 1212 | | - // This is the list of parsers, to modify them, use jsDump.setParser |
| 1213 | | - parsers:{ |
| 1214 | | - window: '[Window]', |
| 1215 | | - document: '[Document]', |
| 1216 | | - error:'[ERROR]', //when no parser is found, shouldn't happen |
| 1217 | | - unknown: '[Unknown]', |
| 1218 | | - 'null':'null', |
| 1219 | | - 'undefined':'undefined', |
| 1220 | | - 'function':function( fn ) { |
| 1221 | | - var ret = 'function', |
| 1222 | | - name = 'name' in fn ? fn.name : (reName.exec(fn)||[])[1];//functions never have name in IE |
| 1223 | | - if ( name ) |
| 1224 | | - ret += ' ' + name; |
| 1225 | | - ret += '('; |
| 1226 | | - |
| 1227 | | - ret = [ ret, QUnit.jsDump.parse( fn, 'functionArgs' ), '){'].join(''); |
| 1228 | | - return join( ret, QUnit.jsDump.parse(fn,'functionCode'), '}' ); |
| 1229 | | - }, |
| 1230 | | - array: array, |
| 1231 | | - nodelist: array, |
| 1232 | | - arguments: array, |
| 1233 | | - object:function( map ) { |
| 1234 | | - var ret = [ ]; |
| 1235 | | - QUnit.jsDump.up(); |
| 1236 | | - for ( var key in map ) |
| 1237 | | - ret.push( QUnit.jsDump.parse(key,'key') + ': ' + QUnit.jsDump.parse(map[key]) ); |
| 1238 | | - QUnit.jsDump.down(); |
| 1239 | | - return join( '{', ret, '}' ); |
| 1240 | | - }, |
| 1241 | | - node:function( node ) { |
| 1242 | | - var open = QUnit.jsDump.HTML ? '<' : '<', |
| 1243 | | - close = QUnit.jsDump.HTML ? '>' : '>'; |
| 1244 | | - |
| 1245 | | - var tag = node.nodeName.toLowerCase(), |
| 1246 | | - ret = open + tag; |
| 1247 | | - |
| 1248 | | - for ( var a in QUnit.jsDump.DOMAttrs ) { |
| 1249 | | - var val = node[QUnit.jsDump.DOMAttrs[a]]; |
| 1250 | | - if ( val ) |
| 1251 | | - ret += ' ' + a + '=' + QUnit.jsDump.parse( val, 'attribute' ); |
| 1252 | | - } |
| 1253 | | - return ret + close + open + '/' + tag + close; |
| 1254 | | - }, |
| 1255 | | - functionArgs:function( fn ) {//function calls it internally, it's the arguments part of the function |
| 1256 | | - var l = fn.length; |
| 1257 | | - if ( !l ) return ''; |
| 1258 | | - |
| 1259 | | - var args = Array(l); |
| 1260 | | - while ( l-- ) |
| 1261 | | - args[l] = String.fromCharCode(97+l);//97 is 'a' |
| 1262 | | - return ' ' + args.join(', ') + ' '; |
| 1263 | | - }, |
| 1264 | | - key:quote, //object calls it internally, the key part of an item in a map |
| 1265 | | - functionCode:'[code]', //function calls it internally, it's the content of the function |
| 1266 | | - attribute:quote, //node calls it internally, it's an html attribute value |
| 1267 | | - string:quote, |
| 1268 | | - date:quote, |
| 1269 | | - regexp:literal, //regex |
| 1270 | | - number:literal, |
| 1271 | | - 'boolean':literal |
| 1272 | | - }, |
| 1273 | | - DOMAttrs:{//attributes to dump from nodes, name=>realName |
| 1274 | | - id:'id', |
| 1275 | | - name:'name', |
| 1276 | | - 'class':'className' |
| 1277 | | - }, |
| 1278 | | - HTML:false,//if true, entities are escaped ( <, >, \t, space and \n ) |
| 1279 | | - indentChar:' ',//indentation unit |
| 1280 | | - multiline:true //if true, items in a collection, are separated by a \n, else just a space. |
| 1281 | | - }; |
| 1282 | | - |
| 1283 | | - return jsDump; |
| 1284 | | -})(); |
| 1285 | | - |
| 1286 | | -// from Sizzle.js |
| 1287 | | -function getText( elems ) { |
| 1288 | | - var ret = "", elem; |
| 1289 | | - |
| 1290 | | - for ( var i = 0; elems[i]; i++ ) { |
| 1291 | | - elem = elems[i]; |
| 1292 | | - |
| 1293 | | - // Get the text from text nodes and CDATA nodes |
| 1294 | | - if ( elem.nodeType === 3 || elem.nodeType === 4 ) { |
| 1295 | | - ret += elem.nodeValue; |
| 1296 | | - |
| 1297 | | - // Traverse everything else, except comment nodes |
| 1298 | | - } else if ( elem.nodeType !== 8 ) { |
| 1299 | | - ret += getText( elem.childNodes ); |
| 1300 | | - } |
| 1301 | | - } |
| 1302 | | - |
| 1303 | | - return ret; |
| 1304 | | -}; |
| 1305 | | - |
| 1306 | | -/* |
| 1307 | | - * Javascript Diff Algorithm |
| 1308 | | - * By John Resig (http://ejohn.org/) |
| 1309 | | - * Modified by Chu Alan "sprite" |
| 1310 | | - * |
| 1311 | | - * Released under the MIT license. |
| 1312 | | - * |
| 1313 | | - * More Info: |
| 1314 | | - * http://ejohn.org/projects/javascript-diff-algorithm/ |
| 1315 | | - * |
| 1316 | | - * Usage: QUnit.diff(expected, actual) |
| 1317 | | - * |
| 1318 | | - * QUnit.diff("the quick brown fox jumped over", "the quick fox jumps over") == "the quick <del>brown </del> fox <del>jumped </del><ins>jumps </ins> over" |
| 1319 | | - */ |
| 1320 | | -QUnit.diff = (function() { |
| 1321 | | - function diff(o, n){ |
| 1322 | | - var ns = new Object(); |
| 1323 | | - var os = new Object(); |
| 1324 | | - |
| 1325 | | - for (var i = 0; i < n.length; i++) { |
| 1326 | | - if (ns[n[i]] == null) |
| 1327 | | - ns[n[i]] = { |
| 1328 | | - rows: new Array(), |
| 1329 | | - o: null |
| 1330 | | - }; |
| 1331 | | - ns[n[i]].rows.push(i); |
| 1332 | | - } |
| 1333 | | - |
| 1334 | | - for (var i = 0; i < o.length; i++) { |
| 1335 | | - if (os[o[i]] == null) |
| 1336 | | - os[o[i]] = { |
| 1337 | | - rows: new Array(), |
| 1338 | | - n: null |
| 1339 | | - }; |
| 1340 | | - os[o[i]].rows.push(i); |
| 1341 | | - } |
| 1342 | | - |
| 1343 | | - for (var i in ns) { |
| 1344 | | - if (ns[i].rows.length == 1 && typeof(os[i]) != "undefined" && os[i].rows.length == 1) { |
| 1345 | | - n[ns[i].rows[0]] = { |
| 1346 | | - text: n[ns[i].rows[0]], |
| 1347 | | - row: os[i].rows[0] |
| 1348 | | - }; |
| 1349 | | - o[os[i].rows[0]] = { |
| 1350 | | - text: o[os[i].rows[0]], |
| 1351 | | - row: ns[i].rows[0] |
| 1352 | | - }; |
| 1353 | | - } |
| 1354 | | - } |
| 1355 | | - |
| 1356 | | - for (var i = 0; i < n.length - 1; i++) { |
| 1357 | | - if (n[i].text != null && n[i + 1].text == null && n[i].row + 1 < o.length && o[n[i].row + 1].text == null && |
| 1358 | | - n[i + 1] == o[n[i].row + 1]) { |
| 1359 | | - n[i + 1] = { |
| 1360 | | - text: n[i + 1], |
| 1361 | | - row: n[i].row + 1 |
| 1362 | | - }; |
| 1363 | | - o[n[i].row + 1] = { |
| 1364 | | - text: o[n[i].row + 1], |
| 1365 | | - row: i + 1 |
| 1366 | | - }; |
| 1367 | | - } |
| 1368 | | - } |
| 1369 | | - |
| 1370 | | - for (var i = n.length - 1; i > 0; i--) { |
| 1371 | | - if (n[i].text != null && n[i - 1].text == null && n[i].row > 0 && o[n[i].row - 1].text == null && |
| 1372 | | - n[i - 1] == o[n[i].row - 1]) { |
| 1373 | | - n[i - 1] = { |
| 1374 | | - text: n[i - 1], |
| 1375 | | - row: n[i].row - 1 |
| 1376 | | - }; |
| 1377 | | - o[n[i].row - 1] = { |
| 1378 | | - text: o[n[i].row - 1], |
| 1379 | | - row: i - 1 |
| 1380 | | - }; |
| 1381 | | - } |
| 1382 | | - } |
| 1383 | | - |
| 1384 | | - return { |
| 1385 | | - o: o, |
| 1386 | | - n: n |
| 1387 | | - }; |
| 1388 | | - } |
| 1389 | | - |
| 1390 | | - return function(o, n){ |
| 1391 | | - o = o.replace(/\s+$/, ''); |
| 1392 | | - n = n.replace(/\s+$/, ''); |
| 1393 | | - var out = diff(o == "" ? [] : o.split(/\s+/), n == "" ? [] : n.split(/\s+/)); |
| 1394 | | - |
| 1395 | | - var str = ""; |
| 1396 | | - |
| 1397 | | - var oSpace = o.match(/\s+/g); |
| 1398 | | - if (oSpace == null) { |
| 1399 | | - oSpace = [" "]; |
| 1400 | | - } |
| 1401 | | - else { |
| 1402 | | - oSpace.push(" "); |
| 1403 | | - } |
| 1404 | | - var nSpace = n.match(/\s+/g); |
| 1405 | | - if (nSpace == null) { |
| 1406 | | - nSpace = [" "]; |
| 1407 | | - } |
| 1408 | | - else { |
| 1409 | | - nSpace.push(" "); |
| 1410 | | - } |
| 1411 | | - |
| 1412 | | - if (out.n.length == 0) { |
| 1413 | | - for (var i = 0; i < out.o.length; i++) { |
| 1414 | | - str += '<del>' + out.o[i] + oSpace[i] + "</del>"; |
| 1415 | | - } |
| 1416 | | - } |
| 1417 | | - else { |
| 1418 | | - if (out.n[0].text == null) { |
| 1419 | | - for (n = 0; n < out.o.length && out.o[n].text == null; n++) { |
| 1420 | | - str += '<del>' + out.o[n] + oSpace[n] + "</del>"; |
| 1421 | | - } |
| 1422 | | - } |
| 1423 | | - |
| 1424 | | - for (var i = 0; i < out.n.length; i++) { |
| 1425 | | - if (out.n[i].text == null) { |
| 1426 | | - str += '<ins>' + out.n[i] + nSpace[i] + "</ins>"; |
| 1427 | | - } |
| 1428 | | - else { |
| 1429 | | - var pre = ""; |
| 1430 | | - |
| 1431 | | - for (n = out.n[i].row + 1; n < out.o.length && out.o[n].text == null; n++) { |
| 1432 | | - pre += '<del>' + out.o[n] + oSpace[n] + "</del>"; |
| 1433 | | - } |
| 1434 | | - str += " " + out.n[i].text + nSpace[i] + pre; |
| 1435 | | - } |
| 1436 | | - } |
| 1437 | | - } |
| 1438 | | - |
| 1439 | | - return str; |
| 1440 | | - }; |
| 1441 | | -})(); |
| 1442 | | - |
| 1443 | | -})(this); |
| \ No newline at end of file |
| Index: trunk/phase3/resources/jquery/jquery.qunit.css |
| — | — | @@ -1,225 +0,0 @@ |
| 2 | | -/** |
| 3 | | - * QUnit - A JavaScript Unit Testing Framework |
| 4 | | - * |
| 5 | | - * http://docs.jquery.com/QUnit |
| 6 | | - * |
| 7 | | - * Copyright (c) 2011 John Resig, Jörn Zaefferer |
| 8 | | - * Dual licensed under the MIT (MIT-LICENSE.txt) |
| 9 | | - * or GPL (GPL-LICENSE.txt) licenses. |
| 10 | | - */ |
| 11 | | - |
| 12 | | -/** Font Family and Sizes */ |
| 13 | | - |
| 14 | | -#qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult { |
| 15 | | - font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial; |
| 16 | | -} |
| 17 | | - |
| 18 | | -#qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; } |
| 19 | | -#qunit-tests { font-size: smaller; } |
| 20 | | - |
| 21 | | - |
| 22 | | -/** Resets */ |
| 23 | | - |
| 24 | | -#qunit-tests, #qunit-tests ol, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult { |
| 25 | | - margin: 0; |
| 26 | | - padding: 0; |
| 27 | | -} |
| 28 | | - |
| 29 | | - |
| 30 | | -/** Header */ |
| 31 | | - |
| 32 | | -#qunit-header { |
| 33 | | - padding: 0.5em 0 0.5em 1em; |
| 34 | | - |
| 35 | | - color: #8699a4; |
| 36 | | - background-color: #0d3349; |
| 37 | | - |
| 38 | | - font-size: 1.5em; |
| 39 | | - line-height: 1em; |
| 40 | | - font-weight: normal; |
| 41 | | - |
| 42 | | - border-radius: 15px 15px 0 0; |
| 43 | | - -moz-border-radius: 15px 15px 0 0; |
| 44 | | - -webkit-border-top-right-radius: 15px; |
| 45 | | - -webkit-border-top-left-radius: 15px; |
| 46 | | -} |
| 47 | | - |
| 48 | | -#qunit-header a { |
| 49 | | - text-decoration: none; |
| 50 | | - color: #c2ccd1; |
| 51 | | -} |
| 52 | | - |
| 53 | | -#qunit-header a:hover, |
| 54 | | -#qunit-header a:focus { |
| 55 | | - color: #fff; |
| 56 | | -} |
| 57 | | - |
| 58 | | -#qunit-banner { |
| 59 | | - height: 5px; |
| 60 | | -} |
| 61 | | - |
| 62 | | -#qunit-testrunner-toolbar { |
| 63 | | - padding: 0.5em 0 0.5em 2em; |
| 64 | | - color: #5E740B; |
| 65 | | - background-color: #eee; |
| 66 | | -} |
| 67 | | - |
| 68 | | -#qunit-userAgent { |
| 69 | | - padding: 0.5em 0 0.5em 2.5em; |
| 70 | | - background-color: #2b81af; |
| 71 | | - color: #fff; |
| 72 | | - text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px; |
| 73 | | -} |
| 74 | | - |
| 75 | | - |
| 76 | | -/** Tests: Pass/Fail */ |
| 77 | | - |
| 78 | | -#qunit-tests { |
| 79 | | - list-style-position: inside; |
| 80 | | -} |
| 81 | | - |
| 82 | | -#qunit-tests li { |
| 83 | | - padding: 0.4em 0.5em 0.4em 2.5em; |
| 84 | | - border-bottom: 1px solid #fff; |
| 85 | | - list-style-position: inside; |
| 86 | | -} |
| 87 | | - |
| 88 | | -#qunit-tests.hidepass li.pass, #qunit-tests.hidepass li.running { |
| 89 | | - display: none; |
| 90 | | -} |
| 91 | | - |
| 92 | | -#qunit-tests li strong { |
| 93 | | - cursor: pointer; |
| 94 | | -} |
| 95 | | - |
| 96 | | -#qunit-tests li a { |
| 97 | | - padding: 0.5em; |
| 98 | | - color: #c2ccd1; |
| 99 | | - text-decoration: none; |
| 100 | | -} |
| 101 | | -#qunit-tests li a:hover, |
| 102 | | -#qunit-tests li a:focus { |
| 103 | | - color: #000; |
| 104 | | -} |
| 105 | | - |
| 106 | | -#qunit-tests ol { |
| 107 | | - margin-top: 0.5em; |
| 108 | | - padding: 0.5em; |
| 109 | | - |
| 110 | | - background-color: #fff; |
| 111 | | - |
| 112 | | - border-radius: 15px; |
| 113 | | - -moz-border-radius: 15px; |
| 114 | | - -webkit-border-radius: 15px; |
| 115 | | - |
| 116 | | - box-shadow: inset 0px 2px 13px #999; |
| 117 | | - -moz-box-shadow: inset 0px 2px 13px #999; |
| 118 | | - -webkit-box-shadow: inset 0px 2px 13px #999; |
| 119 | | -} |
| 120 | | - |
| 121 | | -#qunit-tests table { |
| 122 | | - border-collapse: collapse; |
| 123 | | - margin-top: .2em; |
| 124 | | -} |
| 125 | | - |
| 126 | | -#qunit-tests th { |
| 127 | | - text-align: right; |
| 128 | | - vertical-align: top; |
| 129 | | - padding: 0 .5em 0 0; |
| 130 | | -} |
| 131 | | - |
| 132 | | -#qunit-tests td { |
| 133 | | - vertical-align: top; |
| 134 | | -} |
| 135 | | - |
| 136 | | -#qunit-tests pre { |
| 137 | | - margin: 0; |
| 138 | | - white-space: pre-wrap; |
| 139 | | - word-wrap: break-word; |
| 140 | | -} |
| 141 | | - |
| 142 | | -#qunit-tests del { |
| 143 | | - background-color: #e0f2be; |
| 144 | | - color: #374e0c; |
| 145 | | - text-decoration: none; |
| 146 | | -} |
| 147 | | - |
| 148 | | -#qunit-tests ins { |
| 149 | | - background-color: #ffcaca; |
| 150 | | - color: #500; |
| 151 | | - text-decoration: none; |
| 152 | | -} |
| 153 | | - |
| 154 | | -/*** Test Counts */ |
| 155 | | - |
| 156 | | -#qunit-tests b.counts { color: black; } |
| 157 | | -#qunit-tests b.passed { color: #5E740B; } |
| 158 | | -#qunit-tests b.failed { color: #710909; } |
| 159 | | - |
| 160 | | -#qunit-tests li li { |
| 161 | | - margin: 0.5em; |
| 162 | | - padding: 0.4em 0.5em 0.4em 0.5em; |
| 163 | | - background-color: #fff; |
| 164 | | - border-bottom: none; |
| 165 | | - list-style-position: inside; |
| 166 | | -} |
| 167 | | - |
| 168 | | -/*** Passing Styles */ |
| 169 | | - |
| 170 | | -#qunit-tests li li.pass { |
| 171 | | - color: #5E740B; |
| 172 | | - background-color: #fff; |
| 173 | | - border-left: 26px solid #C6E746; |
| 174 | | -} |
| 175 | | - |
| 176 | | -#qunit-tests .pass { color: #528CE0; background-color: #D2E0E6; } |
| 177 | | -#qunit-tests .pass .test-name { color: #366097; } |
| 178 | | - |
| 179 | | -#qunit-tests .pass .test-actual, |
| 180 | | -#qunit-tests .pass .test-expected { color: #999999; } |
| 181 | | - |
| 182 | | -#qunit-banner.qunit-pass { background-color: #C6E746; } |
| 183 | | - |
| 184 | | -/*** Failing Styles */ |
| 185 | | - |
| 186 | | -#qunit-tests li li.fail { |
| 187 | | - color: #710909; |
| 188 | | - background-color: #fff; |
| 189 | | - border-left: 26px solid #EE5757; |
| 190 | | -} |
| 191 | | - |
| 192 | | -#qunit-tests > li:last-child { |
| 193 | | - border-radius: 0 0 15px 15px; |
| 194 | | - -moz-border-radius: 0 0 15px 15px; |
| 195 | | - -webkit-border-bottom-right-radius: 15px; |
| 196 | | - -webkit-border-bottom-left-radius: 15px; |
| 197 | | -} |
| 198 | | - |
| 199 | | -#qunit-tests .fail { color: #000000; background-color: #EE5757; } |
| 200 | | -#qunit-tests .fail .test-name, |
| 201 | | -#qunit-tests .fail .module-name { color: #000000; } |
| 202 | | - |
| 203 | | -#qunit-tests .fail .test-actual { color: #EE5757; } |
| 204 | | -#qunit-tests .fail .test-expected { color: green; } |
| 205 | | - |
| 206 | | -#qunit-banner.qunit-fail { background-color: #EE5757; } |
| 207 | | - |
| 208 | | - |
| 209 | | -/** Result */ |
| 210 | | - |
| 211 | | -#qunit-testresult { |
| 212 | | - padding: 0.5em 0.5em 0.5em 2.5em; |
| 213 | | - |
| 214 | | - color: #2b81af; |
| 215 | | - background-color: #D2E0E6; |
| 216 | | - |
| 217 | | - border-bottom: 1px solid white; |
| 218 | | -} |
| 219 | | - |
| 220 | | -/** Fixture */ |
| 221 | | - |
| 222 | | -#qunit-fixture { |
| 223 | | - position: absolute; |
| 224 | | - top: -10000px; |
| 225 | | - left: -10000px; |
| 226 | | -} |
| \ No newline at end of file |
| Index: trunk/phase3/resources/jquery/jquery.messageBox.js |
| — | — | @@ -35,9 +35,6 @@ |
| 36 | 36 | 'display': 'none' |
| 37 | 37 | } |
| 38 | 38 | }); |
| 39 | | - if ( $( options.parent ).length < 1 ) { |
| 40 | | - options.parent = 'body'; |
| 41 | | - } |
| 42 | 39 | if ( options.insert === 'append' ) { |
| 43 | 40 | $newBox.appendTo( options.parent ); |
| 44 | 41 | return $newBox; |
| Index: trunk/phase3/resources/Resources.php |
| — | — | @@ -132,10 +132,6 @@ |
| 133 | 133 | 'styles' => 'resources/jquery/jquery.makeCollapsible.css', |
| 134 | 134 | 'messages' => array( 'collapsible-expand', 'collapsible-collapse' ), |
| 135 | 135 | ), |
| 136 | | - 'jquery.qunit' => array( |
| 137 | | - 'scripts' => 'resources/jquery/jquery.qunit.js', |
| 138 | | - 'styles' => 'resources/jquery/jquery.qunit.css', |
| 139 | | - ), |
| 140 | 136 | 'jquery.suggestions' => array( |
| 141 | 137 | 'scripts' => 'resources/jquery/jquery.suggestions.js', |
| 142 | 138 | 'styles' => 'resources/jquery/jquery.suggestions.css', |
| Index: trunk/phase3/resources/mediawiki/mediawiki.js |
| — | — | @@ -186,13 +186,10 @@ |
| 187 | 187 | if ( typeof selection === 'object' ) { |
| 188 | 188 | for ( var s in selection ) { |
| 189 | 189 | this.values[s] = selection[s]; |
| 190 | | - return true; |
| 191 | 190 | } |
| 192 | 191 | } else if ( typeof selection === 'string' && typeof value !== 'undefined' ) { |
| 193 | 192 | this.values[selection] = value; |
| 194 | | - return true; |
| 195 | 193 | } |
| 196 | | - return false; |
| 197 | 194 | }; |
| 198 | 195 | |
| 199 | 196 | /** |