1 /****************************************************************************
2 **
3 ** Copyright (C) 2015 The Qt Company Ltd.
4 ** Contact: http://www.qt.io/licensing/
5 **
6 ** This file is part of the test suite of the Qt Toolkit.
7 **
8 ** $QT_BEGIN_LICENSE:LGPL$
9 ** Commercial License Usage
10 ** Licensees holding valid commercial Qt licenses may use this file in
11 ** accordance with the commercial license agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and The Qt Company. For licensing terms
14 ** and conditions see http://www.qt.io/terms-conditions. For further
15 ** information use the contact form at http://www.qt.io/contact-us.
16 **
17 ** GNU Lesser General Public License Usage
18 ** Alternatively, this file may be used under the terms of the GNU Lesser
19 ** General Public License version 2.1 or version 3 as published by the Free
20 ** Software Foundation and appearing in the file LICENSE.LGPLv21 and
21 ** LICENSE.LGPLv3 included in the packaging of this file. Please review the
22 ** following information to ensure the GNU Lesser General Public License
23 ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
24 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
25 **
26 ** As a special exception, The Qt Company gives you certain additional
27 ** rights. These rights are described in The Qt Company LGPL Exception
28 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
29 **
30 ** GNU General Public License Usage
31 ** Alternatively, this file may be used under the terms of the GNU
32 ** General Public License version 3.0 as published by the Free Software
33 ** Foundation and appearing in the file LICENSE.GPL included in the
34 ** packaging of this file. Please review the following information to
35 ** ensure the GNU General Public License version 3.0 requirements will be
36 ** met: http://www.gnu.org/copyleft/gpl.html.
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41
42
43 #include <QtTest/QtTest>
44 #include <private/qapplication_p.h>
45 #include <qkeysequence.h>
46 #include <private/qkeysequence_p.h>
47 #include <QTranslator>
48 #include <QLibraryInfo>
49
50 //TESTED_CLASS=
51 //TESTED_FILES=
52
53 #ifdef Q_WS_MAC
54 #include <Carbon/Carbon.h>
55 struct MacSpecialKey {
56 int key;
57 ushort macSymbol;
58 };
59
60 static const int NumEntries = 21;
61 static const MacSpecialKey entries[NumEntries] = {
62 { Qt::Key_Escape, 0x238B },
63 { Qt::Key_Tab, 0x21E5 },
64 { Qt::Key_Backtab, 0x21E4 },
65 { Qt::Key_Backspace, 0x232B },
66 { Qt::Key_Return, 0x21B5 },
67 { Qt::Key_Enter, 0x21B5 },
68 { Qt::Key_Delete, 0x2326 },
69 { Qt::Key_Home, 0x2196 },
70 { Qt::Key_End, 0x2198 },
71 { Qt::Key_Left, 0x2190 },
72 { Qt::Key_Up, 0x2191 },
73 { Qt::Key_Right, 0x2192 },
74 { Qt::Key_Down, 0x2193 },
75 { Qt::Key_PageUp, 0x21DE },
76 { Qt::Key_PageDown, 0x21DF },
77 { Qt::Key_Shift, kShiftUnicode },
78 { Qt::Key_Control, kCommandUnicode },
79 { Qt::Key_Meta, kControlUnicode },
80 { Qt::Key_Alt, kOptionUnicode },
81 { Qt::Key_CapsLock, 0x21EA },
82 };
83
operator <(const MacSpecialKey & entry,int key)84 static bool operator<(const MacSpecialKey &entry, int key)
85 {
86 return entry.key < key;
87 }
88
operator <(int key,const MacSpecialKey & entry)89 static bool operator<(int key, const MacSpecialKey &entry)
90 {
91 return key < entry.key;
92 }
93
94 static const MacSpecialKey * const MacSpecialKeyEntriesEnd = entries + NumEntries;
95
macSymbolForQtKey(int key)96 static QChar macSymbolForQtKey(int key)
97 {
98 const MacSpecialKey *i = qBinaryFind(entries, MacSpecialKeyEntriesEnd, key);
99 if (i == MacSpecialKeyEntriesEnd)
100 return QChar();
101 return QChar(i->macSymbol);
102 }
103
104 #endif
105
106 class tst_QKeySequence : public QObject
107 {
108 Q_OBJECT
109
110 public:
111 tst_QKeySequence();
112 virtual ~tst_QKeySequence();
113
114 private slots:
115 void swap();
116 void operatorQString_data();
117 void operatorQString();
118 void compareConstructors_data();
119 void compareConstructors();
120 void symetricConstructors_data();
121 void symetricConstructors();
122 void checkMultipleNames();
123 void checkMultipleCodes();
124 void mnemonic_data();
125 void mnemonic();
126 void toString_data();
127 void toString();
128 void streamOperators_data();
129 void streamOperators();
130 void fromString_data();
131 void fromString();
132 void ensureSorted();
133 void standardKeys_data();
134 void standardKeys();
135 void keyBindings();
136 void translated_data();
137 void translated();
138 void i18nKeys_data();
139 void i18nKeys();
140
141
142 void initTestCase();
143 private:
144 QTranslator *ourTranslator;
145 QTranslator *qtTranslator;
146 #ifdef Q_WS_MAC
147 static const QString MacCtrl;
148 static const QString MacMeta;
149 static const QString MacAlt;
150 static const QString MacShift;
151 #endif
152
153
154 };
155
156 #ifdef Q_WS_MAC
157 const QString tst_QKeySequence::MacCtrl = QString(QChar(0x2318));
158 const QString tst_QKeySequence::MacMeta = QString(QChar(0x2303));
159 const QString tst_QKeySequence::MacAlt = QString(QChar(0x2325));
160 const QString tst_QKeySequence::MacShift = QString(QChar(0x21E7));
161 #endif
162
tst_QKeySequence()163 tst_QKeySequence::tst_QKeySequence()
164 {
165 }
166
~tst_QKeySequence()167 tst_QKeySequence::~tst_QKeySequence()
168 {
169
170 }
171
initTestCase()172 void tst_QKeySequence::initTestCase()
173 {
174 ourTranslator = new QTranslator(this);
175 ourTranslator->load(":/keys_de");
176 qtTranslator = new QTranslator(this);
177 qtTranslator->load(":/qt_de");
178 }
179
swap()180 void tst_QKeySequence::swap()
181 {
182 QKeySequence ks1(Qt::CTRL+Qt::Key_O);
183 QKeySequence ks2(Qt::CTRL+Qt::Key_L);
184 ks1.swap(ks2);
185 QCOMPARE(ks1[0], int(Qt::CTRL+Qt::Key_L));
186 QCOMPARE(ks2[0], int(Qt::CTRL+Qt::Key_O));
187 }
188
operatorQString_data()189 void tst_QKeySequence::operatorQString_data()
190 {
191 QTest::addColumn<int>("modifiers");
192 QTest::addColumn<int>("keycode");
193 QTest::addColumn<QString>("keystring");
194
195 QTest::newRow( "No modifier" ) << 0 << int(Qt::Key_Aring | Qt::UNICODE_ACCEL) << QString( "\x0c5" );
196
197 #ifndef Q_WS_MAC
198 QTest::newRow( "Ctrl+Left" ) << int(Qt::CTRL) << int(Qt::Key_Left) << QString( "Ctrl+Left" );
199 QTest::newRow( "Ctrl+," ) << int(Qt::CTRL) << int(Qt::Key_Comma) << QString( "Ctrl+," );
200 QTest::newRow( "Alt+Left" ) << int(Qt::ALT) << int(Qt::Key_Left) << QString( "Alt+Left" );
201 QTest::newRow( "Alt+Shift+Left" ) << int(Qt::ALT | Qt::SHIFT) << int(Qt::Key_Left) << QString( "Alt+Shift+Left" );
202 QTest::newRow( "Ctrl" ) << int(Qt::CTRL) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL) << QString( "Ctrl+\x0c5" );
203 QTest::newRow( "Alt" ) << int(Qt::ALT) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL) << QString( "Alt+\x0c5" );
204 QTest::newRow( "Shift" ) << int(Qt::SHIFT) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL) << QString( "Shift+\x0c5" );
205 QTest::newRow( "Meta" ) << int(Qt::META) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL) << QString( "Meta+\x0c5" );
206 #else
207 QTest::newRow( "Ctrl+Left" ) << int(Qt::CTRL) << int(Qt::Key_Left) << MacCtrl + macSymbolForQtKey(Qt::Key_Left);
208 QTest::newRow( "Ctrl+," ) << int(Qt::CTRL) << int(Qt::Key_Comma) << MacCtrl + ",";
209 QTest::newRow( "Alt+Left" ) << int(Qt::ALT) << int(Qt::Key_Left) << MacAlt + macSymbolForQtKey(Qt::Key_Left);
210 QTest::newRow( "Alt+Shift+Left" ) << int(Qt::ALT | Qt::SHIFT) << int(Qt::Key_Left) << MacAlt + MacShift + macSymbolForQtKey(Qt::Key_Left);
211 QTest::newRow( "Ctrl" ) << int(Qt::CTRL) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL) << MacCtrl + "\x0c5";
212 QTest::newRow( "Alt" ) << int(Qt::ALT) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL) << MacAlt + "\x0c5";
213 QTest::newRow( "Shift" ) << int(Qt::SHIFT) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL) << MacShift + "\x0c5";
214 QTest::newRow( "Meta" ) << int(Qt::META) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL) << MacMeta + "\x0c5";
215 #endif
216 }
217
symetricConstructors_data()218 void tst_QKeySequence::symetricConstructors_data()
219 {
220 QTest::addColumn<int>("modifiers");
221 QTest::addColumn<int>("keycode");
222
223 QTest::newRow( "No modifier" ) << 0 << int(Qt::Key_Aring | Qt::UNICODE_ACCEL);
224 QTest::newRow( "Ctrl" ) << int(Qt::CTRL) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL);
225 QTest::newRow( "Alt" ) << int(Qt::ALT) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL);
226 QTest::newRow( "Shift" ) << int(Qt::SHIFT) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL);
227 QTest::newRow( "Meta" ) << int(Qt::META) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL);
228 }
229
compareConstructors_data()230 void tst_QKeySequence::compareConstructors_data()
231 {
232 operatorQString_data();
233 }
234
235 // operator QString()
operatorQString()236 void tst_QKeySequence::operatorQString()
237 {
238 QKeySequence seq;
239 QFETCH( int, modifiers );
240 QFETCH( int, keycode );
241 QFETCH( QString, keystring );
242
243 seq = QKeySequence( modifiers | keycode );
244
245 QCOMPARE( (QString)seq, keystring );
246 }
247
248 // this verifies that the constructors can handle the same strings in and out
symetricConstructors()249 void tst_QKeySequence::symetricConstructors()
250 {
251 QFETCH( int, modifiers );
252 QFETCH( int, keycode );
253
254 QKeySequence seq1( modifiers | keycode );
255 QKeySequence seq2( (QString)seq1 );
256
257 QVERIFY( seq1 == seq2 );
258 }
259
260 /* Compares QKeySequence constructurs with int or QString arguments
261 We don't do this for 3.0 since it doesn't support unicode accelerators */
compareConstructors()262 void tst_QKeySequence::compareConstructors()
263 {
264 QFETCH( int, modifiers );
265 QFETCH( int, keycode );
266 QFETCH( QString, keystring );
267
268 QKeySequence qstringSeq( keystring );
269 QKeySequence intSeq( modifiers | keycode );
270
271 QVERIFY( qstringSeq == intSeq );
272 }
273
checkMultipleNames()274 void tst_QKeySequence::checkMultipleNames()
275 {
276 QKeySequence oldK( "Ctrl+Page Up" );
277 QKeySequence newK( "Ctrl+PgUp" );
278 QVERIFY( oldK == newK );
279 }
280
281 //TODO: could test third constructor, or test fromString on all constructor-data
checkMultipleCodes()282 void tst_QKeySequence::checkMultipleCodes()
283 {
284 QKeySequence seq1("Alt+d, l");
285 QKeySequence seq2 = QKeySequence::fromString("Alt+d, l");
286 QVERIFY( seq1 == seq2 );
287
288 QKeySequence seq3("Alt+d,l");
289 QKeySequence seq4 = QKeySequence::fromString("Alt+d,l");
290 QVERIFY( seq3 == seq4 );
291 }
292
293 /*
294 * We must ensure that the keyBindings data is always sorted
295 * so that we can safely perform binary searches.
296 */
ensureSorted()297 void tst_QKeySequence::ensureSorted()
298 {
299 //### accessing static members from private classes does not work on msvc at the moment
300 #if defined(QT_BUILD_INTERNAL) && !defined(Q_WS_WIN)
301 uint N = QKeySequencePrivate::numberOfKeyBindings;
302 uint val = QKeySequencePrivate::keyBindings[0].shortcut;
303 for ( uint i = 1 ; i < N ; ++i) {
304 uint nextval = QKeySequencePrivate::keyBindings[i].shortcut;
305 if (nextval < val)
306 qDebug() << "Data not sorted at index " << i;
307 QVERIFY(nextval >= val);
308 val = nextval;
309 }
310 #endif
311 }
312
standardKeys_data()313 void tst_QKeySequence::standardKeys_data()
314 {
315 QTest::addColumn<int>("standardKey");
316 QTest::addColumn<QString>("expected");
317 QTest::newRow("unknownkey") << (int)QKeySequence::UnknownKey<< QString("");
318 QTest::newRow("copy") << (int)QKeySequence::Copy << QString("CTRL+C");
319 QTest::newRow("cut") << (int)QKeySequence::Cut << QString("CTRL+X");
320 QTest::newRow("paste") << (int)QKeySequence::Paste << QString("CTRL+V");
321 QTest::newRow("delete") << (int)QKeySequence::Delete<< QString("DEL");
322 QTest::newRow("open") << (int)QKeySequence::Open << QString("CTRL+O");
323 QTest::newRow("find") << (int)QKeySequence::Find<< QString("CTRL+F");
324 #ifdef Q_WS_WIN
325 QTest::newRow("addTab") << (int)QKeySequence::AddTab<< QString("CTRL+T");
326 QTest::newRow("findNext") << (int)QKeySequence::FindNext<< QString("F3");
327 QTest::newRow("findPrevious") << (int)QKeySequence::FindPrevious << QString("SHIFT+F3");
328 QTest::newRow("close") << (int)QKeySequence::Close<< QString("CTRL+F4");
329 QTest::newRow("replace") << (int)QKeySequence::Replace<< QString("CTRL+H");
330 #endif
331 QTest::newRow("bold") << (int)QKeySequence::Bold << QString("CTRL+B");
332 QTest::newRow("italic") << (int)QKeySequence::Italic << QString("CTRL+I");
333 QTest::newRow("underline") << (int)QKeySequence::Underline << QString("CTRL+U");
334 QTest::newRow("selectall") << (int)QKeySequence::SelectAll << QString("CTRL+A");
335 QTest::newRow("print") << (int)QKeySequence::Print << QString("CTRL+P");
336 QTest::newRow("movenextchar") << (int)QKeySequence::MoveToNextChar<< QString("RIGHT");
337 QTest::newRow("zoomIn") << (int)QKeySequence::ZoomIn<< QString("CTRL++");
338 QTest::newRow("zoomOut") << (int)QKeySequence::ZoomOut<< QString("CTRL+-");
339 QTest::newRow("whatsthis") << (int)QKeySequence::WhatsThis<< QString("SHIFT+F1");
340
341 #if defined(Q_WS_MAC)
342 QTest::newRow("help") << (int)QKeySequence::HelpContents<< QString("Ctrl+?");
343 QTest::newRow("nextChild") << (int)QKeySequence::NextChild << QString("CTRL+}");
344 QTest::newRow("previousChild") << (int)QKeySequence::PreviousChild << QString("CTRL+{");
345 QTest::newRow("MoveToEndOfBlock") << (int)QKeySequence::MoveToEndOfBlock << QString("ALT+DOWN");
346 QTest::newRow("forward") << (int)QKeySequence::Forward << QString("CTRL+]");
347 QTest::newRow("backward") << (int)QKeySequence::Back << QString("CTRL+[");
348 QTest::newRow("SelectEndOfDocument") << (int)QKeySequence::SelectEndOfDocument<< QString("CTRL+SHIFT+DOWN"); //mac only
349 #elif defined(Q_WS_S60)
350 QTest::newRow("help") << (int)QKeySequence::HelpContents<< QString("F2");
351 QTest::newRow("SelectEndOfDocument") << (int)QKeySequence::SelectEndOfDocument<< QString("CTRL+SHIFT+END"); //mac only
352 #else
353 QTest::newRow("help") << (int)QKeySequence::HelpContents<< QString("F1");
354 QTest::newRow("nextChild") << (int)QKeySequence::NextChild<< QString("CTRL+Tab");
355 QTest::newRow("previousChild") << (int)QKeySequence::PreviousChild<< QString("CTRL+SHIFT+BACKTAB");
356 QTest::newRow("forward") << (int)QKeySequence::Forward << QString("ALT+RIGHT");
357 QTest::newRow("backward") << (int)QKeySequence::Back << QString("ALT+LEFT");
358 QTest::newRow("MoveToEndOfBlock") << (int)QKeySequence::MoveToEndOfBlock<< QString(""); //mac only
359 QTest::newRow("SelectEndOfDocument") << (int)QKeySequence::SelectEndOfDocument<< QString("CTRL+SHIFT+END"); //mac only
360 #endif
361 }
362
standardKeys()363 void tst_QKeySequence::standardKeys()
364 {
365 QFETCH(int, standardKey);
366 QFETCH(QString, expected);
367 QKeySequence ks((QKeySequence::StandardKey)standardKey);
368 QKeySequence ks2(expected);
369 QVERIFY(ks == ks2);
370 }
371
keyBindings()372 void tst_QKeySequence::keyBindings()
373 {
374 QList<QKeySequence> bindings = QKeySequence::keyBindings(QKeySequence::Copy);
375 QList<QKeySequence> expected;
376 #if defined(Q_WS_MAC) || defined (Q_WS_S60)
377 expected << QKeySequence("CTRL+C");
378 #elif defined Q_WS_X11
379 expected << QKeySequence("CTRL+C") << QKeySequence("F16") << QKeySequence("CTRL+INSERT");
380 #else
381 expected << QKeySequence("CTRL+C") << QKeySequence("CTRL+INSERT");
382 #endif
383 QVERIFY(bindings == expected);
384 }
385
386
387
mnemonic_data()388 void tst_QKeySequence::mnemonic_data()
389 {
390 QTest::addColumn<QString>("string");
391 QTest::addColumn<QString>("key");
392 QTest::addColumn<bool>("warning");
393
394 QTest::newRow("1") << QString::fromLatin1("&bonjour") << QString::fromLatin1("ALT+B") << false;
395 QTest::newRow("2") << QString::fromLatin1("&&bonjour") << QString() << false;
396 QTest::newRow("3") << QString::fromLatin1("&&bon&jour") << QString::fromLatin1("ALT+J") << false;
397 QTest::newRow("4") << QString::fromLatin1("&&bon&jo&ur") << QString::fromLatin1("ALT+J") << true;
398 QTest::newRow("5") << QString::fromLatin1("b&on&&jour") << QString::fromLatin1("ALT+O") << false;
399 QTest::newRow("6") << QString::fromLatin1("bonjour") << QString() << false;
400 QTest::newRow("7") << QString::fromLatin1("&&&bonjour") << QString::fromLatin1("ALT+B") << false;
401 QTest::newRow("8") << QString::fromLatin1("bonjour&&&") << QString() << false;
402 QTest::newRow("9") << QString::fromLatin1("bo&&nj&o&&u&r") << QString::fromLatin1("ALT+O") << true;
403 QTest::newRow("10") << QString::fromLatin1("BON&JOUR") << QString::fromLatin1("ALT+J") << false;
404 QTest::newRow("11") << QString::fromUtf8("bonjour") << QString() << false;
405 }
406
mnemonic()407 void tst_QKeySequence::mnemonic()
408 {
409 #ifdef Q_WS_MAC
410 QSKIP("mnemonics are not used on Mac OS X", SkipAll);
411 #endif
412 QFETCH(QString, string);
413 QFETCH(QString, key);
414 QFETCH(bool, warning);
415
416 #ifndef QT_NO_DEBUG
417 if (warning) {
418 QString str = QString::fromLatin1("QKeySequence::mnemonic: \"%1\" contains multiple occurrences of '&'").arg(string);
419 QTest::ignoreMessage(QtWarningMsg, qPrintable(str));
420 // qWarning(qPrintable(str));
421 }
422 #endif
423 QKeySequence seq = QKeySequence::mnemonic(string);
424 QKeySequence res = QKeySequence(key);
425
426 QCOMPARE(seq, res);
427 }
428
429
430
toString_data()431 void tst_QKeySequence::toString_data()
432 {
433 QTest::addColumn<QString>("strSequence");
434 QTest::addColumn<QString>("neutralString");
435 QTest::addColumn<QString>("platformString");
436
437
438 #ifndef Q_WS_MAC
439 QTest::newRow("Ctrl+Left") << QString("Ctrl+Left") << QString("Ctrl+Left") << QString("Ctrl+Left");
440 QTest::newRow("Alt+Left") << QString("Alt+Left") << QString("Alt+Left") << QString("Alt+Left");
441 QTest::newRow("Alt+Shift+Left") << QString("Alt+Shift+Left") << QString("Alt+Shift+Left") << QString("Alt+Shift+Left");
442 QTest::newRow("Ctrl") << QString("Ctrl+\x0c5") << QString("Ctrl+\x0c5") << QString("Ctrl+\x0c5");
443 QTest::newRow("Alt") << QString("Alt+\x0c5") << QString("Alt+\x0c5") << QString("Alt+\x0c5");
444 QTest::newRow("Shift") << QString("Shift+\x0c5") << QString("Shift+\x0c5") << QString("Shift+\x0c5");
445 QTest::newRow("Meta") << QString("Meta+\x0c5") << QString("Meta+\x0c5") << QString("Meta+\x0c5");
446 QTest::newRow("Ctrl+Plus") << QString("Ctrl++") << QString("Ctrl++") << QString("Ctrl++");
447 QTest::newRow("Ctrl+,") << QString("Ctrl+,") << QString("Ctrl+,") << QString("Ctrl+,");
448 QTest::newRow("Ctrl+,,Ctrl+,") << QString("Ctrl+,,Ctrl+,") << QString("Ctrl+,, Ctrl+,") << QString("Ctrl+,, Ctrl+,");
449 QTest::newRow("MultiKey") << QString("Alt+X, Ctrl+Y, Z") << QString("Alt+X, Ctrl+Y, Z")
450 << QString("Alt+X, Ctrl+Y, Z");
451
452 QTest::newRow("Invalid") << QString("Ctrly") << QString("") << QString("");
453 #else
454 /*
455 QTest::newRow("Ctrl+Left") << MacCtrl + "Left" << QString("Ctrl+Left") << MacCtrl + macSymbolForQtKey(Qt::Key_Left);
456 QTest::newRow("Alt+Left") << MacAlt + "Left" << QString("Alt+Left") << MacAlt + macSymbolForQtKey(Qt::Key_Left);
457 QTest::newRow("Alt+Shift+Left") << MacAlt + MacShift + "Left" << QString("Alt+Shift+Left")
458 << MacAlt + MacShift + macSymbolForQtKey(Qt::Key_Left);
459 */
460 QTest::newRow("Ctrl+Right,Left") << MacCtrl + "Right, Left" << QString("Ctrl+Right, Left") << MacCtrl + macSymbolForQtKey(Qt::Key_Right) + QString(", ") + macSymbolForQtKey(Qt::Key_Left);
461 QTest::newRow("Ctrl") << MacCtrl + "\x0c5" << QString("Ctrl+\x0c5") << MacCtrl + "\x0c5";
462 QTest::newRow("Alt") << MacAlt + "\x0c5" << QString("Alt+\x0c5") << MacAlt + "\x0c5";
463 QTest::newRow("Shift") << MacShift + "\x0c5" << QString("Shift+\x0c5") << MacShift + "\x0c5";
464 QTest::newRow("Meta") << MacMeta + "\x0c5" << QString("Meta+\x0c5") << MacMeta + "\x0c5";
465 QTest::newRow("Ctrl+Plus") << MacCtrl + "+" << QString("Ctrl++") << MacCtrl + "+";
466 QTest::newRow("Ctrl+,") << MacCtrl + "," << QString("Ctrl+,") << MacCtrl + ",";
467 QTest::newRow("Ctrl+,,Ctrl+,") << MacCtrl + ",, " + MacCtrl + "," << QString("Ctrl+,, Ctrl+,") << MacCtrl + ",, " + MacCtrl + ",";
468 QTest::newRow("MultiKey") << MacAlt + "X, " + MacCtrl + "Y, Z" << QString("Alt+X, Ctrl+Y, Z")
469 << MacAlt + "X, " + MacCtrl + "Y, Z";
470 QTest::newRow("Invalid") << QString("Ctrly") << QString("") << QString("");
471 #endif
472 }
473
toString()474 void tst_QKeySequence::toString()
475 {
476 QFETCH(QString, strSequence);
477 QFETCH(QString, neutralString);
478 QFETCH(QString, platformString);
479
480 QKeySequence ks1(strSequence);
481
482 QCOMPARE(ks1.toString(QKeySequence::NativeText), platformString);
483 QCOMPARE(ks1.toString(QKeySequence::PortableText), neutralString);
484
485 }
486
streamOperators_data()487 void tst_QKeySequence::streamOperators_data()
488 {
489 operatorQString_data();
490 }
491
streamOperators()492 void tst_QKeySequence::streamOperators()
493 {
494 QFETCH( int, modifiers );
495 QFETCH( int, keycode );
496
497 QByteArray data;
498 QKeySequence refK( modifiers | keycode );
499 QKeySequence orgK( "Ctrl+A" );
500 QKeySequence copyOrgK = orgK;
501 QVERIFY( copyOrgK == orgK );
502
503 QDataStream in(&data, QIODevice::WriteOnly);
504 in << refK;
505 QDataStream out(&data, QIODevice::ReadOnly);
506 out >> orgK;
507
508 QVERIFY( orgK == refK );
509
510 // check if detached
511 QVERIFY( orgK != copyOrgK );
512 }
513
fromString_data()514 void tst_QKeySequence::fromString_data()
515 {
516 toString_data();
517 }
518
fromString()519 void tst_QKeySequence::fromString()
520 {
521 QFETCH(QString, strSequence);
522 QFETCH(QString, neutralString);
523 QFETCH(QString, platformString);
524
525 QKeySequence ks1(strSequence);
526 QKeySequence ks2 = QKeySequence::fromString(ks1.toString());
527 QKeySequence ks3 = QKeySequence::fromString(neutralString, QKeySequence::PortableText);
528 QKeySequence ks4 = QKeySequence::fromString(platformString, QKeySequence::NativeText);
529
530
531 // assume the transitive property exists here.
532 QCOMPARE(ks2, ks1);
533 QCOMPARE(ks3, ks1);
534 QCOMPARE(ks4, ks1);
535 }
536
translated_data()537 void tst_QKeySequence::translated_data()
538 {
539 qApp->installTranslator(ourTranslator);
540 qApp->installTranslator(qtTranslator);
541
542 QTest::addColumn<QString>("transKey");
543 QTest::addColumn<QString>("compKey");
544
545 QTest::newRow("Shift++") << tr("Shift++") << QString("Umschalt++");
546 QTest::newRow("Ctrl++") << tr("Ctrl++") << QString("Strg++");
547 QTest::newRow("Alt++") << tr("Alt++") << QString("Alt++");
548 QTest::newRow("Meta++") << tr("Meta++") << QString("Meta++");
549
550 QTest::newRow("Shift+,, Shift++") << tr("Shift+,, Shift++") << QString("Umschalt+,, Umschalt++");
551 QTest::newRow("Shift+,, Ctrl++") << tr("Shift+,, Ctrl++") << QString("Umschalt+,, Strg++");
552 QTest::newRow("Shift+,, Alt++") << tr("Shift+,, Alt++") << QString("Umschalt+,, Alt++");
553 QTest::newRow("Shift+,, Meta++") << tr("Shift+,, Meta++") << QString("Umschalt+,, Meta++");
554
555 QTest::newRow("Ctrl+,, Shift++") << tr("Ctrl+,, Shift++") << QString("Strg+,, Umschalt++");
556 QTest::newRow("Ctrl+,, Ctrl++") << tr("Ctrl+,, Ctrl++") << QString("Strg+,, Strg++");
557 QTest::newRow("Ctrl+,, Alt++") << tr("Ctrl+,, Alt++") << QString("Strg+,, Alt++");
558 QTest::newRow("Ctrl+,, Meta++") << tr("Ctrl+,, Meta++") << QString("Strg+,, Meta++");
559
560 qApp->removeTranslator(ourTranslator);
561 qApp->removeTranslator(qtTranslator);
562 }
563
translated()564 void tst_QKeySequence::translated()
565 {
566 QFETCH(QString, transKey);
567 QFETCH(QString, compKey);
568 #ifdef Q_WS_MAC
569 QSKIP("No need to translate modifiers on Mac OS X", SkipAll);
570 #elif defined(Q_OS_WINCE) || defined(Q_OS_SYMBIAN)
571 QSKIP("No need to translate modifiers on WinCE or Symbian", SkipAll);
572 #endif
573
574 qApp->installTranslator(ourTranslator);
575 qApp->installTranslator(qtTranslator);
576
577 QKeySequence ks1(transKey);
578 QCOMPARE(ks1.toString(QKeySequence::NativeText), compKey);
579
580 qApp->removeTranslator(ourTranslator);
581 qApp->removeTranslator(qtTranslator);
582 }
583
584
i18nKeys_data()585 void tst_QKeySequence::i18nKeys_data()
586 {
587 QTest::addColumn<int>("keycode");
588 QTest::addColumn<QString>("keystring");
589
590 // Japanese keyboard support
591 QTest::newRow("Kanji") << (int)Qt::Key_Kanji << QString("Kanji");
592 QTest::newRow("Muhenkan") << (int)Qt::Key_Muhenkan << QString("Muhenkan");
593 QTest::newRow("Henkan") << (int)Qt::Key_Henkan << QString("Henkan");
594 QTest::newRow("Romaji") << (int)Qt::Key_Romaji << QString("Romaji");
595 QTest::newRow("Hiragana") << (int)Qt::Key_Hiragana << QString("Hiragana");
596 QTest::newRow("Katakana") << (int)Qt::Key_Katakana << QString("Katakana");
597 QTest::newRow("Hiragana Katakana") << (int)Qt::Key_Hiragana_Katakana << QString("Hiragana Katakana");
598 QTest::newRow("Zenkaku") << (int)Qt::Key_Zenkaku << QString("Zenkaku");
599 QTest::newRow("Hankaku") << (int)Qt::Key_Hankaku << QString("Hankaku");
600 QTest::newRow("Zenkaku Hankaku") << (int)Qt::Key_Zenkaku_Hankaku << QString("Zenkaku Hankaku");
601 QTest::newRow("Touroku") << (int)Qt::Key_Touroku << QString("Touroku");
602 QTest::newRow("Massyo") << (int)Qt::Key_Massyo << QString("Massyo");
603 QTest::newRow("Kana Lock") << (int)Qt::Key_Kana_Lock << QString("Kana Lock");
604 QTest::newRow("Kana Shift") << (int)Qt::Key_Kana_Shift << QString("Kana Shift");
605 QTest::newRow("Eisu Shift") << (int)Qt::Key_Eisu_Shift << QString("Eisu Shift");
606 QTest::newRow("Eisu_toggle") << (int)Qt::Key_Eisu_toggle << QString("Eisu toggle");
607 QTest::newRow("Code input") << (int)Qt::Key_Codeinput << QString("Code input");
608 QTest::newRow("Multiple Candidate") << (int)Qt::Key_MultipleCandidate << QString("Multiple Candidate");
609 QTest::newRow("Previous Candidate") << (int)Qt::Key_PreviousCandidate << QString("Previous Candidate");
610
611 // Korean keyboard support
612 QTest::newRow("Hangul") << (int)Qt::Key_Hangul << QString("Hangul");
613 QTest::newRow("Hangul Start") << (int)Qt::Key_Hangul_Start << QString("Hangul Start");
614 QTest::newRow("Hangul End") << (int)Qt::Key_Hangul_End << QString("Hangul End");
615 QTest::newRow("Hangul Hanja") << (int)Qt::Key_Hangul_Hanja << QString("Hangul Hanja");
616 QTest::newRow("Hangul Jamo") << (int)Qt::Key_Hangul_Jamo << QString("Hangul Jamo");
617 QTest::newRow("Hangul Romaja") << (int)Qt::Key_Hangul_Romaja << QString("Hangul Romaja");
618 QTest::newRow("Hangul Jeonja") << (int)Qt::Key_Hangul_Jeonja << QString("Hangul Jeonja");
619 QTest::newRow("Hangul Banja") << (int)Qt::Key_Hangul_Banja << QString("Hangul Banja");
620 QTest::newRow("Hangul PreHanja") << (int)Qt::Key_Hangul_PreHanja << QString("Hangul PreHanja");
621 QTest::newRow("Hangul PostHanja") << (int)Qt::Key_Hangul_PostHanja << QString("Hangul PostHanja");
622 QTest::newRow("Hangul Special") << (int)Qt::Key_Hangul_Special << QString("Hangul Special");
623 }
624
i18nKeys()625 void tst_QKeySequence::i18nKeys()
626 {
627 QFETCH(int, keycode);
628 QFETCH(QString, keystring);
629 QKeySequence seq(keycode);
630
631 QCOMPARE(seq, QKeySequence(keystring));
632 QCOMPARE(seq.toString(), keystring);
633 }
634
635 QTEST_MAIN(tst_QKeySequence)
636 #include "tst_qkeysequence.moc"
637