← Back to branch summary

~ubuntu-branches/ubuntu/quantal/lightning-extension/quantal-security

« back to all changes in this revision

Viewing changes to mozilla/testing/marionette/client/marionette/tests/head.js

  • Committer: Package Import Robot
  • Author(s): Chris Coulson
  • Date: 2012-11-08 10:00:06 UTC
  • mfrom: (1.3.8)
  • Revision ID: package-import@ubuntu.com-20121108100006-gljsc52uauf1o4ri
Tags: 1.9+build1-0ubuntu0.12.10.1
https://launchpad.net/bugs/1080212
* New upstream stable release to support Thunderbird 17 (CALENDAR_1_9_BUILD1)
  - see LP: #1080212 for USN information

Show diffs side-by-side

added added

removed removed

Lines of Context:
mozilla/testing/marionette/client/marionette/tests/head.js
 
1
MARIONETTE_CONTEXT="chrome";
 
2
MARIONETTE_TIMEOUT=120000;
 
3
 
 
4
// Must be synchronized with nsIDOMWindowUtils.
 
5
const COMPOSITION_ATTR_RAWINPUT              = 0x02;
 
6
const COMPOSITION_ATTR_SELECTEDRAWTEXT       = 0x03;
 
7
const COMPOSITION_ATTR_CONVERTEDTEXT         = 0x04;
 
8
const COMPOSITION_ATTR_SELECTEDCONVERTEDTEXT = 0x05;
 
9
 
 
10
var EventUtils = {
 
11
  /**
 
12
   * see http://mxr.mozilla.org/mozilla-central/source/testing/mochitest/tests/SimpleTest/EventUtils.js
 
13
   */
 
14
  sendMouseEvent: function EventUtils__sendMouseEvent(aEvent, aTarget, aWindow) {
 
15
    if (['click', 'dblclick', 'mousedown', 'mouseup', 'mouseover', 'mouseout'].indexOf(aEvent.type) == -1) {
 
16
      throw new Error("sendMouseEvent doesn't know about event type '" + aEvent.type + "'");
 
17
    }
 
18
 
 
19
    if (!aWindow) {
 
20
      aWindow = window;
 
21
    }
 
22
 
 
23
    if (typeof(aTarget) == "string") {
 
24
      aTarget = aWindow.document.getElementById(aTarget);
 
25
    }
 
26
 
 
27
    var event = aWindow.document.createEvent('MouseEvent');
 
28
 
 
29
    var typeArg          = aEvent.type;
 
30
    var canBubbleArg     = true;
 
31
    var cancelableArg    = true;
 
32
    var viewArg          = aWindow;
 
33
    var detailArg        = aEvent.detail        || (aEvent.type == 'click'     ||
 
34
                                                    aEvent.type == 'mousedown' ||
 
35
                                                    aEvent.type == 'mouseup' ? 1 :
 
36
                                                    aEvent.type == 'dblclick'? 2 : 0);
 
37
    var screenXArg       = aEvent.screenX       || 0;
 
38
    var screenYArg       = aEvent.screenY       || 0;
 
39
    var clientXArg       = aEvent.clientX       || 0;
 
40
    var clientYArg       = aEvent.clientY       || 0;
 
41
    var ctrlKeyArg       = aEvent.ctrlKey       || false;
 
42
    var altKeyArg        = aEvent.altKey        || false;
 
43
    var shiftKeyArg      = aEvent.shiftKey      || false;
 
44
    var metaKeyArg       = aEvent.metaKey       || false;
 
45
    var buttonArg        = aEvent.button        || 0;
 
46
    var relatedTargetArg = aEvent.relatedTarget || null;
 
47
 
 
48
    event.initMouseEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg,
 
49
                         screenXArg, screenYArg, clientXArg, clientYArg,
 
50
                         ctrlKeyArg, altKeyArg, shiftKeyArg, metaKeyArg,
 
51
                         buttonArg, relatedTargetArg);
 
52
 
 
53
    aTarget.dispatchEvent(event);
 
54
  },
 
55
 
 
56
  sendChar: function EventUtils_sendChar(aChar, aWindow) {
 
57
    // DOM event charcodes match ASCII (JS charcodes) for a-zA-Z0-9.
 
58
    var hasShift = (aChar == aChar.toUpperCase());
 
59
    this.synthesizeKey(aChar, { shiftKey: hasShift }, aWindow);
 
60
  },
 
61
 
 
62
  sendString: function EventUtils_sendString(aStr, aWindow) {
 
63
    for (var i = 0; i < aStr.length; ++i) {
 
64
      this.sendChar(aStr.charAt(i), aWindow);
 
65
    }
 
66
  },
 
67
 
 
68
  sendKey: function EventUtils_sendKey(aKey, aWindow) {
 
69
    var keyName = "VK_" + aKey.toUpperCase();
 
70
    this.synthesizeKey(keyName, { shiftKey: false }, aWindow);
 
71
  },
 
72
 
 
73
  _getDOMWindowUtils: function EventUtils__getDOMWindowUtils(aWindow) {
 
74
    if (!aWindow) {
 
75
      aWindow = window;
 
76
    }
 
77
 
 
78
    // we need parent.SpecialPowers for:
 
79
    //  layout/base/tests/test_reftests_with_caret.html
 
80
    //  chrome: toolkit/content/tests/chrome/test_findbar.xul
 
81
    //  chrome: toolkit/content/tests/chrome/test_popup_anchor.xul
 
82
    /*if ("SpecialPowers" in window && window.SpecialPowers != undefined) {
 
83
      return SpecialPowers.getDOMWindowUtils(aWindow);
 
84
    }
 
85
    if ("SpecialPowers" in parent && parent.SpecialPowers != undefined) {
 
86
      return parent.SpecialPowers.getDOMWindowUtils(aWindow);
 
87
    }*/
 
88
 
 
89
    //TODO: this is assuming we are in chrome space
 
90
    return aWindow.QueryInterface(Components.interfaces.nsIInterfaceRequestor).
 
91
                                 getInterface(Components.interfaces.nsIDOMWindowUtils);
 
92
  },
 
93
 
 
94
  _computeKeyCodeFromChar: function EventUtils__computeKeyCodeFromChar(aChar) {
 
95
    if (aChar.length != 1) {
 
96
      return 0;
 
97
    }
 
98
    const nsIDOMKeyEvent = Components.interfaces.nsIDOMKeyEvent;
 
99
    if (aChar >= 'a' && aChar <= 'z') {
 
100
      return nsIDOMKeyEvent.DOM_VK_A + aChar.charCodeAt(0) - 'a'.charCodeAt(0);
 
101
    }
 
102
    if (aChar >= 'A' && aChar <= 'Z') {
 
103
      return nsIDOMKeyEvent.DOM_VK_A + aChar.charCodeAt(0) - 'A'.charCodeAt(0);
 
104
    }
 
105
    if (aChar >= '0' && aChar <= '9') {
 
106
      return nsIDOMKeyEvent.DOM_VK_0 + aChar.charCodeAt(0) - '0'.charCodeAt(0);
 
107
    }
 
108
    // returns US keyboard layout's keycode
 
109
    switch (aChar) {
 
110
      case '~':
 
111
      case '`':
 
112
        return nsIDOMKeyEvent.DOM_VK_BACK_QUOTE;
 
113
      case '!':
 
114
        return nsIDOMKeyEvent.DOM_VK_1;
 
115
      case '@':
 
116
        return nsIDOMKeyEvent.DOM_VK_2;
 
117
      case '#':
 
118
        return nsIDOMKeyEvent.DOM_VK_3;
 
119
      case '$':
 
120
        return nsIDOMKeyEvent.DOM_VK_4;
 
121
      case '%':
 
122
        return nsIDOMKeyEvent.DOM_VK_5;
 
123
      case '^':
 
124
        return nsIDOMKeyEvent.DOM_VK_6;
 
125
      case '&':
 
126
        return nsIDOMKeyEvent.DOM_VK_7;
 
127
      case '*':
 
128
        return nsIDOMKeyEvent.DOM_VK_8;
 
129
      case '(':
 
130
        return nsIDOMKeyEvent.DOM_VK_9;
 
131
      case ')':
 
132
        return nsIDOMKeyEvent.DOM_VK_0;
 
133
      case '-':
 
134
      case '_':
 
135
        return nsIDOMKeyEvent.DOM_VK_SUBTRACT;
 
136
      case '+':
 
137
      case '=':
 
138
        return nsIDOMKeyEvent.DOM_VK_EQUALS;
 
139
      case '{':
 
140
      case '[':
 
141
        return nsIDOMKeyEvent.DOM_VK_OPEN_BRACKET;
 
142
      case '}':
 
143
      case ']':
 
144
        return nsIDOMKeyEvent.DOM_VK_CLOSE_BRACKET;
 
145
      case '|':
 
146
      case '\\':
 
147
        return nsIDOMKeyEvent.DOM_VK_BACK_SLASH;
 
148
      case ':':
 
149
      case ';':
 
150
        return nsIDOMKeyEvent.DOM_VK_SEMICOLON;
 
151
      case '\'':
 
152
      case '"':
 
153
        return nsIDOMKeyEvent.DOM_VK_QUOTE;
 
154
      case '<':
 
155
      case ',':
 
156
        return nsIDOMKeyEvent.DOM_VK_COMMA;
 
157
      case '>':
 
158
      case '.':
 
159
        return nsIDOMKeyEvent.DOM_VK_PERIOD;
 
160
      case '?':
 
161
      case '/':
 
162
        return nsIDOMKeyEvent.DOM_VK_SLASH;
 
163
      default:
 
164
        return 0;
 
165
    }
 
166
  },
 
167
 
 
168
  _parseModifiers: function EventUtils__parseModifiers(aEvent) {
 
169
    const masks = Components.interfaces.nsIDOMNSEvent;
 
170
    var mval = 0;
 
171
    if (aEvent.shiftKey)
 
172
      mval |= masks.SHIFT_MASK;
 
173
    if (aEvent.ctrlKey)
 
174
      mval |= masks.CONTROL_MASK;
 
175
    if (aEvent.altKey)
 
176
      mval |= masks.ALT_MASK;
 
177
    if (aEvent.metaKey)
 
178
      mval |= masks.META_MASK;
 
179
    if (aEvent.accelKey)
 
180
      mval |= (navigator.platform.indexOf("Mac") >= 0) ? masks.META_MASK :
 
181
                                                         masks.CONTROL_MASK;
 
182
 
 
183
    return mval;
 
184
  },
 
185
 
 
186
  isKeypressFiredKey: function EventUtils_isKeypressFiredKey(aDOMKeyCode) {
 
187
    if (typeof(aDOMKeyCode) == "string") {
 
188
      if (aDOMKeyCode.indexOf("VK_") == 0) {
 
189
        aDOMKeyCode = KeyEvent["DOM_" + aDOMKeyCode];
 
190
        if (!aDOMKeyCode) {
 
191
          throw "Unknown key: " + aDOMKeyCode;
 
192
        }
 
193
      } else {
 
194
        // If the key generates a character, it must cause a keypress event.
 
195
        return true;
 
196
      }
 
197
    }
 
198
    switch (aDOMKeyCode) {
 
199
      case KeyEvent.DOM_VK_SHIFT:
 
200
      case KeyEvent.DOM_VK_CONTROL:
 
201
      case KeyEvent.DOM_VK_ALT:
 
202
      case KeyEvent.DOM_VK_CAPS_LOCK:
 
203
      case KeyEvent.DOM_VK_NUM_LOCK:
 
204
      case KeyEvent.DOM_VK_SCROLL_LOCK:
 
205
      case KeyEvent.DOM_VK_META:
 
206
        return false;
 
207
      default:
 
208
        return true;
 
209
    }
 
210
  },
 
211
 
 
212
  synthesizeKey: function EventUtils_synthesizeKey(aKey, aEvent, aWindow) {
 
213
    var utils = this._getDOMWindowUtils(aWindow);
 
214
    if (utils) {
 
215
      var keyCode = 0, charCode = 0;
 
216
      if (aKey.indexOf("VK_") == 0) {
 
217
        keyCode = KeyEvent["DOM_" + aKey];
 
218
        if (!keyCode) {
 
219
          throw "Unknown key: " + aKey;
 
220
        }
 
221
      } else {
 
222
        charCode = aKey.charCodeAt(0);
 
223
        keyCode = this._computeKeyCodeFromChar(aKey.charAt(0));
 
224
      }
 
225
 
 
226
      var modifiers = this._parseModifiers(aEvent);
 
227
 
 
228
      if (!("type" in aEvent) || !aEvent.type) {
 
229
        // Send keydown + (optional) keypress + keyup events.
 
230
        var keyDownDefaultHappened =
 
231
            utils.sendKeyEvent("keydown", keyCode, 0, modifiers);
 
232
        if (this.isKeypressFiredKey(keyCode)) {
 
233
          utils.sendKeyEvent("keypress", charCode ? 0 : keyCode, charCode,
 
234
                             modifiers, !keyDownDefaultHappened);
 
235
        }
 
236
        utils.sendKeyEvent("keyup", keyCode, 0, modifiers);
 
237
      } else if (aEvent.type == "keypress") {
 
238
        // Send standalone keypress event.
 
239
        utils.sendKeyEvent(aEvent.type, charCode ? 0 : keyCode,
 
240
                           charCode, modifiers);
 
241
      } else {
 
242
        // Send other standalone event than keypress.
 
243
        utils.sendKeyEvent(aEvent.type, keyCode, 0, modifiers);
 
244
      }
 
245
    }
 
246
  },
 
247
};
 
248
 
 
249
function waitForExplicitFinish() {}
 
250
 
 
251
var SpecialPowers = {
 
252
  _prefService: Components.classes["@mozilla.org/preferences-service;1"]
 
253
                .getService(Components.interfaces.nsIPrefBranch),
 
254
 
 
255
  setBoolPref: function SpecialPowers__setBoolPref(pref, value) {
 
256
    this._prefService.setBoolPref(pref, value);
 
257
  },
 
258
};
 
259
 
 
260
var readyAndUnlocked;
 
261
 
 
262
// see http://mxr.mozilla.org/mozilla-central/source/testing/mochitest/browser-test.js#478
 
263
function nextStep(arg) {
 
264
  try {
 
265
    __generator.send(arg);
 
266
  } catch(ex if ex instanceof StopIteration) {
 
267
    finish();
 
268
  } catch(ex) {
 
269
    ok(false, "Unhandled exception: " + ex);
 
270
    finish();
 
271
  }
 
272
}
 
273
 
 
274
// see http://mxr.mozilla.org/mozilla-central/source/testing/mochitest/browser-test.js#523
 
275
function requestLongerTimeout() {
 
276
  /* no-op! */
 
277
}
 
278
 
 
279
// The browser-chrome tests either start with test() or generatorTest().
 
280
var __generator = null;
 
281
if (typeof(test) != 'undefined')
 
282
  test();
 
283
else if (typeof(generatorTest) != 'undefined') {
 
284
  __generator = generatorTest();
 
285
  __generator.next();
 
286
}
 
287