← Back to branch summary

~launchpad-pqm/launchpad/devel

« back to all changes in this revision

Viewing changes to lib/lp/app/javascript/lazr/testing/jsUnitMockTimeout.js

  • Committer: Launchpad Patch Queue Manager
  • Date: 2011-07-08 03:08:43 UTC
  • mfrom: (13314.10.11 lazr-js-tests)
  • Revision ID: launchpad@pqm.canonical.com-20110708030843-lmw3ba9pva8bcdyy
[r=allenap][bug=806956] Refactor the lazr-js javascript tests so they
 are run as part of the Launchpad YUI test layer.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/lp/app/javascript/lazr/testing/jsUnitMockTimeout.js
1
 
/*
2
 
    Version: MPL 1.1/GPL 2.0/LGPL 2.1
3
 
 
4
 
    The contents of this file are subject to the Mozilla Public License Version
5
 
    1.1 (the "License"); you may not use this file except in compliance with
6
 
    the License. You may obtain a copy of the License at
7
 
    http://www.mozilla.org/MPL/
8
 
 
9
 
    Software distributed under the License is distributed on an "AS IS" basis,
10
 
    WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
11
 
    for the specific language governing rights and limitations under the
12
 
    License.
13
 
 
14
 
    The Original Code is Edward Hieatt code.
15
 
 
16
 
    The Initial Developer of the Original Code is
17
 
    Edward Hieatt, edward@jsunit.net.
18
 
    Portions created by the Initial Developer are Copyright (C) 2003
19
 
    the Initial Developer. All Rights Reserved.
20
 
 
21
 
    Author Edward Hieatt, edward@jsunit.net
22
 
 
23
 
    Alternatively, the contents of this file may be used under the terms of
24
 
    either the GNU General Public License Version 2 or later (the "GPL"), or
25
 
    the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
26
 
    in which case the provisions of the GPL or the LGPL are applicable instead
27
 
    of those above. If you wish to allow use of your version of this file only
28
 
    under the terms of either the GPL or the LGPL, and not to allow others to
29
 
    use your version of this file under the terms of the MPL, indicate your
30
 
    decision by deleting the provisions above and replace them with the notice
31
 
    and other provisions required by the LGPL or the GPL. If you do not delete
32
 
    the provisions above, a recipient may use your version of this file under
33
 
    the terms of any one of the MPL, the GPL or the LGPL.
34
 
*/
35
 
 
36
 
// Mock setTimeout, clearTimeout
37
 
// Contributed by Pivotal Computer Systems, www.pivotalsf.com
38
 
//
39
 
// Copied from the JsUnit 2.2alpha1 release, made in Mar 24 2006
40
 
// (http://www.jsunit.net/)
41
 
 
42
 
var Clock = {
43
 
    timeoutsMade: 0,
44
 
    scheduledFunctions: {},
45
 
    nowMillis: 0,
46
 
    reset: function() {
47
 
        this.scheduledFunctions = {};
48
 
        this.nowMillis = 0;
49
 
        this.timeoutsMade = 0;
50
 
    },
51
 
    tick: function(millis) {
52
 
        var oldMillis = this.nowMillis;
53
 
        var newMillis = oldMillis + millis;
54
 
        this.runFunctionsWithinRange(oldMillis, newMillis);
55
 
        this.nowMillis = newMillis;
56
 
    },
57
 
    runFunctionsWithinRange: function(oldMillis, nowMillis) {
58
 
        var scheduledFunc;
59
 
        var funcsToRun = [];
60
 
        for (var timeoutKey in this.scheduledFunctions) {
61
 
            scheduledFunc = this.scheduledFunctions[timeoutKey];
62
 
            if (scheduledFunc != undefined &&
63
 
                scheduledFunc.runAtMillis >= oldMillis &&
64
 
                scheduledFunc.runAtMillis <= nowMillis) {
65
 
                funcsToRun.push(scheduledFunc);
66
 
                this.scheduledFunctions[timeoutKey] = undefined;
67
 
            }
68
 
        }
69
 
 
70
 
        if (funcsToRun.length > 0) {
71
 
            funcsToRun.sort(function(a, b) {
72
 
                return a.runAtMillis - b.runAtMillis;
73
 
            });
74
 
            for (var i = 0; i < funcsToRun.length; ++i) {
75
 
                try {
76
 
                    this.nowMillis = funcsToRun[i].runAtMillis;
77
 
                    funcsToRun[i].funcToCall();
78
 
                    if (funcsToRun[i].recurring) {
79
 
                        Clock.scheduleFunction(funcsToRun[i].timeoutKey,
80
 
                                funcsToRun[i].funcToCall,
81
 
                                funcsToRun[i].millis,
82
 
                                true);
83
 
                    }
84
 
                } catch(e) {
85
 
                    console.log(e);
86
 
                }
87
 
            }
88
 
            this.runFunctionsWithinRange(oldMillis, nowMillis);
89
 
        }
90
 
    },
91
 
    scheduleFunction: function(timeoutKey, funcToCall, millis, recurring) {
92
 
        Clock.scheduledFunctions[timeoutKey] = {
93
 
            runAtMillis: Clock.nowMillis + millis,
94
 
            funcToCall: funcToCall,
95
 
            recurring: recurring,
96
 
            timeoutKey: timeoutKey,
97
 
            millis: millis
98
 
        };
99
 
    }
100
 
};
101
 
 
102
 
function setTimeout(funcToCall, millis) {
103
 
    Clock.timeoutsMade = Clock.timeoutsMade + 1;
104
 
    Clock.scheduleFunction(Clock.timeoutsMade, funcToCall, millis, false);
105
 
    return Clock.timeoutsMade;
106
 
}
107
 
 
108
 
function setInterval(funcToCall, millis) {
109
 
    Clock.timeoutsMade = Clock.timeoutsMade + 1;
110
 
    Clock.scheduleFunction(Clock.timeoutsMade, funcToCall, millis, true);
111
 
    return Clock.timeoutsMade;
112
 
}
113
 
 
114
 
function clearTimeout(timeoutKey) {
115
 
    Clock.scheduledFunctions[timeoutKey] = undefined;
116
 
}
117
 
 
118
 
function clearInterval(timeoutKey) {
119
 
    Clock.scheduledFunctions[timeoutKey] = undefined;
120
 
}