Andreas Hocevar
717 lines
20 KiB
JavaScript
717 lines
20 KiB
JavaScript
// Copyright 2007 The Closure Library Authors. All Rights Reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS-IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
goog.provide('goog.ui.ac.InputHandlerTest');
|
|
goog.setTestOnly('goog.ui.ac.InputHandlerTest');
|
|
|
|
goog.require('goog.dom.selection');
|
|
goog.require('goog.events.BrowserEvent');
|
|
goog.require('goog.events.Event');
|
|
goog.require('goog.events.EventTarget');
|
|
goog.require('goog.events.KeyCodes');
|
|
goog.require('goog.functions');
|
|
goog.require('goog.object');
|
|
goog.require('goog.testing.MockClock');
|
|
goog.require('goog.testing.jsunit');
|
|
goog.require('goog.ui.ac.InputHandler');
|
|
goog.require('goog.userAgent');
|
|
|
|
|
|
|
|
/**
|
|
* Mock out the input element.
|
|
* @constructor
|
|
*/
|
|
function MockElement() {
|
|
goog.events.EventTarget.call(this);
|
|
this.setAttributeNS = function() {};
|
|
this.setAttribute = function(key, value) { this[key] = value; };
|
|
this.focus = function() {};
|
|
this.blur = function() {};
|
|
this.ownerDocument = document;
|
|
this.selectionStart = 0;
|
|
}
|
|
goog.inherits(MockElement, goog.events.EventTarget);
|
|
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
function MockAutoCompleter() {
|
|
this.setToken = null;
|
|
this.setTokenWasCalled = false;
|
|
this.selectHilitedWasCalled = false;
|
|
this.dismissWasCalled = false;
|
|
this.getTarget = function() { return mockElement };
|
|
this.setTarget = function() { };
|
|
this.setToken = function(token) {
|
|
this.setTokenWasCalled = true;
|
|
this.setToken = token;
|
|
};
|
|
this.selectHilited = function() {
|
|
this.selectHilitedWasCalled = true;
|
|
return true; // Success.
|
|
};
|
|
this.cancelDelayedDismiss = function() { };
|
|
this.dismissOnDelay = function() {};
|
|
this.dismiss = function() { this.dismissWasCalled = true; };
|
|
this.isOpen = goog.functions.TRUE;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* MockInputHandler simulates key events for testing the IME behavior of
|
|
* InputHandler.
|
|
* @constructor
|
|
*/
|
|
function MockInputHandler() {
|
|
goog.ui.ac.InputHandler.call(this);
|
|
|
|
this.ac_ = new MockAutoCompleter();
|
|
this.cursorPosition_ = 0;
|
|
|
|
this.attachInput(mockElement);
|
|
}
|
|
goog.inherits(MockInputHandler, goog.ui.ac.InputHandler);
|
|
|
|
|
|
/** Checks for updates to the text area, should not happen during IME. */
|
|
MockInputHandler.prototype.update = function() {
|
|
this.updates++;
|
|
};
|
|
|
|
|
|
/** Simulates key events. */
|
|
MockInputHandler.prototype.fireKeyEvents = function(
|
|
keyCode, down, press, up, opt_properties) {
|
|
if (down) this.fireEvent('keydown', keyCode, opt_properties);
|
|
if (press) this.fireEvent('keypress', keyCode, opt_properties);
|
|
if (up) this.fireEvent('keyup', keyCode, opt_properties);
|
|
};
|
|
|
|
|
|
/** Simulates an event. */
|
|
MockInputHandler.prototype.fireEvent = function(
|
|
type, keyCode, opt_properties) {
|
|
var e = {};
|
|
e.type = type;
|
|
e.keyCode = keyCode;
|
|
e.preventDefault = function() {};
|
|
if (!goog.userAgent.IE) {
|
|
e.which = type == 'keydown' ? keyCode : 0;
|
|
}
|
|
if (opt_properties) {
|
|
goog.object.extend(e, opt_properties);
|
|
}
|
|
e = new goog.events.BrowserEvent(e);
|
|
mockElement.dispatchEvent(e);
|
|
};
|
|
|
|
MockInputHandler.prototype.setCursorPosition = function(cursorPosition) {
|
|
this.cursorPosition_ = cursorPosition;
|
|
};
|
|
|
|
MockInputHandler.prototype.getCursorPosition = function() {
|
|
return this.cursorPosition_;
|
|
};
|
|
|
|
// Variables used by all test
|
|
var mh = null;
|
|
var oldMac, oldWin, oldLinux, oldIe, oldFf, oldWebkit, oldVersion;
|
|
var oldUsesKeyDown;
|
|
var mockElement;
|
|
var mockClock;
|
|
|
|
function setUp() {
|
|
oldMac = goog.userAgent.MAC;
|
|
oldWin = goog.userAgent.WINDOWS;
|
|
oldLinux = goog.userAgent.LINUX;
|
|
oldIe = goog.userAgent.IE;
|
|
oldFf = goog.userAgent.GECKO;
|
|
oldWebkit = goog.userAgent.WEBKIT;
|
|
oldVersion = goog.userAgent.VERSION;
|
|
oldUsesKeyDown = goog.events.KeyHandler.USES_KEYDOWN_;
|
|
mockClock = new goog.testing.MockClock(true);
|
|
mockElement = new MockElement;
|
|
mh = new MockInputHandler;
|
|
}
|
|
|
|
function tearDown() {
|
|
goog.userAgent.MAC = oldMac;
|
|
goog.userAgent.WINDOWS = oldWin;
|
|
goog.userAgent.LINUX = oldLinux;
|
|
goog.userAgent.IE = oldIe;
|
|
goog.userAgent.GECKO = oldFf;
|
|
goog.userAgent.WEBKIT = oldWebkit;
|
|
goog.userAgent.VERSION = oldVersion;
|
|
goog.events.KeyHandler.USES_KEYDOWN_ = oldUsesKeyDown;
|
|
mockClock.dispose();
|
|
mockElement.dispose();
|
|
}
|
|
|
|
|
|
/** Used to simulate behavior of Windows/Firefox3 */
|
|
function simulateWinFirefox3() {
|
|
goog.userAgent.MAC = false;
|
|
goog.userAgent.WINDOWS = true;
|
|
goog.userAgent.LINUX = false;
|
|
goog.userAgent.IE = false;
|
|
goog.userAgent.GECKO = true;
|
|
goog.userAgent.WEBKIT = false;
|
|
goog.events.KeyHandler.USES_KEYDOWN_ = false;
|
|
}
|
|
|
|
|
|
/** Used to simulate behavior of Windows/InternetExplorer7 */
|
|
function simulateWinIe7() {
|
|
goog.userAgent.MAC = false;
|
|
goog.userAgent.WINDOWS = true;
|
|
goog.userAgent.LINUX = false;
|
|
goog.userAgent.IE = true;
|
|
goog.userAgent.DOCUMENT_MODE = 7;
|
|
goog.userAgent.GECKO = false;
|
|
goog.userAgent.WEBKIT = false;
|
|
goog.events.KeyHandler.USES_KEYDOWN_ = true;
|
|
}
|
|
|
|
|
|
/** Used to simulate behavior of Windows/Chrome */
|
|
function simulateWinChrome() {
|
|
goog.userAgent.MAC = false;
|
|
goog.userAgent.WINDOWS = true;
|
|
goog.userAgent.LINUX = false;
|
|
goog.userAgent.IE = false;
|
|
goog.userAgent.GECKO = false;
|
|
goog.userAgent.WEBKIT = true;
|
|
goog.userAgent.VERSION = '525';
|
|
goog.events.KeyHandler.USES_KEYDOWN_ = true;
|
|
}
|
|
|
|
|
|
/** Used to simulate behavior of Mac/Firefox3 */
|
|
function simulateMacFirefox3() {
|
|
goog.userAgent.MAC = true;
|
|
goog.userAgent.WINDOWS = false;
|
|
goog.userAgent.LINUX = false;
|
|
goog.userAgent.IE = false;
|
|
goog.userAgent.GECKO = true;
|
|
goog.userAgent.WEBKIT = false;
|
|
goog.events.KeyHandler.USES_KEYDOWN_ = true;
|
|
}
|
|
|
|
|
|
/** Used to simulate behavior of Mac/Safari3 */
|
|
function simulateMacSafari3() {
|
|
goog.userAgent.MAC = true;
|
|
goog.userAgent.WINDOWS = false;
|
|
goog.userAgent.LINUX = false;
|
|
goog.userAgent.IE = false;
|
|
goog.userAgent.GECKO = false;
|
|
goog.userAgent.WEBKIT = true;
|
|
goog.userAgent.VERSION = '525';
|
|
goog.events.KeyHandler.USES_KEYDOWN_ = true;
|
|
}
|
|
|
|
|
|
/** Used to simulate behavior of Linux/Firefox3 */
|
|
function simulateLinuxFirefox3() {
|
|
goog.userAgent.MAC = false;
|
|
goog.userAgent.WINDOWS = false;
|
|
goog.userAgent.LINUX = true;
|
|
goog.userAgent.IE = false;
|
|
goog.userAgent.GECKO = true;
|
|
goog.userAgent.WEBKIT = false;
|
|
goog.events.KeyHandler.USES_KEYDOWN_ = true;
|
|
}
|
|
|
|
|
|
/** Test the normal, non-IME case */
|
|
function testRegularKey() {
|
|
// Each key fires down, press, and up in that order, and each should
|
|
// trigger an autocomplete update
|
|
assertFalse('IME should not be triggered', mh.waitingForIme_);
|
|
|
|
mh.fireKeyEvents(goog.events.KeyCodes.K, true, true, true);
|
|
assertFalse('IME should not be triggered by K', mh.waitingForIme_);
|
|
|
|
mh.fireKeyEvents(goog.events.KeyCodes.A, true, true, true);
|
|
assertFalse('IME should not be triggered by A', mh.waitingForIme_);
|
|
}
|
|
|
|
|
|
/**
|
|
* This test simulates the key inputs generated by pressing
|
|
* '<ime_on>a<enter>i<ime_off>u' using the Japanese IME
|
|
* on Windows/Firefox3.
|
|
*/
|
|
function testImeWinFirefox3() {
|
|
simulateWinFirefox3();
|
|
mh.fireEvent('focus', '');
|
|
assertFalse('IME should not be triggered', mh.waitingForIme_);
|
|
|
|
// ime_on
|
|
|
|
// a
|
|
mh.fireKeyEvents(goog.events.KeyCodes.WIN_IME, true, true, false);
|
|
// Event is not generated for key code a.
|
|
assertTrue('IME should be triggered', mh.waitingForIme_);
|
|
|
|
// enter
|
|
mh.fireKeyEvents(goog.events.KeyCodes.ENTER, false, false, true);
|
|
assertFalse('IME should not be triggered', mh.waitingForIme_);
|
|
|
|
// i
|
|
mh.fireKeyEvents(goog.events.KeyCodes.WIN_IME, true, true, false);
|
|
// Event is not generated for key code i.
|
|
assertTrue('IME should be triggered', mh.waitingForIme_);
|
|
|
|
// ime_off
|
|
|
|
// u
|
|
mh.fireKeyEvents(goog.events.KeyCodes.U, true, true, true);
|
|
assertFalse('IME should not be triggered', mh.waitingForIme_);
|
|
|
|
mh.fireEvent('blur', '');
|
|
}
|
|
|
|
|
|
/**
|
|
* This test simulates the key inputs generated by pressing
|
|
* '<ime_on>a<enter>i<ime_off>u' using the Japanese IME
|
|
* on Windows/InternetExplorer7.
|
|
*/
|
|
function testImeWinIe7() {
|
|
simulateWinIe7();
|
|
mh.fireEvent('focus', '');
|
|
assertFalse('IME should not be triggered', mh.waitingForIme_);
|
|
|
|
// ime_on
|
|
|
|
// a
|
|
mh.fireKeyEvents(goog.events.KeyCodes.WIN_IME, true, false, false);
|
|
mh.fireKeyEvents(goog.events.KeyCodes.A, false, false, true);
|
|
assertTrue('IME should be triggered', mh.waitingForIme_);
|
|
|
|
// enter
|
|
mh.fireKeyEvents(goog.events.KeyCodes.WIN_IME, true, false, false);
|
|
mh.fireKeyEvents(goog.events.KeyCodes.ENTER, false, false, true);
|
|
assertFalse('IME should not be triggered', mh.waitingForIme_);
|
|
|
|
// i
|
|
mh.fireKeyEvents(goog.events.KeyCodes.WIN_IME, true, false, false);
|
|
mh.fireKeyEvents(goog.events.KeyCodes.I, false, false, true);
|
|
assertTrue('IME should be triggered', mh.waitingForIme_);
|
|
|
|
// ime_off
|
|
|
|
// u
|
|
mh.fireKeyEvents(goog.events.KeyCodes.U, true, true, true);
|
|
assertFalse('IME should not be triggered', mh.waitingForIme_);
|
|
|
|
mh.fireEvent('blur', '');
|
|
}
|
|
|
|
|
|
/**
|
|
* This test simulates the key inputs generated by pressing
|
|
* '<ime_on>a<enter>i<ime_off>u' using the Japanese IME
|
|
* on Windows/Chrome.
|
|
*/
|
|
function testImeWinChrome() {
|
|
simulateWinChrome();
|
|
mh.fireEvent('focus', '');
|
|
assertFalse('IME should not be triggered', mh.waitingForIme_);
|
|
|
|
// ime_on
|
|
|
|
// a
|
|
mh.fireKeyEvents(goog.events.KeyCodes.WIN_IME, true, false, false);
|
|
mh.fireKeyEvents(goog.events.KeyCodes.A, false, false, true);
|
|
assertTrue('IME should be triggered', mh.waitingForIme_);
|
|
|
|
// enter
|
|
mh.fireKeyEvents(goog.events.KeyCodes.WIN_IME, true, false, false);
|
|
mh.fireKeyEvents(goog.events.KeyCodes.ENTER, false, false, true);
|
|
assertFalse('IME should not be triggered', mh.waitingForIme_);
|
|
|
|
// i
|
|
mh.fireKeyEvents(goog.events.KeyCodes.WIN_IME, true, false, false);
|
|
mh.fireKeyEvents(goog.events.KeyCodes.I, false, false, true);
|
|
assertTrue('IME should be triggered', mh.waitingForIme_);
|
|
|
|
// ime_off
|
|
|
|
// u
|
|
mh.fireKeyEvents(goog.events.KeyCodes.U, true, true, true);
|
|
assertFalse('IME should not be triggered', mh.waitingForIme_);
|
|
|
|
mh.fireEvent('blur', '');
|
|
}
|
|
|
|
|
|
/**
|
|
* This test simulates the key inputs generated by pressing
|
|
* '<ime_on>a<enter>i<ime_off>u' using the Japanese IME
|
|
* on Mac/Firefox3.
|
|
*/
|
|
function testImeMacFirefox3() {
|
|
// TODO(user): Currently our code cannot distinguish preedit characters
|
|
// from normal ones for Mac/Firefox3.
|
|
// Enable this test after we fix it.
|
|
|
|
simulateMacFirefox3();
|
|
mh.fireEvent('focus', '');
|
|
assertFalse('IME should not be triggered', mh.waitingForIme_);
|
|
|
|
// ime_on
|
|
|
|
// a
|
|
mh.fireKeyEvents(goog.events.KeyCodes.WIN_IME, true, true, false);
|
|
assertTrue('IME should be triggered', mh.waitingForIme_);
|
|
mh.fireKeyEvents(goog.events.KeyCodes.A, true, false, true);
|
|
assertTrue('IME should be triggered', mh.waitingForIme_);
|
|
|
|
// enter
|
|
mh.fireKeyEvents(goog.events.KeyCodes.ENTER, true, true, true);
|
|
assertFalse('IME should not be triggered', mh.waitingForIme_);
|
|
|
|
// i
|
|
mh.fireKeyEvents(goog.events.KeyCodes.WIN_IME, true, true, false);
|
|
mh.fireKeyEvents(goog.events.KeyCodes.I, true, false, true);
|
|
assertTrue('IME should be triggered', mh.waitingForIme_);
|
|
|
|
// ime_off
|
|
|
|
// u
|
|
mh.fireKeyEvents(goog.events.KeyCodes.U, true, true, true);
|
|
assertFalse('IME should not be triggered', mh.waitingForIme_);
|
|
|
|
mh.fireEvent('blur', '');
|
|
}
|
|
|
|
|
|
/**
|
|
* This test simulates the key inputs generated by pressing
|
|
* '<ime_on>a<enter>i<ime_off>u' using the Japanese IME
|
|
* on Mac/Safari3.
|
|
*/
|
|
function testImeMacSafari3() {
|
|
simulateMacSafari3();
|
|
mh.fireEvent('focus', '');
|
|
assertFalse('IME should not be triggered', mh.waitingForIme_);
|
|
|
|
// ime_on
|
|
|
|
// a
|
|
mh.fireKeyEvents(goog.events.KeyCodes.WIN_IME, true, false, false);
|
|
mh.fireKeyEvents(goog.events.KeyCodes.A, false, false, true);
|
|
assertTrue('IME should be triggered', mh.waitingForIme_);
|
|
|
|
// enter
|
|
mh.fireKeyEvents(goog.events.KeyCodes.WIN_IME, true, false, false);
|
|
mh.fireKeyEvents(goog.events.KeyCodes.ENTER, false, false, true);
|
|
assertFalse('IME should not be triggered', mh.waitingForIme_);
|
|
|
|
// i
|
|
mh.fireKeyEvents(goog.events.KeyCodes.WIN_IME, true, false, false);
|
|
mh.fireKeyEvents(goog.events.KeyCodes.I, false, false, true);
|
|
assertTrue('IME should be triggered', mh.waitingForIme_);
|
|
|
|
// ime_off
|
|
|
|
// u
|
|
mh.fireKeyEvents(goog.events.KeyCodes.U, true, true, true);
|
|
assertFalse('IME should not be triggered', mh.waitingForIme_);
|
|
|
|
mh.fireEvent('blur', '');
|
|
}
|
|
|
|
|
|
/**
|
|
* This test simulates the key inputs generated by pressing
|
|
* '<ime_on>a<enter>i<ime_off>u' using the Japanese IME
|
|
* on Linux/Firefox3.
|
|
*/
|
|
function testImeLinuxFirefox3() {
|
|
// TODO(user): Currently our code cannot distinguish preedit characters
|
|
// from normal ones for Linux/Firefox3.
|
|
// Enable this test after we fix it.
|
|
|
|
|
|
simulateLinuxFirefox3();
|
|
mh.fireEvent('focus', '');
|
|
assertFalse('IME should not be triggered', mh.waitingForIme_);
|
|
|
|
// ime_on
|
|
mh.fireKeyEvents(goog.events.KeyCodes.WIN_IME, true, true, false);
|
|
|
|
// a
|
|
mh.fireKeyEvents(goog.events.KeyCodes.A, true, false, true);
|
|
assertTrue('IME should be triggered', mh.waitingForIme_);
|
|
|
|
// enter
|
|
mh.fireKeyEvents(goog.events.KeyCodes.ENTER, true, true, true);
|
|
assertFalse('IME should not be triggered', mh.waitingForIme_);
|
|
|
|
// i
|
|
mh.fireKeyEvents(goog.events.KeyCodes.WIN_IME, true, true, false);
|
|
mh.fireKeyEvents(goog.events.KeyCodes.I, true, false, true);
|
|
assertTrue('IME should be triggered', mh.waitingForIme_);
|
|
|
|
// ime_off
|
|
|
|
// u
|
|
mh.fireKeyEvents(goog.events.KeyCodes.U, true, true, true);
|
|
assertFalse('IME should not be triggered', mh.waitingForIme_);
|
|
|
|
mh.fireEvent('blur', '');
|
|
}
|
|
|
|
|
|
/**
|
|
* Check attaching to an EventTarget instead of an element.
|
|
*/
|
|
function testAttachEventTarget() {
|
|
var target = new goog.events.EventTarget();
|
|
|
|
assertNull(mh.activeElement_);
|
|
mh.attachInput(target);
|
|
assertNull(mh.activeElement_);
|
|
|
|
mockElement.dispatchEvent(new goog.events.Event('focus', mockElement));
|
|
assertEquals(mockElement, mh.activeElement_);
|
|
|
|
mh.detachInput(target);
|
|
}
|
|
|
|
|
|
/**
|
|
* Make sure that the active element handling works.
|
|
*/
|
|
function testActiveElement() {
|
|
assertNull(mh.activeElement_);
|
|
|
|
mockElement.dispatchEvent('keydown');
|
|
assertEquals(mockElement, mh.activeElement_);
|
|
|
|
mockElement.dispatchEvent('blur');
|
|
assertNull(mh.activeElement_);
|
|
|
|
mockElement.dispatchEvent('focus');
|
|
assertEquals(mockElement, mh.activeElement_);
|
|
|
|
mh.detachInput(mockElement);
|
|
assertNull(mh.activeElement_);
|
|
}
|
|
|
|
|
|
/**
|
|
* We can attach an EventTarget that isn't an element.
|
|
*/
|
|
function testAttachEventTarget() {
|
|
var target = new goog.events.EventTarget();
|
|
|
|
assertNull(mh.activeElement_);
|
|
mh.attachInput(target);
|
|
assertNull(mh.activeElement_);
|
|
|
|
target.dispatchEvent(new goog.events.Event('focus', mockElement));
|
|
assertEquals(mockElement, mh.activeElement_);
|
|
|
|
mh.detachInput(target);
|
|
}
|
|
|
|
|
|
/**
|
|
* Make sure an already-focused element becomes active immediately.
|
|
*/
|
|
function testActiveElementAlreadyFocused() {
|
|
var element = document.getElementById('textInput');
|
|
element.style.display = '';
|
|
element.focus();
|
|
|
|
assertNull(mh.activeElement_);
|
|
|
|
mh.attachInput(element);
|
|
assertEquals(element, mh.activeElement_);
|
|
|
|
mh.detachInput(element);
|
|
element.style.display = 'none';
|
|
}
|
|
|
|
function testUpdateDoesNotTriggerSetTokenForSelectRow() {
|
|
|
|
var ih = new goog.ui.ac.InputHandler();
|
|
|
|
// Set up our input handler with the necessary mocks
|
|
var mockAutoCompleter = new MockAutoCompleter();
|
|
ih.ac_ = mockAutoCompleter;
|
|
ih.activeElement_ = mockElement;
|
|
|
|
var row = {};
|
|
ih.selectRow(row, false);
|
|
|
|
ih.update();
|
|
assertFalse('update should not call setToken on selectRow',
|
|
mockAutoCompleter.setTokenWasCalled);
|
|
|
|
ih.update();
|
|
assertFalse('update should not call setToken on selectRow',
|
|
mockAutoCompleter.setTokenWasCalled);
|
|
}
|
|
|
|
function testSetTokenText() {
|
|
|
|
var ih = new MockInputHandler();
|
|
|
|
// Set up our input handler with the necessary mocks
|
|
var mockAutoCompleter = new MockAutoCompleter();
|
|
ih.ac_ = mockAutoCompleter;
|
|
ih.activeElement_ = mockElement;
|
|
mockElement.value = 'bob, wal, joey';
|
|
ih.setCursorPosition(8);
|
|
|
|
ih.setTokenText('waldo', true /* multi-row */);
|
|
|
|
assertEquals('bob, waldo, joey', mockElement.value);
|
|
}
|
|
|
|
function testSetTokenTextLeftHandSideOfToken() {
|
|
|
|
var ih = new MockInputHandler();
|
|
ih.setSeparators(' ');
|
|
ih.setWhitespaceWrapEntries(false);
|
|
|
|
// Set up our input handler with the necessary mocks
|
|
var mockAutoCompleter = new MockAutoCompleter();
|
|
ih.ac_ = mockAutoCompleter;
|
|
ih.activeElement_ = mockElement;
|
|
mockElement.value = 'foo bar';
|
|
// Sets cursor position right before 'bar'
|
|
ih.setCursorPosition(4);
|
|
|
|
ih.setTokenText('bar', true /* multi-row */);
|
|
|
|
assertEquals('foo bar ', mockElement.value);
|
|
}
|
|
|
|
function testEmptyTokenWithSeparator() {
|
|
var ih = new goog.ui.ac.InputHandler();
|
|
var mockAutoCompleter = new MockAutoCompleter();
|
|
ih.ac_ = mockAutoCompleter;
|
|
ih.activeElement_ = mockElement;
|
|
mockElement.value = ', ,';
|
|
// Sets cursor position before the second comma
|
|
goog.dom.selection.setStart(mockElement, 2);
|
|
|
|
ih.update();
|
|
assertTrue('update should call setToken on selectRow',
|
|
mockAutoCompleter.setTokenWasCalled);
|
|
assertEquals('update should be called with empty string',
|
|
'', mockAutoCompleter.setToken);
|
|
}
|
|
|
|
function testNonEmptyTokenWithSeparator() {
|
|
var ih = new goog.ui.ac.InputHandler();
|
|
var mockAutoCompleter = new MockAutoCompleter();
|
|
ih.ac_ = mockAutoCompleter;
|
|
ih.activeElement_ = mockElement;
|
|
mockElement.value = ', joe ,';
|
|
// Sets cursor position before the second comma
|
|
goog.dom.selection.setStart(mockElement, 5);
|
|
|
|
ih.update();
|
|
assertTrue('update should call setToken on selectRow',
|
|
mockAutoCompleter.setTokenWasCalled);
|
|
assertEquals('update should be called with expected string',
|
|
'joe', mockAutoCompleter.setToken);
|
|
}
|
|
|
|
function testGetThrottleTime() {
|
|
var ih = new goog.ui.ac.InputHandler();
|
|
ih.setThrottleTime(999);
|
|
assertEquals('throttle time set+get', 999, ih.getThrottleTime());
|
|
}
|
|
|
|
function testGetUpdateDuringTyping() {
|
|
var ih = new goog.ui.ac.InputHandler();
|
|
ih.setUpdateDuringTyping(false);
|
|
assertFalse('update during typing set+get', ih.getUpdateDuringTyping());
|
|
}
|
|
|
|
function testEnterToSelect() {
|
|
mh.fireEvent('focus', '');
|
|
mh.fireKeyEvents(goog.events.KeyCodes.ENTER, true, true, true);
|
|
assertTrue('Should hilite', mh.ac_.selectHilitedWasCalled);
|
|
assertFalse('Should NOT be dismissed', mh.ac_.dismissWasCalled);
|
|
}
|
|
|
|
function testEnterDoesNotSelectWhenClosed() {
|
|
mh.fireEvent('focus', '');
|
|
mh.ac_.isOpen = goog.functions.FALSE;
|
|
mh.fireKeyEvents(goog.events.KeyCodes.ENTER, true, true, true);
|
|
assertFalse('Should NOT hilite', mh.ac_.selectHilitedWasCalled);
|
|
assertTrue('Should be dismissed', mh.ac_.dismissWasCalled);
|
|
}
|
|
|
|
function testTabToSelect() {
|
|
mh.fireEvent('focus', '');
|
|
mh.fireKeyEvents(goog.events.KeyCodes.TAB, true, true, true);
|
|
assertTrue('Should hilite', mh.ac_.selectHilitedWasCalled);
|
|
assertFalse('Should NOT be dismissed', mh.ac_.dismissWasCalled);
|
|
}
|
|
|
|
function testTabDoesNotSelectWhenClosed() {
|
|
mh.fireEvent('focus', '');
|
|
mh.ac_.isOpen = goog.functions.FALSE;
|
|
mh.fireKeyEvents(goog.events.KeyCodes.TAB, true, true, true);
|
|
assertFalse('Should NOT hilite', mh.ac_.selectHilitedWasCalled);
|
|
assertTrue('Should be dismissed', mh.ac_.dismissWasCalled);
|
|
}
|
|
|
|
function testShiftTabDoesNotSelect() {
|
|
mh.fireEvent('focus', '');
|
|
mh.ac_.isOpen = goog.functions.TRUE;
|
|
mh.fireKeyEvents(goog.events.KeyCodes.TAB, true, true, true,
|
|
{shiftKey: true});
|
|
assertFalse('Should NOT hilite', mh.ac_.selectHilitedWasCalled);
|
|
assertTrue('Should be dismissed', mh.ac_.dismissWasCalled);
|
|
}
|
|
|
|
function testEmptySeparatorUsesDefaults() {
|
|
var inputHandler = new goog.ui.ac.InputHandler('');
|
|
assertFalse(inputHandler.separatorCheck_.test(''));
|
|
assertFalse(inputHandler.separatorCheck_.test('x'));
|
|
assertTrue(inputHandler.separatorCheck_.test(','));
|
|
}
|
|
|
|
function testMultipleSeparatorUsesEmptyDefaults() {
|
|
var inputHandler = new goog.ui.ac.InputHandler(',\n', null, true);
|
|
inputHandler.setWhitespaceWrapEntries(false);
|
|
inputHandler.setSeparators(',\n', '');
|
|
|
|
// Set up our input handler with the necessary mocks
|
|
var mockAutoCompleter = new MockAutoCompleter();
|
|
inputHandler.ac_ = mockAutoCompleter;
|
|
inputHandler.activeElement_ = mockElement;
|
|
mockElement.value = 'bob,wal';
|
|
inputHandler.setCursorPosition(8);
|
|
|
|
inputHandler.setTokenText('waldo', true /* multi-row */);
|
|
|
|
assertEquals('bob,waldo', mockElement.value);
|
|
}
|