1 | /**************************************************************************** |
---|---|
2 | ** |
3 | ** Copyright (C) 2016 The Qt Company Ltd. |
4 | ** Contact: https://www.qt.io/licensing/ |
5 | ** |
6 | ** This file is part of the test suite of the Qt Toolkit. |
7 | ** |
8 | ** $QT_BEGIN_LICENSE:GPL-EXCEPT$ |
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 https://www.qt.io/terms-conditions. For further |
15 | ** information use the contact form at https://www.qt.io/contact-us. |
16 | ** |
17 | ** GNU General Public License Usage |
18 | ** Alternatively, this file may be used under the terms of the GNU |
19 | ** General Public License version 3 as published by the Free Software |
20 | ** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT |
21 | ** included in the packaging of this file. Please review the following |
22 | ** information to ensure the GNU General Public License requirements will |
23 | ** be met: https://www.gnu.org/licenses/gpl-3.0.html. |
24 | ** |
25 | ** $QT_END_LICENSE$ |
26 | ** |
27 | ****************************************************************************/ |
28 | |
29 | |
30 | #include <QtTest/QtTest> |
31 | #include <qkeysequence.h> |
32 | #include <qpa/qplatformtheme.h> |
33 | #include <qpa/qplatformtheme_p.h> |
34 | #include <private/qguiapplication_p.h> |
35 | #include <QTranslator> |
36 | #include <QLibraryInfo> |
37 | |
38 | #ifdef Q_OS_MAC |
39 | struct MacSpecialKey { |
40 | int key; |
41 | ushort macSymbol; |
42 | }; |
43 | |
44 | // Unicode code points for the glyphs associated with these keys |
45 | // Defined by Carbon headers but not anywhere in Cocoa |
46 | static const int kShiftUnicode = 0x21E7; |
47 | static const int kControlUnicode = 0x2303; |
48 | static const int kOptionUnicode = 0x2325; |
49 | static const int kCommandUnicode = 0x2318; |
50 | |
51 | static const int NumEntries = 21; |
52 | static const MacSpecialKey entries[NumEntries] = { |
53 | { Qt::Key_Escape, 0x238B }, |
54 | { Qt::Key_Tab, 0x21E5 }, |
55 | { Qt::Key_Backtab, 0x21E4 }, |
56 | { Qt::Key_Backspace, 0x232B }, |
57 | { Qt::Key_Return, 0x21B5 }, |
58 | { Qt::Key_Enter, 0x21B5 }, |
59 | { Qt::Key_Delete, 0x2326 }, |
60 | { Qt::Key_Home, 0x2196 }, |
61 | { Qt::Key_End, 0x2198 }, |
62 | { Qt::Key_Left, 0x2190 }, |
63 | { Qt::Key_Up, 0x2191 }, |
64 | { Qt::Key_Right, 0x2192 }, |
65 | { Qt::Key_Down, 0x2193 }, |
66 | { Qt::Key_PageUp, 0x21DE }, |
67 | { Qt::Key_PageDown, 0x21DF }, |
68 | { Qt::Key_Shift, kShiftUnicode }, |
69 | { Qt::Key_Control, kCommandUnicode }, |
70 | { Qt::Key_Meta, kControlUnicode }, |
71 | { Qt::Key_Alt, kOptionUnicode }, |
72 | { Qt::Key_CapsLock, 0x21EA }, |
73 | }; |
74 | |
75 | static bool operator<(const MacSpecialKey &entry, int key) |
76 | { |
77 | return entry.key < key; |
78 | } |
79 | |
80 | static bool operator<(int key, const MacSpecialKey &entry) |
81 | { |
82 | return key < entry.key; |
83 | } |
84 | |
85 | static const MacSpecialKey * const MacSpecialKeyEntriesEnd = entries + NumEntries; |
86 | |
87 | static QChar macSymbolForQtKey(int key) |
88 | { |
89 | const MacSpecialKey *i = std::lower_bound(entries, MacSpecialKeyEntriesEnd, key); |
90 | if (i == MacSpecialKeyEntriesEnd) |
91 | return QChar(); |
92 | return QChar(i->macSymbol); |
93 | } |
94 | |
95 | #endif |
96 | |
97 | class tst_QKeySequence : public QObject |
98 | { |
99 | Q_OBJECT |
100 | |
101 | public: |
102 | tst_QKeySequence(); |
103 | virtual ~tst_QKeySequence(); |
104 | |
105 | private slots: |
106 | void swap(); |
107 | void operatorQString_data(); |
108 | void operatorQString(); |
109 | void compareConstructors_data(); |
110 | void compareConstructors(); |
111 | void symetricConstructors_data(); |
112 | void symetricConstructors(); |
113 | void checkMultipleNames(); |
114 | void checkMultipleCodes(); |
115 | void mnemonic_data(); |
116 | void mnemonic(); |
117 | void toString_data(); |
118 | void toString(); |
119 | void toStringFromKeycode_data(); |
120 | void toStringFromKeycode(); |
121 | void streamOperators_data(); |
122 | void streamOperators(); |
123 | void parseString_data(); |
124 | void parseString(); |
125 | void fromString_data(); |
126 | void fromString(); |
127 | void listToString_data(); |
128 | void listToString(); |
129 | void listFromString_data(); |
130 | void listFromString(); |
131 | #ifdef QT_BUILD_INTERNAL |
132 | void ensureSorted(); |
133 | #endif |
134 | void standardKeys_data(); |
135 | void standardKeys(); |
136 | void keyBindings(); |
137 | void translated_data(); |
138 | void translated(); |
139 | void i18nKeys_data(); |
140 | void i18nKeys(); |
141 | |
142 | |
143 | void initTestCase(); |
144 | private: |
145 | int m_keyboardScheme; |
146 | QTranslator *ourTranslator; |
147 | QTranslator *qtTranslator; |
148 | #ifdef Q_OS_MAC |
149 | static const QString MacCtrl; |
150 | static const QString MacMeta; |
151 | static const QString MacAlt; |
152 | static const QString MacShift; |
153 | #endif |
154 | |
155 | |
156 | }; |
157 | |
158 | #ifdef Q_OS_MAC |
159 | const QString tst_QKeySequence::MacCtrl = QString(QChar(0x2318)); |
160 | const QString tst_QKeySequence::MacMeta = QString(QChar(0x2303)); |
161 | const QString tst_QKeySequence::MacAlt = QString(QChar(0x2325)); |
162 | const QString tst_QKeySequence::MacShift = QString(QChar(0x21E7)); |
163 | #endif |
164 | |
165 | tst_QKeySequence::tst_QKeySequence() : m_keyboardScheme(QPlatformTheme::WindowsKeyboardScheme) |
166 | { |
167 | if (const QPlatformTheme *theme = QGuiApplicationPrivate::platformTheme()) |
168 | m_keyboardScheme = theme->themeHint(hint: QPlatformTheme::KeyboardScheme).toInt(); |
169 | } |
170 | |
171 | tst_QKeySequence::~tst_QKeySequence() |
172 | { |
173 | |
174 | } |
175 | |
176 | void tst_QKeySequence::initTestCase() |
177 | { |
178 | ourTranslator = new QTranslator(this); |
179 | ourTranslator->load(filename: ":/keys_de"); |
180 | qtTranslator = new QTranslator(this); |
181 | qtTranslator->load(filename: ":/qt_de"); |
182 | } |
183 | |
184 | void tst_QKeySequence::swap() |
185 | { |
186 | QKeySequence ks1(Qt::CTRL+Qt::Key_O); |
187 | QKeySequence ks2(Qt::CTRL+Qt::Key_L); |
188 | ks1.swap(other&: ks2); |
189 | QCOMPARE(ks1[0], int(Qt::CTRL+Qt::Key_L)); |
190 | QCOMPARE(ks2[0], int(Qt::CTRL+Qt::Key_O)); |
191 | } |
192 | |
193 | void tst_QKeySequence::operatorQString_data() |
194 | { |
195 | QTest::addColumn<int>(name: "modifiers"); |
196 | QTest::addColumn<int>(name: "keycode"); |
197 | QTest::addColumn<QString>(name: "keystring"); |
198 | |
199 | QTest::newRow( dataTag: "No modifier") << 0 << int(Qt::Key_Aring | Qt::UNICODE_ACCEL) << QString::fromLatin1( str: "\x0c5"); |
200 | |
201 | #ifndef Q_OS_MAC |
202 | QTest::newRow( dataTag: "Ctrl+Left") << int(Qt::CTRL) << int(Qt::Key_Left) << QString( "Ctrl+Left"); |
203 | QTest::newRow( dataTag: "Ctrl+,") << int(Qt::CTRL) << int(Qt::Key_Comma) << QString( "Ctrl+,"); |
204 | QTest::newRow( dataTag: "Alt+Left") << int(Qt::ALT) << int(Qt::Key_Left) << QString( "Alt+Left"); |
205 | QTest::newRow( dataTag: "Alt+Shift+Left") << int(Qt::ALT | Qt::SHIFT) << int(Qt::Key_Left) << QString( "Alt+Shift+Left"); |
206 | QTest::newRow( dataTag: "Ctrl") << int(Qt::CTRL) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL) << QString::fromLatin1( str: "Ctrl+\x0c5"); |
207 | QTest::newRow( dataTag: "Alt") << int(Qt::ALT) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL) << QString::fromLatin1( str: "Alt+\x0c5"); |
208 | QTest::newRow( dataTag: "Shift") << int(Qt::SHIFT) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL) << QString::fromLatin1( str: "Shift+\x0c5"); |
209 | QTest::newRow( dataTag: "Meta") << int(Qt::META) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL) << QString::fromLatin1( str: "Meta+\x0c5"); |
210 | #else |
211 | QTest::newRow( "Ctrl+Left") << int(Qt::CTRL) << int(Qt::Key_Left) << MacCtrl + macSymbolForQtKey(Qt::Key_Left); |
212 | QTest::newRow( "Ctrl+,") << int(Qt::CTRL) << int(Qt::Key_Comma) << MacCtrl + ","; |
213 | QTest::newRow( "Alt+Left") << int(Qt::ALT) << int(Qt::Key_Left) << MacAlt + macSymbolForQtKey(Qt::Key_Left); |
214 | QTest::newRow( "Alt+Shift+Left") << int(Qt::ALT | Qt::SHIFT) << int(Qt::Key_Left) << MacAlt + MacShift + macSymbolForQtKey(Qt::Key_Left); |
215 | QTest::newRow( "Ctrl") << int(Qt::CTRL) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL) << MacCtrl + QLatin1String( "\x0c5"); |
216 | QTest::newRow( "Alt") << int(Qt::ALT) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL) << MacAlt + QLatin1String( "\x0c5"); |
217 | QTest::newRow( "Shift") << int(Qt::SHIFT) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL) << MacShift + QLatin1String( "\x0c5"); |
218 | QTest::newRow( "Meta") << int(Qt::META) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL) << MacMeta + QLatin1String( "\x0c5"); |
219 | #endif |
220 | } |
221 | |
222 | void tst_QKeySequence::symetricConstructors_data() |
223 | { |
224 | QTest::addColumn<int>(name: "modifiers"); |
225 | QTest::addColumn<int>(name: "keycode"); |
226 | |
227 | QTest::newRow( dataTag: "No modifier") << 0 << int(Qt::Key_Aring | Qt::UNICODE_ACCEL); |
228 | QTest::newRow( dataTag: "Ctrl") << int(Qt::CTRL) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL); |
229 | QTest::newRow( dataTag: "Alt") << int(Qt::ALT) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL); |
230 | QTest::newRow( dataTag: "Shift") << int(Qt::SHIFT) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL); |
231 | QTest::newRow( dataTag: "Meta") << int(Qt::META) << int(Qt::Key_Aring | Qt::UNICODE_ACCEL); |
232 | } |
233 | |
234 | void tst_QKeySequence::compareConstructors_data() |
235 | { |
236 | operatorQString_data(); |
237 | } |
238 | |
239 | // operator QString() |
240 | void tst_QKeySequence::operatorQString() |
241 | { |
242 | QKeySequence seq; |
243 | QFETCH( int, modifiers ); |
244 | QFETCH( int, keycode ); |
245 | QFETCH( QString, keystring ); |
246 | |
247 | seq = QKeySequence( modifiers | keycode ); |
248 | |
249 | QCOMPARE( seq.toString(QKeySequence::NativeText), keystring ); |
250 | } |
251 | |
252 | // this verifies that the constructors can handle the same strings in and out |
253 | void tst_QKeySequence::symetricConstructors() |
254 | { |
255 | QFETCH( int, modifiers ); |
256 | QFETCH( int, keycode ); |
257 | |
258 | QKeySequence seq1( modifiers | keycode ); |
259 | QKeySequence seq2( seq1.toString(format: QKeySequence::NativeText) ); |
260 | |
261 | QVERIFY( seq1 == seq2 ); |
262 | } |
263 | |
264 | /* Compares QKeySequence constructurs with int or QString arguments |
265 | We don't do this for 3.0 since it doesn't support unicode accelerators */ |
266 | void tst_QKeySequence::compareConstructors() |
267 | { |
268 | QFETCH( int, modifiers ); |
269 | QFETCH( int, keycode ); |
270 | QFETCH( QString, keystring ); |
271 | |
272 | QKeySequence qstringSeq( keystring ); |
273 | QKeySequence intSeq( modifiers | keycode ); |
274 | |
275 | QVERIFY( qstringSeq == intSeq ); |
276 | } |
277 | |
278 | void tst_QKeySequence::checkMultipleNames() |
279 | { |
280 | QKeySequence oldK( "Ctrl+Page Up"); |
281 | QKeySequence newK( "Ctrl+PgUp"); |
282 | QVERIFY( oldK == newK ); |
283 | } |
284 | |
285 | //TODO: could test third constructor, or test fromString on all constructor-data |
286 | void tst_QKeySequence::checkMultipleCodes() |
287 | { |
288 | QKeySequence seq1("Alt+d, l"); |
289 | QKeySequence seq2 = QKeySequence::fromString(str: "Alt+d, l"); |
290 | QVERIFY( seq1 == seq2 ); |
291 | |
292 | QKeySequence seq3("Alt+d,l"); |
293 | QKeySequence seq4 = QKeySequence::fromString(str: "Alt+d,l"); |
294 | QVERIFY( seq3 == seq4 ); |
295 | } |
296 | |
297 | /* |
298 | * We must ensure that the keyBindings data are always sorted by standardKey |
299 | * so that we can safely perform binary searches. |
300 | */ |
301 | #ifdef QT_BUILD_INTERNAL |
302 | void tst_QKeySequence::ensureSorted() |
303 | { |
304 | uint N = QPlatformThemePrivate::numberOfKeyBindings; |
305 | uint val = QPlatformThemePrivate::keyBindings[0].standardKey; |
306 | for ( uint i = 1 ; i < N ; ++i) { |
307 | uint nextval = QPlatformThemePrivate::keyBindings[i].standardKey; |
308 | if (nextval < val) |
309 | qDebug() << "Data not sorted at index "<< i; |
310 | QVERIFY(nextval >= val); |
311 | val = nextval; |
312 | } |
313 | } |
314 | #endif |
315 | |
316 | void tst_QKeySequence::standardKeys_data() |
317 | { |
318 | QTest::addColumn<int>(name: "standardKey"); |
319 | QTest::addColumn<QString>(name: "expected"); |
320 | QTest::newRow(dataTag: "unknownkey") << (int)QKeySequence::UnknownKey<< QString( ""); |
321 | QTest::newRow(dataTag: "copy") << (int)QKeySequence::Copy << QString( "CTRL+C"); |
322 | QTest::newRow(dataTag: "cut") << (int)QKeySequence::Cut << QString( "CTRL+X"); |
323 | QTest::newRow(dataTag: "paste") << (int)QKeySequence::Paste << QString( "CTRL+V"); |
324 | QTest::newRow(dataTag: "delete") << (int)QKeySequence::Delete<< QString( "DEL"); |
325 | QTest::newRow(dataTag: "open") << (int)QKeySequence::Open << QString( "CTRL+O"); |
326 | QTest::newRow(dataTag: "find") << (int)QKeySequence::Find<< QString( "CTRL+F"); |
327 | if (m_keyboardScheme == QPlatformTheme::WindowsKeyboardScheme) { |
328 | QTest::newRow(dataTag: "addTab") << (int)QKeySequence::AddTab<< QString( "CTRL+T"); |
329 | QTest::newRow(dataTag: "findNext") << (int)QKeySequence::FindNext<< QString( "F3"); |
330 | QTest::newRow(dataTag: "findPrevious") << (int)QKeySequence::FindPrevious << QString( "SHIFT+F3"); |
331 | QTest::newRow(dataTag: "close") << (int)QKeySequence::Close<< QString( "CTRL+F4"); |
332 | QTest::newRow(dataTag: "replace") << (int)QKeySequence::Replace<< QString( "CTRL+H"); |
333 | } |
334 | QTest::newRow(dataTag: "bold") << (int)QKeySequence::Bold << QString( "CTRL+B"); |
335 | QTest::newRow(dataTag: "italic") << (int)QKeySequence::Italic << QString( "CTRL+I"); |
336 | QTest::newRow(dataTag: "underline") << (int)QKeySequence::Underline << QString( "CTRL+U"); |
337 | QTest::newRow(dataTag: "selectall") << (int)QKeySequence::SelectAll << QString( "CTRL+A"); |
338 | QTest::newRow(dataTag: "print") << (int)QKeySequence::Print << QString( "CTRL+P"); |
339 | QTest::newRow(dataTag: "movenextchar") << (int)QKeySequence::MoveToNextChar<< QString( "RIGHT"); |
340 | QTest::newRow(dataTag: "zoomIn") << (int)QKeySequence::ZoomIn<< QString( "CTRL++"); |
341 | QTest::newRow(dataTag: "zoomOut") << (int)QKeySequence::ZoomOut<< QString( "CTRL+-"); |
342 | QTest::newRow(dataTag: "whatsthis") << (int)QKeySequence::WhatsThis<< QString( "SHIFT+F1"); |
343 | |
344 | #if defined(Q_OS_MAC) |
345 | QTest::newRow("help") << (int)QKeySequence::HelpContents<< QString( "Ctrl+?"); |
346 | QTest::newRow("nextChild") << (int)QKeySequence::NextChild << QString( "CTRL+}"); |
347 | QTest::newRow("previousChild") << (int)QKeySequence::PreviousChild << QString( "CTRL+{"); |
348 | QTest::newRow("MoveToEndOfBlock") << (int)QKeySequence::MoveToEndOfBlock << QString( "ALT+DOWN"); |
349 | QTest::newRow("forward") << (int)QKeySequence::Forward << QString( "CTRL+]"); |
350 | QTest::newRow("backward") << (int)QKeySequence::Back << QString( "CTRL+["); |
351 | QTest::newRow("SelectEndOfDocument") << (int)QKeySequence::SelectEndOfDocument<< QString( "CTRL+SHIFT+DOWN"); //mac only |
352 | #else |
353 | QTest::newRow(dataTag: "help") << (int)QKeySequence::HelpContents<< QString( "F1"); |
354 | QTest::newRow(dataTag: "nextChild") << (int)QKeySequence::NextChild<< QString( "CTRL+Tab"); |
355 | QTest::newRow(dataTag: "previousChild") << (int)QKeySequence::PreviousChild<< QString( "CTRL+SHIFT+BACKTAB"); |
356 | QTest::newRow(dataTag: "forward") << (int)QKeySequence::Forward << QString( "ALT+RIGHT"); |
357 | QTest::newRow(dataTag: "backward") << (int)QKeySequence::Back << QString( "ALT+LEFT"); |
358 | QTest::newRow(dataTag: "MoveToEndOfBlock") << (int)QKeySequence::MoveToEndOfBlock<< QString( ""); //mac only |
359 | QTest::newRow(dataTag: "SelectEndOfDocument") << (int)QKeySequence::SelectEndOfDocument<< QString( "CTRL+SHIFT+END"); //mac only |
360 | #endif |
361 | } |
362 | |
363 | void tst_QKeySequence::standardKeys() |
364 | { |
365 | QFETCH(int, standardKey); |
366 | QFETCH(QString, expected); |
367 | QKeySequence actualKeySequence((QKeySequence::StandardKey)standardKey); |
368 | QKeySequence expectedKeySequence(expected); |
369 | QVERIFY2(actualKeySequence == expectedKeySequence, |
370 | qPrintable(QString::fromLatin1("Key mismatch, expected '%1', got '%2' for standard key %3"). |
371 | arg(expected, actualKeySequence.toString()).arg(standardKey))); |
372 | } |
373 | |
374 | void tst_QKeySequence::keyBindings() |
375 | { |
376 | const QList<QKeySequence> bindings = |
377 | QKeySequence::keyBindings(key: QKeySequence::Copy); |
378 | |
379 | QList<QKeySequence> expected; |
380 | const QKeySequence ctrlC = QKeySequence(QStringLiteral("CTRL+C")); |
381 | const QKeySequence ctrlInsert = QKeySequence(QStringLiteral("CTRL+INSERT")); |
382 | switch (m_keyboardScheme) { |
383 | case QPlatformTheme::MacKeyboardScheme: |
384 | expected << ctrlC; |
385 | break; |
386 | case QPlatformTheme::WindowsKeyboardScheme: |
387 | expected << ctrlC << ctrlInsert; |
388 | break; |
389 | default: // X11 |
390 | expected << ctrlC << ctrlInsert << QKeySequence(QStringLiteral("F16")); |
391 | break; |
392 | } |
393 | QCOMPARE(bindings, expected); |
394 | } |
395 | |
396 | void tst_QKeySequence::mnemonic_data() |
397 | { |
398 | #ifdef Q_OS_MAC |
399 | QSKIP("Test not applicable to OS X"); |
400 | #endif |
401 | QTest::addColumn<QString>(name: "string"); |
402 | QTest::addColumn<QString>(name: "key"); |
403 | QTest::addColumn<bool>(name: "warning"); |
404 | |
405 | QTest::newRow(dataTag: "1") << QString::fromLatin1(str: "&bonjour") << QString::fromLatin1(str: "ALT+B") << false; |
406 | QTest::newRow(dataTag: "2") << QString::fromLatin1(str: "&&bonjour") << QString() << false; |
407 | QTest::newRow(dataTag: "3") << QString::fromLatin1(str: "&&bon&jour") << QString::fromLatin1(str: "ALT+J") << false; |
408 | QTest::newRow(dataTag: "4") << QString::fromLatin1(str: "&&bon&jo&ur") << QString::fromLatin1(str: "ALT+J") << true; |
409 | QTest::newRow(dataTag: "5") << QString::fromLatin1(str: "b&on&&jour") << QString::fromLatin1(str: "ALT+O") << false; |
410 | QTest::newRow(dataTag: "6") << QString::fromLatin1(str: "bonjour") << QString() << false; |
411 | QTest::newRow(dataTag: "7") << QString::fromLatin1(str: "&&&bonjour") << QString::fromLatin1(str: "ALT+B") << false; |
412 | QTest::newRow(dataTag: "8") << QString::fromLatin1(str: "bonjour&&&") << QString() << false; |
413 | QTest::newRow(dataTag: "9") << QString::fromLatin1(str: "bo&&nj&o&&u&r") << QString::fromLatin1(str: "ALT+O") << true; |
414 | QTest::newRow(dataTag: "10") << QString::fromLatin1(str: "BON&JOUR") << QString::fromLatin1(str: "ALT+J") << false; |
415 | QTest::newRow(dataTag: "11") << QString::fromUtf8(str: "bonjour") << QString() << false; |
416 | } |
417 | |
418 | void tst_QKeySequence::mnemonic() |
419 | { |
420 | #ifndef Q_OS_MAC |
421 | QFETCH(QString, string); |
422 | QFETCH(QString, key); |
423 | QFETCH(bool, warning); |
424 | |
425 | #ifdef QT_NO_DEBUG |
426 | Q_UNUSED(warning) |
427 | #else |
428 | if (warning) { |
429 | QString str = QString::fromLatin1(str: "QKeySequence::mnemonic: \"%1\" contains multiple occurrences of '&'").arg(a: string); |
430 | QTest::ignoreMessage(type: QtWarningMsg, qPrintable(str)); |
431 | // qWarning(qPrintable(str)); |
432 | } |
433 | #endif |
434 | QKeySequence seq = QKeySequence::mnemonic(text: string); |
435 | QKeySequence res = QKeySequence(key); |
436 | |
437 | QCOMPARE(seq, res); |
438 | #endif |
439 | } |
440 | |
441 | void tst_QKeySequence::toString_data() |
442 | { |
443 | QTest::addColumn<QString>(name: "strSequence"); |
444 | QTest::addColumn<QString>(name: "neutralString"); |
445 | QTest::addColumn<QString>(name: "platformString"); |
446 | |
447 | |
448 | #ifndef Q_OS_MAC |
449 | QTest::newRow(dataTag: "Ctrl+Left") << QString( "Ctrl+Left") << QString( "Ctrl+Left") << QString( "Ctrl+Left"); |
450 | QTest::newRow(dataTag: "Alt+Left") << QString( "Alt+Left") << QString( "Alt+Left") << QString( "Alt+Left"); |
451 | QTest::newRow(dataTag: "Alt+Shift+Left") << QString( "Alt+Shift+Left") << QString( "Alt+Shift+Left") << QString( "Alt+Shift+Left"); |
452 | QTest::newRow(dataTag: "Ctrl") << QString::fromLatin1(str: "Ctrl+\x0c5") << QString::fromLatin1(str: "Ctrl+\x0c5") << QString::fromLatin1(str: "Ctrl+\x0c5"); |
453 | QTest::newRow(dataTag: "Alt") << QString::fromLatin1(str: "Alt+\x0c5") << QString::fromLatin1(str: "Alt+\x0c5") << QString::fromLatin1(str: "Alt+\x0c5"); |
454 | QTest::newRow(dataTag: "Shift") << QString::fromLatin1(str: "Shift+\x0c5") << QString::fromLatin1(str: "Shift+\x0c5") << QString::fromLatin1(str: "Shift+\x0c5"); |
455 | QTest::newRow(dataTag: "Meta") << QString::fromLatin1(str: "Meta+\x0c5") << QString::fromLatin1(str: "Meta+\x0c5") << QString::fromLatin1(str: "Meta+\x0c5"); |
456 | QTest::newRow(dataTag: "Ctrl+Plus") << QString( "Ctrl++") << QString( "Ctrl++") << QString( "Ctrl++"); |
457 | QTest::newRow(dataTag: "Ctrl+,") << QString( "Ctrl+,") << QString( "Ctrl+,") << QString( "Ctrl+,"); |
458 | QTest::newRow(dataTag: "Ctrl+,,Ctrl+,") << QString( "Ctrl+,,Ctrl+,") << QString( "Ctrl+,, Ctrl+,") << QString( "Ctrl+,, Ctrl+,"); |
459 | QTest::newRow(dataTag: "MultiKey") << QString( "Alt+X, Ctrl+Y, Z") << QString( "Alt+X, Ctrl+Y, Z") |
460 | << QString("Alt+X, Ctrl+Y, Z"); |
461 | |
462 | QTest::newRow(dataTag: "Invalid") << QString( "Ctrly") << QString( "") << QString( ""); |
463 | #else |
464 | /* |
465 | QTest::newRow("Ctrl+Left") << MacCtrl + "Left" << QString("Ctrl+Left") << MacCtrl + macSymbolForQtKey(Qt::Key_Left); |
466 | QTest::newRow("Alt+Left") << MacAlt + "Left" << QString("Alt+Left") << MacAlt + macSymbolForQtKey(Qt::Key_Left); |
467 | QTest::newRow("Alt+Shift+Left") << MacAlt + MacShift + "Left" << QString("Alt+Shift+Left") |
468 | << MacAlt + MacShift + macSymbolForQtKey(Qt::Key_Left); |
469 | */ |
470 | QTest::newRow("Ctrl+Right,Left") << MacCtrl + "Right, Left"<< QString( "Ctrl+Right, Left") << MacCtrl + macSymbolForQtKey(Qt::Key_Right) + QString( ", ") + macSymbolForQtKey(Qt::Key_Left); |
471 | QTest::newRow("Ctrl") << MacCtrl + QLatin1String( "\x0c5") << QString::fromLatin1( "Ctrl+\x0c5") << MacCtrl + QLatin1String( "\x0c5"); |
472 | QTest::newRow("Alt") << MacAlt + QLatin1String( "\x0c5") << QString::fromLatin1( "Alt+\x0c5") << MacAlt + QLatin1String( "\x0c5"); |
473 | QTest::newRow("Shift") << MacShift + QLatin1String( "\x0c5") << QString::fromLatin1( "Shift+\x0c5") << MacShift + QLatin1String( "\x0c5"); |
474 | QTest::newRow("Meta") << MacMeta + QLatin1String( "\x0c5") << QString::fromLatin1( "Meta+\x0c5") << MacMeta + QLatin1String( "\x0c5"); |
475 | QTest::newRow("Ctrl+Plus") << MacCtrl + "+"<< QString( "Ctrl++") << MacCtrl + "+"; |
476 | QTest::newRow("Ctrl+,") << MacCtrl + ","<< QString( "Ctrl+,") << MacCtrl + ","; |
477 | QTest::newRow("Ctrl+,,Ctrl+,") << MacCtrl + ",, "+ MacCtrl + ","<< QString( "Ctrl+,, Ctrl+,") << MacCtrl + ",, "+ MacCtrl + ","; |
478 | QTest::newRow("MultiKey") << MacAlt + "X, "+ MacCtrl + "Y, Z"<< QString( "Alt+X, Ctrl+Y, Z") |
479 | << MacAlt + "X, "+ MacCtrl + "Y, Z"; |
480 | QTest::newRow("Invalid") << QString( "Ctrly") << QString( "") << QString( ""); |
481 | #endif |
482 | } |
483 | |
484 | void tst_QKeySequence::toString() |
485 | { |
486 | QFETCH(QString, strSequence); |
487 | QFETCH(QString, neutralString); |
488 | QFETCH(QString, platformString); |
489 | |
490 | QKeySequence ks1(strSequence); |
491 | |
492 | QCOMPARE(ks1.toString(QKeySequence::NativeText), platformString); |
493 | QCOMPARE(ks1.toString(QKeySequence::PortableText), neutralString); |
494 | |
495 | } |
496 | |
497 | void tst_QKeySequence::toStringFromKeycode_data() |
498 | { |
499 | QTest::addColumn<QKeySequence>(name: "keycode"); |
500 | QTest::addColumn<QString>(name: "expectedString"); |
501 | |
502 | QTest::newRow(dataTag: "A") << QKeySequence(Qt::Key_A) << "A"; |
503 | QTest::newRow(dataTag: "-1") << QKeySequence(-1) << ""; |
504 | QTest::newRow(dataTag: "Unknown") << QKeySequence(Qt::Key_unknown) << ""; |
505 | QTest::newRow(dataTag: "Ctrl+Num+Ins") << QKeySequence(Qt::ControlModifier | Qt::KeypadModifier | Qt::Key_Insert) << "Ctrl+Num+Ins"; |
506 | QTest::newRow(dataTag: "Ctrl+Num+Del") << QKeySequence(Qt::ControlModifier | Qt::KeypadModifier | Qt::Key_Delete) << "Ctrl+Num+Del"; |
507 | QTest::newRow(dataTag: "Ctrl+Alt+Num+Del") << QKeySequence(Qt::ControlModifier | Qt::AltModifier | Qt::KeypadModifier | Qt::Key_Delete) << "Ctrl+Alt+Num+Del"; |
508 | QTest::newRow(dataTag: "Ctrl+Ins") << QKeySequence(Qt::ControlModifier | Qt::Key_Insert) << "Ctrl+Ins"; |
509 | QTest::newRow(dataTag: "Ctrl+Num+Ins(1)") << QKeySequence(Qt::Key_Insert | Qt::KeypadModifier | Qt::ControlModifier) << "Ctrl+Num+Ins"; |
510 | } |
511 | |
512 | void tst_QKeySequence::toStringFromKeycode() |
513 | { |
514 | QFETCH(QKeySequence, keycode); |
515 | QFETCH(QString, expectedString); |
516 | |
517 | QCOMPARE(QKeySequence(keycode).toString(), expectedString); |
518 | } |
519 | |
520 | void tst_QKeySequence::streamOperators_data() |
521 | { |
522 | operatorQString_data(); |
523 | } |
524 | |
525 | void tst_QKeySequence::streamOperators() |
526 | { |
527 | QFETCH( int, modifiers ); |
528 | QFETCH( int, keycode ); |
529 | |
530 | QByteArray data; |
531 | QKeySequence refK( modifiers | keycode ); |
532 | QKeySequence orgK( "Ctrl+A"); |
533 | QKeySequence copyOrgK = orgK; |
534 | QVERIFY( copyOrgK == orgK ); |
535 | |
536 | QDataStream in(&data, QIODevice::WriteOnly); |
537 | in << refK; |
538 | QDataStream out(&data, QIODevice::ReadOnly); |
539 | out >> orgK; |
540 | |
541 | QVERIFY( orgK == refK ); |
542 | |
543 | // check if detached |
544 | QVERIFY( orgK != copyOrgK ); |
545 | } |
546 | |
547 | |
548 | void tst_QKeySequence::parseString_data() |
549 | { |
550 | QTest::addColumn<QString>(name: "strSequence"); |
551 | QTest::addColumn<QKeySequence>(name: "keycode"); |
552 | |
553 | // Valid |
554 | QTest::newRow(dataTag: "A") << "A"<< QKeySequence(Qt::Key_A); |
555 | QTest::newRow(dataTag: "a") << "a"<< QKeySequence(Qt::Key_A); |
556 | QTest::newRow(dataTag: "Ctrl+Left") << "Ctrl+Left"<< QKeySequence(Qt::CTRL + Qt::Key_Left); |
557 | QTest::newRow(dataTag: "CTRL+LEFT") << "CTRL+LEFT"<< QKeySequence(Qt::CTRL + Qt::Key_Left); |
558 | QTest::newRow(dataTag: "Meta+A") << "Meta+a"<< QKeySequence(Qt::META + Qt::Key_A); |
559 | QTest::newRow(dataTag: "mEtA+A") << "mEtA+a"<< QKeySequence(Qt::META + Qt::Key_A); |
560 | QTest::newRow(dataTag: "Ctrl++") << "Ctrl++"<< QKeySequence(Qt::CTRL + Qt::Key_Plus); |
561 | |
562 | // Invalid modifiers |
563 | QTest::newRow(dataTag: "Win+A") << "Win+a"<< QKeySequence(Qt::Key_unknown); |
564 | QTest::newRow(dataTag: "Super+Meta+A") << "Super+Meta+A"<< QKeySequence(Qt::Key_unknown); |
565 | |
566 | // Invalid Keys |
567 | QTest::newRow(dataTag: "Meta+Trolls") << "Meta+Trolls"<< QKeySequence(Qt::Key_unknown); |
568 | QTest::newRow(dataTag: "Meta+Period") << "Meta+Period"<< QKeySequence(Qt::Key_unknown); |
569 | QTest::newRow(dataTag: "Meta+Ypsilon") << "Meta+Ypsilon"<< QKeySequence(Qt::Key_unknown); |
570 | |
571 | // Garbage |
572 | QTest::newRow(dataTag: "4+3=2") << "4+3=2"<< QKeySequence(Qt::Key_unknown); |
573 | QTest::newRow(dataTag: "Alabama") << "Alabama"<< QKeySequence(Qt::Key_unknown); |
574 | QTest::newRow(dataTag: "Simon+G") << "Simon+G"<< QKeySequence(Qt::Key_unknown); |
575 | QTest::newRow(dataTag: "Shift+++2") << "Shift+++2"<< QKeySequence(Qt::Key_unknown); |
576 | |
577 | // Wrong order |
578 | QTest::newRow(dataTag: "A+Meta") << "a+Meta"<< QKeySequence(Qt::Key_unknown); |
579 | QTest::newRow(dataTag: "Meta+++Shift") << "Meta+++Shift"<< QKeySequence(Qt::Key_unknown); |
580 | QTest::newRow(dataTag: "Meta+a+Shift") << "Meta+a+Shift"<< QKeySequence(Qt::Key_unknown); |
581 | |
582 | // Only Modifiers - currently not supported |
583 | //QTest::newRow("Meta+Shift") << "Meta+Shift" << QKeySequence(Qt::META + Qt::SHIFT); |
584 | //QTest::newRow("Ctrl") << "Ctrl" << QKeySequence(Qt::CTRL); |
585 | //QTest::newRow("Shift") << "Shift" << QKeySequence(Qt::SHIFT); |
586 | |
587 | // Only Keys |
588 | QTest::newRow(dataTag: "a") << "a"<< QKeySequence(Qt::Key_A); |
589 | QTest::newRow(dataTag: "A") << "A"<< QKeySequence(Qt::Key_A); |
590 | |
591 | // Incomplete |
592 | QTest::newRow(dataTag: "Meta+Shift+") << "Meta+Shift+"<< QKeySequence(Qt::Key_unknown); |
593 | } |
594 | |
595 | void tst_QKeySequence::parseString() |
596 | { |
597 | QFETCH( QString, strSequence ); |
598 | QFETCH( QKeySequence, keycode ); |
599 | |
600 | QCOMPARE( QKeySequence(strSequence).toString(), keycode.toString() ); |
601 | QVERIFY( QKeySequence(strSequence) == keycode ); |
602 | } |
603 | |
604 | void tst_QKeySequence::fromString_data() |
605 | { |
606 | toString_data(); |
607 | } |
608 | |
609 | void tst_QKeySequence::fromString() |
610 | { |
611 | QFETCH(QString, strSequence); |
612 | QFETCH(QString, neutralString); |
613 | QFETCH(QString, platformString); |
614 | |
615 | if (strSequence == "Ctrly") // Key_Unknown gives empty string |
616 | return; |
617 | |
618 | QKeySequence ks1(strSequence); |
619 | QKeySequence ks2 = QKeySequence::fromString(str: ks1.toString()); |
620 | QKeySequence ks3 = QKeySequence::fromString(str: neutralString, format: QKeySequence::PortableText); |
621 | QKeySequence ks4 = QKeySequence::fromString(str: platformString, format: QKeySequence::NativeText); |
622 | |
623 | |
624 | // assume the transitive property exists here. |
625 | QCOMPARE(ks2, ks1); |
626 | QCOMPARE(ks3, ks1); |
627 | QCOMPARE(ks4, ks1); |
628 | } |
629 | |
630 | void tst_QKeySequence::listToString_data() |
631 | { |
632 | QTest::addColumn<QString>(name: "strSequences"); |
633 | QTest::addColumn<QList<QKeySequence> >(name: "sequences"); |
634 | |
635 | QList<QKeySequence> sequences; |
636 | |
637 | sequences << QKeySequence(Qt::CTRL + Qt::Key_Left) |
638 | << QKeySequence(Qt::META + Qt::Key_A); |
639 | QTest::newRow(dataTag: "Ctrl+Left; Meta+A") << "Ctrl+Left; Meta+A"<< sequences; |
640 | |
641 | sequences.clear(); |
642 | sequences << QKeySequence(Qt::CTRL + Qt::Key_Semicolon) |
643 | << QKeySequence(Qt::META + Qt::Key_A); |
644 | QTest::newRow(dataTag: "Ctrl+;; Meta+A") << "Ctrl+;; Meta+A"<< sequences; |
645 | |
646 | sequences.clear(); |
647 | sequences << QKeySequence(Qt::Key_Semicolon) |
648 | << QKeySequence(Qt::META + Qt::Key_A); |
649 | QTest::newRow(dataTag: ";; Meta+A") << ";; Meta+A"<< sequences; |
650 | |
651 | sequences.clear(); |
652 | sequences << QKeySequence(Qt::CTRL + Qt::Key_Left) |
653 | << QKeySequence(Qt::META + Qt::Key_Semicolon); |
654 | QTest::newRow(dataTag: "Ctrl+Left; Meta+;") << "Ctrl+Left; Meta+;"<< sequences; |
655 | |
656 | sequences.clear(); |
657 | sequences << QKeySequence(Qt::CTRL + Qt::Key_Left) |
658 | << QKeySequence(); |
659 | QTest::newRow(dataTag: "Ctrl+Left; ") << "Ctrl+Left; "<< sequences; |
660 | |
661 | sequences.clear(); |
662 | sequences << QKeySequence(Qt::CTRL + Qt::Key_Left) |
663 | << QKeySequence() |
664 | << QKeySequence(Qt::META + Qt::Key_A); |
665 | QTest::newRow(dataTag: "Ctrl+Left; ; Meta+A") << "Ctrl+Left; ; Meta+A"<< sequences; |
666 | } |
667 | |
668 | void tst_QKeySequence::listToString() |
669 | { |
670 | QFETCH(QList<QKeySequence>, sequences); |
671 | QFETCH(QString, strSequences); |
672 | |
673 | QCOMPARE(QKeySequence::listToString(sequences), strSequences); |
674 | } |
675 | |
676 | void tst_QKeySequence::listFromString_data() |
677 | { |
678 | QTest::addColumn<QString>(name: "strSequences"); |
679 | QTest::addColumn<QList<QKeySequence> >(name: "sequences"); |
680 | |
681 | QList<QKeySequence> sequences; |
682 | |
683 | sequences << QKeySequence(Qt::CTRL + Qt::Key_Left) |
684 | << QKeySequence(Qt::META + Qt::Key_A); |
685 | QTest::newRow(dataTag: "Ctrl+Left; Meta+A") << "Ctrl+Left; Meta+A"<< sequences; |
686 | |
687 | sequences.clear(); |
688 | sequences << QKeySequence(Qt::CTRL + Qt::Key_Semicolon) |
689 | << QKeySequence(Qt::META + Qt::Key_A); |
690 | QTest::newRow(dataTag: "Ctrl+;; Meta+A") << "Ctrl+;; Meta+A"<< sequences; |
691 | |
692 | sequences.clear(); |
693 | sequences << QKeySequence(Qt::Key_Semicolon) |
694 | << QKeySequence(Qt::META + Qt::Key_A); |
695 | QTest::newRow(dataTag: ";; Meta+A") << ";; Meta+A"<< sequences; |
696 | |
697 | sequences.clear(); |
698 | sequences << QKeySequence(Qt::CTRL + Qt::Key_Left) |
699 | << QKeySequence(Qt::META + Qt::Key_Semicolon); |
700 | QTest::newRow(dataTag: "Ctrl+Left; Meta+;") << "Ctrl+Left; Meta+;"<< sequences; |
701 | |
702 | sequences.clear(); |
703 | sequences << QKeySequence(Qt::CTRL + Qt::Key_Left) |
704 | << QKeySequence(); |
705 | QTest::newRow(dataTag: "Ctrl+Left; ") << "Ctrl+Left; "<< sequences; |
706 | |
707 | sequences.clear(); |
708 | sequences << QKeySequence(Qt::CTRL + Qt::Key_Left) |
709 | << QKeySequence() |
710 | << QKeySequence(Qt::META + Qt::Key_A); |
711 | QTest::newRow(dataTag: "Ctrl+Left; ; Meta+A") << "Ctrl+Left; ; Meta+A"<< sequences; |
712 | |
713 | sequences.clear(); |
714 | sequences << QKeySequence(Qt::CTRL + Qt::Key_Left) |
715 | << QKeySequence(Qt::Key_unknown) |
716 | << QKeySequence(Qt::META + Qt::Key_A); |
717 | QTest::newRow(dataTag: "Ctrl+Left; 4+3=2; Meta+A") << "Ctrl+Left; 4+3=2; Meta+A"<< sequences; |
718 | } |
719 | |
720 | void tst_QKeySequence::listFromString() |
721 | { |
722 | QFETCH(QList<QKeySequence>, sequences); |
723 | QFETCH(QString, strSequences); |
724 | |
725 | QCOMPARE(QKeySequence::listFromString(strSequences), sequences); |
726 | } |
727 | |
728 | void tst_QKeySequence::translated_data() |
729 | { |
730 | #if defined (Q_OS_DARWIN) |
731 | QSKIP("Test not applicable"); |
732 | #endif |
733 | |
734 | qApp->installTranslator(messageFile: ourTranslator); |
735 | qApp->installTranslator(messageFile: qtTranslator); |
736 | |
737 | QTest::addColumn<QString>(name: "transKey"); |
738 | QTest::addColumn<QString>(name: "compKey"); |
739 | |
740 | QTest::newRow(dataTag: "Shift++") << tr(s: "Shift++") << QString( "Umschalt++"); |
741 | QTest::newRow(dataTag: "Ctrl++") << tr(s: "Ctrl++") << QString( "Strg++"); |
742 | QTest::newRow(dataTag: "Alt++") << tr(s: "Alt++") << QString( "Alt++"); |
743 | QTest::newRow(dataTag: "Meta++") << tr(s: "Meta++") << QString( "Meta++"); |
744 | |
745 | QTest::newRow(dataTag: "Shift+,, Shift++") << tr(s: "Shift+,, Shift++") << QString( "Umschalt+,, Umschalt++"); |
746 | QTest::newRow(dataTag: "Shift+,, Ctrl++") << tr(s: "Shift+,, Ctrl++") << QString( "Umschalt+,, Strg++"); |
747 | QTest::newRow(dataTag: "Shift+,, Alt++") << tr(s: "Shift+,, Alt++") << QString( "Umschalt+,, Alt++"); |
748 | QTest::newRow(dataTag: "Shift+,, Meta++") << tr(s: "Shift+,, Meta++") << QString( "Umschalt+,, Meta++"); |
749 | |
750 | QTest::newRow(dataTag: "Ctrl+,, Shift++") << tr(s: "Ctrl+,, Shift++") << QString( "Strg+,, Umschalt++"); |
751 | QTest::newRow(dataTag: "Ctrl+,, Ctrl++") << tr(s: "Ctrl+,, Ctrl++") << QString( "Strg+,, Strg++"); |
752 | QTest::newRow(dataTag: "Ctrl+,, Alt++") << tr(s: "Ctrl+,, Alt++") << QString( "Strg+,, Alt++"); |
753 | QTest::newRow(dataTag: "Ctrl+,, Meta++") << tr(s: "Ctrl+,, Meta++") << QString( "Strg+,, Meta++"); |
754 | |
755 | qApp->removeTranslator(messageFile: ourTranslator); |
756 | qApp->removeTranslator(messageFile: qtTranslator); |
757 | } |
758 | |
759 | void tst_QKeySequence::translated() |
760 | { |
761 | #if !defined (Q_OS_DARWIN) |
762 | QFETCH(QString, transKey); |
763 | QFETCH(QString, compKey); |
764 | |
765 | qApp->installTranslator(messageFile: ourTranslator); |
766 | qApp->installTranslator(messageFile: qtTranslator); |
767 | |
768 | QKeySequence ks1(transKey); |
769 | QCOMPARE(ks1.toString(QKeySequence::NativeText), compKey); |
770 | |
771 | qApp->removeTranslator(messageFile: ourTranslator); |
772 | qApp->removeTranslator(messageFile: qtTranslator); |
773 | #endif |
774 | } |
775 | |
776 | void tst_QKeySequence::i18nKeys_data() |
777 | { |
778 | QTest::addColumn<int>(name: "keycode"); |
779 | QTest::addColumn<QString>(name: "keystring"); |
780 | |
781 | // Japanese keyboard support |
782 | QTest::newRow(dataTag: "Kanji") << (int)Qt::Key_Kanji << QString( "Kanji"); |
783 | QTest::newRow(dataTag: "Muhenkan") << (int)Qt::Key_Muhenkan << QString( "Muhenkan"); |
784 | QTest::newRow(dataTag: "Henkan") << (int)Qt::Key_Henkan << QString( "Henkan"); |
785 | QTest::newRow(dataTag: "Romaji") << (int)Qt::Key_Romaji << QString( "Romaji"); |
786 | QTest::newRow(dataTag: "Hiragana") << (int)Qt::Key_Hiragana << QString( "Hiragana"); |
787 | QTest::newRow(dataTag: "Katakana") << (int)Qt::Key_Katakana << QString( "Katakana"); |
788 | QTest::newRow(dataTag: "Hiragana Katakana") << (int)Qt::Key_Hiragana_Katakana << QString( "Hiragana Katakana"); |
789 | QTest::newRow(dataTag: "Zenkaku") << (int)Qt::Key_Zenkaku << QString( "Zenkaku"); |
790 | QTest::newRow(dataTag: "Hankaku") << (int)Qt::Key_Hankaku << QString( "Hankaku"); |
791 | QTest::newRow(dataTag: "Zenkaku Hankaku") << (int)Qt::Key_Zenkaku_Hankaku << QString( "Zenkaku Hankaku"); |
792 | QTest::newRow(dataTag: "Touroku") << (int)Qt::Key_Touroku << QString( "Touroku"); |
793 | QTest::newRow(dataTag: "Massyo") << (int)Qt::Key_Massyo << QString( "Massyo"); |
794 | QTest::newRow(dataTag: "Kana Lock") << (int)Qt::Key_Kana_Lock << QString( "Kana Lock"); |
795 | QTest::newRow(dataTag: "Kana Shift") << (int)Qt::Key_Kana_Shift << QString( "Kana Shift"); |
796 | QTest::newRow(dataTag: "Eisu Shift") << (int)Qt::Key_Eisu_Shift << QString( "Eisu Shift"); |
797 | QTest::newRow(dataTag: "Eisu_toggle") << (int)Qt::Key_Eisu_toggle << QString( "Eisu toggle"); |
798 | QTest::newRow(dataTag: "Code input") << (int)Qt::Key_Codeinput << QString( "Code input"); |
799 | QTest::newRow(dataTag: "Multiple Candidate") << (int)Qt::Key_MultipleCandidate << QString( "Multiple Candidate"); |
800 | QTest::newRow(dataTag: "Previous Candidate") << (int)Qt::Key_PreviousCandidate << QString( "Previous Candidate"); |
801 | |
802 | // Korean keyboard support |
803 | QTest::newRow(dataTag: "Hangul") << (int)Qt::Key_Hangul << QString( "Hangul"); |
804 | QTest::newRow(dataTag: "Hangul Start") << (int)Qt::Key_Hangul_Start << QString( "Hangul Start"); |
805 | QTest::newRow(dataTag: "Hangul End") << (int)Qt::Key_Hangul_End << QString( "Hangul End"); |
806 | QTest::newRow(dataTag: "Hangul Hanja") << (int)Qt::Key_Hangul_Hanja << QString( "Hangul Hanja"); |
807 | QTest::newRow(dataTag: "Hangul Jamo") << (int)Qt::Key_Hangul_Jamo << QString( "Hangul Jamo"); |
808 | QTest::newRow(dataTag: "Hangul Romaja") << (int)Qt::Key_Hangul_Romaja << QString( "Hangul Romaja"); |
809 | QTest::newRow(dataTag: "Hangul Jeonja") << (int)Qt::Key_Hangul_Jeonja << QString( "Hangul Jeonja"); |
810 | QTest::newRow(dataTag: "Hangul Banja") << (int)Qt::Key_Hangul_Banja << QString( "Hangul Banja"); |
811 | QTest::newRow(dataTag: "Hangul PreHanja") << (int)Qt::Key_Hangul_PreHanja << QString( "Hangul PreHanja"); |
812 | QTest::newRow(dataTag: "Hangul PostHanja") << (int)Qt::Key_Hangul_PostHanja << QString( "Hangul PostHanja"); |
813 | QTest::newRow(dataTag: "Hangul Special") << (int)Qt::Key_Hangul_Special << QString( "Hangul Special"); |
814 | } |
815 | |
816 | void tst_QKeySequence::i18nKeys() |
817 | { |
818 | QFETCH(int, keycode); |
819 | QFETCH(QString, keystring); |
820 | QKeySequence seq(keycode); |
821 | |
822 | QCOMPARE(seq, QKeySequence(keystring)); |
823 | QCOMPARE(seq.toString(), keystring); |
824 | } |
825 | |
826 | QTEST_MAIN(tst_QKeySequence) |
827 | #include "tst_qkeysequence.moc" |
828 |
Definitions
- tst_QKeySequence
- tst_QKeySequence
- ~tst_QKeySequence
- initTestCase
- swap
- operatorQString_data
- symetricConstructors_data
- compareConstructors_data
- operatorQString
- symetricConstructors
- compareConstructors
- checkMultipleNames
- checkMultipleCodes
- ensureSorted
- standardKeys_data
- standardKeys
- keyBindings
- mnemonic_data
- mnemonic
- toString_data
- toString
- toStringFromKeycode_data
- toStringFromKeycode
- streamOperators_data
- streamOperators
- parseString_data
- parseString
- fromString_data
- fromString
- listToString_data
- listToString
- listFromString_data
- listFromString
- translated_data
- translated
- i18nKeys_data
Learn to use CMake with our Intro Training
Find out more