| /**************************************************************************** |
| ** |
| ** Copyright (C) 2016 The Qt Company Ltd. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the test suite of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:GPL-EXCEPT$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 3 as published by the Free Software |
| ** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT |
| ** included in the packaging of this file. Please review the following |
| ** information to ensure the GNU General Public License requirements will |
| ** be met: https://www.gnu.org/licenses/gpl-3.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include "tst_qmakelib.h" |
| |
| #include <proitems.h> |
| #include <qmakevfs.h> |
| #include <qmakeparser.h> |
| |
| class TokenStream |
| { |
| public: |
| TokenStream() {} |
| QString toString() const { return ts; } |
| |
| TokenStream &operator<<(ushort n) { ts += QChar(n); return *this; } |
| TokenStream &operator<<(uint n) { ts += QChar(n & 0xffff); ts += QChar(n >> 16); return *this; } |
| TokenStream &operator<<(const QStringRef &s) { ts += s; return *this; } |
| TokenStream &operator<<(const ProString &s) { return *this << ushort(s.length()) << s.toQStringRef(); } |
| TokenStream &operator<<(const ProKey &s) { return *this << s.hash() << s.toString(); } |
| |
| private: |
| QString ts; |
| }; |
| |
| #define TS(s) (TokenStream() s).toString() |
| #define H(n) ushort(n) |
| #define I(n) uint(n) |
| #define S(s) ProString(QString::fromWCharArray(s)) |
| #define HS(s) ProKey(QString::fromWCharArray(s)) |
| |
| QT_WARNING_PUSH |
| QT_WARNING_DISABLE_MSVC(4003) // "not enough actual parameters for macro TS()" |
| |
| void tst_qmakelib::addParseOperators() |
| { |
| QTest::newRow("assign none") |
| << "VAR =" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"VAR") |
| /* 9 */ << H(TokAssign) << H(0) |
| /* 11 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("append none") |
| << "VAR +=" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"VAR") |
| /* 9 */ << H(TokAppend) << H(0) |
| /* 11 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("unique append none") |
| << "VAR *=" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"VAR") |
| /* 9 */ << H(TokAppendUnique) << H(0) |
| /* 11 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("remove none") |
| << "VAR -=" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"VAR") |
| /* 9 */ << H(TokRemove) << H(0) |
| /* 11 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("replace empty") |
| << "VAR ~=" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"VAR") |
| /* 9 */ << H(TokReplace) << H(0) |
| /* 11 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("assignment without variable") |
| << "=" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokAssign) << H(0) |
| /* 4 */ << H(TokValueTerminator)) |
| << "in:1: Assignment needs exactly one word on the left hand side." |
| << false; |
| |
| QTest::newRow("assignment with multiple variables") |
| << "VAR VAR =" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokAssign) << H(0) |
| /* 4 */ << H(TokValueTerminator)) |
| << "in:1: Assignment needs exactly one word on the left hand side." |
| << false; |
| } |
| |
| void tst_qmakelib::addParseValues() |
| { |
| #define ASSIGN_VAR(h) \ |
| H(TokLine) << H(1) \ |
| << H(TokHashLiteral) << HS(L"VAR") \ |
| << H(TokAssign) << H(h) |
| |
| QTest::newRow("one literal") |
| << "VAR = val" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(0) |
| /* 11 */ << H(TokLiteral | TokNewStr) << S(L"val") |
| /* 16 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("one literal (squeezed)") |
| << "VAR=val" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(0) |
| /* 11 */ << H(TokLiteral | TokNewStr) << S(L"val") |
| /* 16 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("many literals") |
| << "VAR = foo barbaz bak hello" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(4) |
| /* 11 */ << H(TokLiteral | TokNewStr) << S(L"foo") |
| /* 16 */ << H(TokLiteral | TokNewStr) << S(L"barbaz") |
| /* 24 */ << H(TokLiteral | TokNewStr) << S(L"bak") |
| /* 29 */ << H(TokLiteral | TokNewStr) << S(L"hello") |
| /* 36 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("many literals (tab-separated") |
| << "VAR\t=\tfoo\tbarbaz\tbak\thello" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(4) |
| /* 11 */ << H(TokLiteral | TokNewStr) << S(L"foo") |
| /* 16 */ << H(TokLiteral | TokNewStr) << S(L"barbaz") |
| /* 24 */ << H(TokLiteral | TokNewStr) << S(L"bak") |
| /* 29 */ << H(TokLiteral | TokNewStr) << S(L"hello") |
| /* 36 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("one quoted literal") |
| << "VAR = \"val ue\"" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(0) |
| /* 11 */ << H(TokLiteral | TokNewStr) << S(L"val ue") |
| /* 19 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("quoted literal with missing quote") |
| << "VAR = val \"ue" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"VAR") |
| /* 9 */ << H(TokAssign) << H(0) |
| /* 11 */ << H(TokValueTerminator)) |
| << "in:1: Missing closing \" quote" |
| << false; |
| |
| QTest::newRow("many quoted literals") |
| << "VAR = \"foo\" barbaz 'bak hello' \"\"" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(3) |
| /* 11 */ << H(TokLiteral | TokNewStr) << S(L"foo") |
| /* 16 */ << H(TokLiteral | TokNewStr) << S(L"barbaz") |
| /* 24 */ << H(TokLiteral | TokNewStr) << S(L"bak hello") |
| /* 35 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("many quoted literals (with tabs)") |
| << "VAR\t=\t\"foo\"\tbarbaz\t'bak\thello'" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(3) |
| /* 11 */ << H(TokLiteral | TokNewStr) << S(L"foo") |
| /* 16 */ << H(TokLiteral | TokNewStr) << S(L"barbaz") |
| /* 24 */ << H(TokLiteral | TokNewStr) << S(L"bak\thello") |
| /* 35 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("quoted and unquoted spaces") |
| << " VAR = \"val ue \" " |
| << TS( |
| /* 0 */ << ASSIGN_VAR(0) |
| /* 11 */ << H(TokLiteral | TokNewStr) << S(L"val ue ") |
| /* 22 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("funny literals") |
| << "VAR = foo:bar|!baz(blam!, ${foo})" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(2) |
| /* 11 */ << H(TokLiteral | TokNewStr) << S(L"foo:bar|!baz(blam!,") |
| /* 32 */ << H(TokLiteral | TokNewStr) << S(L"${foo})") |
| /* 41 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("literals with escapes") |
| << "VAR = \\{hi\\} \\[ho\\] \\)uh\\( \"\\\\oh\\$\"\\' \\$\\${FOO}" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(5) |
| /* 11 */ << H(TokLiteral | TokNewStr) << S(L"{hi}") |
| /* 17 */ << H(TokLiteral | TokNewStr) << S(L"[ho]") |
| /* 23 */ << H(TokLiteral | TokNewStr) << S(L")uh(") |
| /* 29 */ << H(TokLiteral | TokNewStr) << S(L"\\oh$'") |
| /* 36 */ << H(TokLiteral | TokNewStr) << S(L"$${FOO}") |
| /* 45 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("magic variables") |
| << "VAR = $$LITERAL_HASH $$LITERAL_DOLLAR $$LITERAL_WHITESPACE $$_FILE_ $$_LINE_" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(5) |
| /* 11 */ << H(TokLiteral | TokNewStr) << S(L"#") |
| /* 14 */ << H(TokLiteral | TokNewStr) << S(L"$") |
| /* 17 */ << H(TokLiteral | TokNewStr) << S(L"\t") |
| /* 20 */ << H(TokLiteral | TokNewStr) << S(L"in") |
| /* 24 */ << H(TokLiteral | TokNewStr) << S(L"1") |
| /* 27 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("continuations and comments") |
| << "VAR = foo \\\n bar\n \n" |
| "GAR = foo \\ # comment\n bar \\\n # comment\n baz \\\n" |
| "\"quoted \\ #comment\n escape\" \\\n right\\\n after \\\n gorilla!\n \n\n" |
| "MOO = \\\n kuh # comment\nLOO =\n\n" |
| "FOO = bar \\\n# comment\n baz \\\n \n# comment\n" |
| "GAZ=" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"VAR") |
| /* 9 */ << H(TokAssign) << H(2) |
| /* 11 */ << H(TokLiteral | TokNewStr) << S(L"foo") |
| /* 16 */ << H(TokLiteral | TokNewStr) << S(L"bar") |
| /* 21 */ << H(TokValueTerminator) |
| /* 22 */ << H(TokLine) << H(4) |
| /* 24 */ << H(TokHashLiteral) << HS(L"GAR") |
| /* 31 */ << H(TokAssign) << H(7) |
| /* 33 */ << H(TokLiteral | TokNewStr) << S(L"foo") |
| /* 38 */ << H(TokLiteral | TokNewStr) << S(L"bar") |
| /* 43 */ << H(TokLiteral | TokNewStr) << S(L"baz") |
| /* 48 */ << H(TokLiteral | TokNewStr) << S(L"quoted escape") |
| /* 64 */ << H(TokLiteral | TokNewStr) << S(L"right") |
| /* 71 */ << H(TokLiteral | TokNewStr) << S(L"after") |
| /* 78 */ << H(TokLiteral | TokNewStr) << S(L"gorilla!") |
| /* 88 */ << H(TokValueTerminator) |
| /* 89 */ << H(TokLine) << H(15) |
| /* 91 */ << H(TokHashLiteral) << HS(L"MOO") |
| /* 98 */ << H(TokAssign) << H(0) |
| /* 100 */ << H(TokLiteral | TokNewStr) << S(L"kuh") |
| /* 105 */ << H(TokValueTerminator) |
| /* 106 */ << H(TokLine) << H(17) |
| /* 108 */ << H(TokHashLiteral) << HS(L"LOO") |
| /* 115 */ << H(TokAssign) << H(0) |
| /* 117 */ << H(TokValueTerminator) |
| /* 118 */ << H(TokLine) << H(19) |
| /* 120 */ << H(TokHashLiteral) << HS(L"FOO") |
| /* 127 */ << H(TokAssign) << H(2) |
| /* 129 */ << H(TokLiteral | TokNewStr) << S(L"bar") |
| /* 134 */ << H(TokLiteral | TokNewStr) << S(L"baz") |
| /* 139 */ << H(TokValueTerminator) |
| /* 140 */ << H(TokLine) << H(24) |
| /* 142 */ << H(TokHashLiteral) << HS(L"GAZ") |
| /* 149 */ << H(TokAssign) << H(0) |
| /* 151 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("accidental continuation") |
| << "VAR0 = \\\n this \\\n is \\\n ok\n" |
| "VAR1 = \\\n this \\\n is=still \\\n ok\n" |
| "VAR2 = \\\n this \\\n is \\\n" |
| "VAR3 = \\\n not ok\n" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"VAR0") |
| /* 10 */ << H(TokAssign) << H(3) |
| /* 12 */ << H(TokLiteral | TokNewStr) << S(L"this") |
| /* 18 */ << H(TokLiteral | TokNewStr) << S(L"is") |
| /* 22 */ << H(TokLiteral | TokNewStr) << S(L"ok") |
| /* 26 */ << H(TokValueTerminator) |
| /* 27 */ << H(TokLine) << H(5) |
| /* 29 */ << H(TokHashLiteral) << HS(L"VAR1") |
| /* 37 */ << H(TokAssign) << H(3) |
| /* 39 */ << H(TokLiteral | TokNewStr) << S(L"this") |
| /* 45 */ << H(TokLiteral | TokNewStr) << S(L"is=still") |
| /* 55 */ << H(TokLiteral | TokNewStr) << S(L"ok") |
| /* 59 */ << H(TokValueTerminator) |
| /* 60 */ << H(TokLine) << H(9) |
| /* 62 */ << H(TokHashLiteral) << HS(L"VAR2") |
| /* 70 */ << H(TokAssign) << H(6) |
| /* 72 */ << H(TokLiteral | TokNewStr) << S(L"this") |
| /* 78 */ << H(TokLiteral | TokNewStr) << S(L"is") |
| /* 82 */ << H(TokLiteral | TokNewStr) << S(L"VAR3") |
| /* 88 */ << H(TokLiteral | TokNewStr) << S(L"=") |
| /* 91 */ << H(TokLiteral | TokNewStr) << S(L"not") |
| /* 96 */ << H(TokLiteral | TokNewStr) << S(L"ok") |
| /* 100 */ << H(TokValueTerminator)) |
| << "WARNING: in:12: Possible accidental line continuation" |
| << true; |
| |
| QTest::newRow("plain variable expansion") |
| << "VAR = $$bar" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(0) |
| /* 11 */ << H(TokVariable | TokNewStr) << HS(L"bar") |
| /* 18 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("braced variable expansion") |
| << "VAR = $${foo/bar}" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(0) |
| /* 11 */ << H(TokVariable | TokNewStr) << HS(L"foo/bar") |
| /* 22 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("bogus variable expansion") |
| << "VAR = $$ " |
| << TS( |
| /* 0 */ << ASSIGN_VAR(0) |
| /* 11 */ << H(TokVariable | TokNewStr) << HS(L"") |
| /* 15 */ << H(TokValueTerminator)) |
| << "WARNING: in:1: Missing name in expansion" |
| << true; |
| |
| QTest::newRow("bogus braced variable expansion") |
| << "VAR = $${}" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(0) |
| /* 11 */ << H(TokVariable | TokNewStr) << HS(L"") |
| /* 15 */ << H(TokValueTerminator)) |
| << "WARNING: in:1: Missing name in expansion" |
| << true; |
| |
| QTest::newRow("unterminated braced variable expansion") |
| << "VAR = $${FOO" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"VAR") |
| /* 9 */ << H(TokAssign) << H(0) |
| /* 11 */ << H(TokVariable | TokNewStr) << HS(L"FOO") |
| /* 18 */ << H(TokValueTerminator)) |
| << "in:1: Missing } terminator [found end-of-line]" |
| << false; |
| |
| QTest::newRow("invalid identifier in braced variable expansion") |
| << "VAR = $${FOO/BAR+BAZ}" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"VAR") |
| /* 9 */ << H(TokAssign) << H(0) |
| /* 11 */ << H(TokVariable | TokNewStr) << HS(L"FOO/BAR") |
| /* 22 */ << H(TokLiteral) << S(L"+BAZ") |
| /* 28 */ << H(TokValueTerminator)) |
| << "in:1: Missing } terminator [found +]" |
| << false; |
| |
| QTest::newRow("property expansion") |
| << "VAR = $$[bar]" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(0) |
| /* 11 */ << H(TokProperty | TokNewStr) << HS(L"bar") |
| /* 18 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("environment expansion") |
| << "VAR = $$(bar)" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(0) |
| /* 11 */ << H(TokEnvVar | TokNewStr) << S(L"bar") |
| /* 16 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("plain function call") |
| << "VAR = $$bar()" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(0) |
| /* 11 */ << H(TokFuncName | TokNewStr) << HS(L"bar") |
| /* 18 */ << H(TokFuncTerminator) |
| /* 19 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("braced function call") |
| << "VAR = $${bar()}" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(0) |
| /* 11 */ << H(TokFuncName | TokNewStr) << HS(L"bar") |
| /* 18 */ << H(TokFuncTerminator) |
| /* 19 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("function call with one argument") |
| << "VAR = $$bar(blubb)" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(0) |
| /* 11 */ << H(TokFuncName | TokNewStr) << HS(L"bar") |
| /* 18 */ << H(TokLiteral | TokNewStr) << S(L"blubb") |
| /* 25 */ << H(TokFuncTerminator) |
| /* 26 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("function call with multiple arguments") |
| << "VAR = $$bar( blubb blubb, hey ,$$you)" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(0) |
| /* 11 */ << H(TokFuncName | TokNewStr) << HS(L"bar") |
| /* 18 */ << H(TokLiteral | TokNewStr) << S(L"blubb") |
| /* 25 */ << H(TokLiteral | TokNewStr) << S(L"blubb") |
| /* 32 */ << H(TokArgSeparator) |
| /* 33 */ << H(TokLiteral | TokNewStr) << S(L"hey") |
| /* 38 */ << H(TokArgSeparator) |
| /* 39 */ << H(TokVariable | TokNewStr) << HS(L"you") |
| /* 46 */ << H(TokFuncTerminator) |
| /* 47 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("nested function call") |
| << "VAR = $$foo(yo, $$bar(blubb))" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(0) |
| /* 11 */ << H(TokFuncName | TokNewStr) << HS(L"foo") |
| /* 18 */ << H(TokLiteral | TokNewStr) << S(L"yo") |
| /* 22 */ << H(TokArgSeparator) |
| /* 23 */ << H(TokFuncName | TokNewStr) << HS(L"bar") |
| /* 30 */ << H(TokLiteral | TokNewStr) << S(L"blubb") |
| /* 37 */ << H(TokFuncTerminator) |
| /* 38 */ << H(TokFuncTerminator) |
| /* 39 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| // This is a rather questionable "feature" |
| QTest::newRow("function call with parenthesized argument") |
| << "VAR = $$bar(blubb (yo, man) blabb, nope)" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(0) |
| /* 11 */ << H(TokFuncName | TokNewStr) << HS(L"bar") |
| /* 18 */ << H(TokLiteral | TokNewStr) << S(L"blubb") |
| /* 25 */ << H(TokLiteral | TokNewStr) << S(L"(yo,") |
| /* 31 */ << H(TokLiteral | TokNewStr) << S(L"man)") |
| /* 37 */ << H(TokLiteral | TokNewStr) << S(L"blabb") |
| /* 44 */ << H(TokArgSeparator) |
| /* 45 */ << H(TokLiteral | TokNewStr) << S(L"nope") |
| /* 51 */ << H(TokFuncTerminator) |
| /* 52 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("separate literal and expansion") |
| << "VAR = foo $$bar" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(2) |
| /* 11 */ << H(TokLiteral | TokNewStr) << S(L"foo") |
| /* 16 */ << H(TokVariable | TokNewStr) << HS(L"bar") |
| /* 23 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("separate expansion and literal") |
| << "VAR = $$bar foo" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(0) |
| /* 11 */ << H(TokVariable | TokNewStr) << HS(L"bar") |
| /* 18 */ << H(TokLiteral | TokNewStr) << S(L"foo") |
| /* 23 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("joined literal and expansion") |
| << "VAR = foo$$bar" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(0) |
| /* 11 */ << H(TokLiteral | TokNewStr) << S(L"foo") |
| /* 16 */ << H(TokVariable) << HS(L"bar") |
| /* 23 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("joined expansion and literal") |
| << "VAR = $${bar}foo" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(0) |
| /* 11 */ << H(TokVariable | TokNewStr) << HS(L"bar") |
| /* 18 */ << H(TokLiteral) << S(L"foo") |
| /* 23 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("plain variable expansion with funny name and literal") |
| << "VAR = $$az_AZ_09.dot/nix" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(0) |
| /* 11 */ << H(TokVariable | TokNewStr) << HS(L"az_AZ_09.dot") |
| /* 27 */ << H(TokLiteral) << S(L"/nix") |
| /* 33 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("braced variable expansion with funny name") |
| << "VAR = $${az_AZ_09.dot/nix}" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(0) |
| /* 11 */ << H(TokVariable | TokNewStr) << HS(L"az_AZ_09.dot/nix") |
| /* 31 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("quoted joined literal and expansion") |
| << "VAR = 'foo$$bar'" |
| << TS( |
| /* 0 */ << ASSIGN_VAR(0) |
| /* 11 */ << H(TokLiteral | TokNewStr) << S(L"foo") |
| /* 16 */ << H(TokVariable | TokQuoted) << HS(L"bar") |
| /* 23 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("assignment with expansion in variable name") |
| << "VAR$$EXTRA =" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"VAR") |
| /* 9 */ << H(TokVariable) << HS(L"EXTRA") |
| /* 18 */ << H(TokAssign) << H(0) |
| /* 20 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| } |
| |
| void tst_qmakelib::addParseConditions() |
| { |
| QTest::newRow("one test") |
| << "foo" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokCondition)) |
| << "" |
| << true; |
| |
| QTest::newRow("wildcard-test") |
| << "foo-*" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo-*") |
| /* 11 */ << H(TokCondition)) |
| << "" |
| << true; |
| |
| // This is a rather questionable "feature" |
| QTest::newRow("one quoted test") |
| << "\"foo\"" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokCondition)) |
| << "" |
| << true; |
| |
| QTest::newRow("two tests") |
| << "foo\nbar" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokCondition) |
| /* 10 */ << H(TokLine) << H(2) |
| /* 12 */ << H(TokHashLiteral) << HS(L"bar") |
| /* 19 */ << H(TokCondition)) |
| << "" |
| << true; |
| |
| QTest::newRow("bogus two tests") |
| << "foo bar\nbaz" |
| << TS() |
| << "in:1: Extra characters after test expression." |
| << false; |
| |
| QTest::newRow("test-AND-test") |
| << "foo:bar" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokCondition) |
| /* 10 */ << H(TokAnd) |
| /* 11 */ << H(TokHashLiteral) << HS(L"bar") |
| /* 18 */ << H(TokCondition)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-OR-test") |
| << " foo | bar " |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokCondition) |
| /* 10 */ << H(TokOr) |
| /* 11 */ << H(TokHashLiteral) << HS(L"bar") |
| /* 18 */ << H(TokCondition)) |
| << "" |
| << true; |
| |
| QTest::newRow("NOT-test") |
| << "!foo" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokNot) |
| /* 3 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 10 */ << H(TokCondition)) |
| << "" |
| << true; |
| |
| QTest::newRow("NOT-NOT-test") |
| << "!!foo" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokCondition)) |
| << "" |
| << true; |
| |
| // This is a rather questionable "feature" |
| QTest::newRow("quoted-NOT-test") |
| << "\"!foo\"" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokNot) |
| /* 3 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 10 */ << H(TokCondition)) |
| << "" |
| << true; |
| |
| // This is a rather questionable "feature" |
| QTest::newRow("NOT-quoted-test") |
| << "!\"foo\"" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokNot) |
| /* 3 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 10 */ << H(TokCondition)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-AND-NOT-test") |
| << "foo:!bar" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokCondition) |
| /* 10 */ << H(TokAnd) |
| /* 11 */ << H(TokNot) |
| /* 12 */ << H(TokHashLiteral) << HS(L"bar") |
| /* 19 */ << H(TokCondition)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-assignment") |
| << "foo\nVAR=" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokCondition) |
| /* 10 */ << H(TokLine) << H(2) |
| /* 12 */ << H(TokHashLiteral) << HS(L"VAR") |
| /* 19 */ << H(TokAssign) << H(0) |
| /* 21 */ << H(TokValueTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-AND-assignment") |
| << "foo: VAR =" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokCondition) |
| /* 10 */ << H(TokBranch) |
| /* 11 */ /* then branch */ << I(11) |
| /* 13 */ << H(TokHashLiteral) << HS(L"VAR") |
| /* 20 */ << H(TokAssign) << H(0) |
| /* 22 */ << H(TokValueTerminator) |
| /* 23 */ << H(TokTerminator) |
| /* 24 */ /* else branch */ << I(0)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-else-test") |
| << "foo\nelse: bar" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokCondition) |
| /* 10 */ << H(TokBranch) |
| /* 11 */ /* then branch */ << I(0) |
| /* 13 */ /* else branch */ << I(11) |
| /* 15 */ << H(TokLine) << H(2) |
| /* 17 */ << H(TokHashLiteral) << HS(L"bar") |
| /* 24 */ << H(TokCondition) |
| /* 25 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("function-else-test") |
| << "foo()\nelse: bar" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokTestCall) |
| /* 10 */ << H(TokFuncTerminator) |
| /* 11 */ << H(TokBranch) |
| /* 12 */ /* then branch */ << I(0) |
| /* 14 */ /* else branch */ << I(11) |
| /* 16 */ << H(TokLine) << H(2) |
| /* 18 */ << H(TokHashLiteral) << HS(L"bar") |
| /* 25 */ << H(TokCondition) |
| /* 26 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-AND-test-else-test") |
| << "foo:bar\nelse: baz" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokCondition) |
| /* 10 */ << H(TokAnd) |
| /* 11 */ << H(TokHashLiteral) << HS(L"bar") |
| /* 18 */ << H(TokCondition) |
| /* 19 */ << H(TokBranch) |
| /* 20 */ /* then branch */ << I(0) |
| /* 22 */ /* else branch */ << I(11) |
| /* 24 */ << H(TokLine) << H(2) |
| /* 26 */ << H(TokHashLiteral) << HS(L"baz") |
| /* 33 */ << H(TokCondition) |
| /* 34 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-AND-test-else-test-else-test-function") |
| << "foo:bar\nelse: baz\nelse: bak\nbuzz()" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokCondition) |
| /* 10 */ << H(TokAnd) |
| /* 11 */ << H(TokHashLiteral) << HS(L"bar") |
| /* 18 */ << H(TokCondition) |
| /* 19 */ << H(TokBranch) |
| /* 20 */ /* then branch */ << I(0) |
| /* 22 */ /* else branch */ << I(27) |
| /* 24 */ << H(TokLine) << H(2) |
| /* 26 */ << H(TokHashLiteral) << HS(L"baz") |
| /* 33 */ << H(TokCondition) |
| /* 34 */ << H(TokBranch) |
| /* 35 */ /* then branch */ << I(0) |
| /* 37 */ /* else branch */ << I(11) |
| /* 39 */ << H(TokLine) << H(3) |
| /* 41 */ << H(TokHashLiteral) << HS(L"bak") |
| /* 48 */ << H(TokCondition) |
| /* 49 */ << H(TokTerminator) |
| /* 50 */ << H(TokTerminator) |
| /* 51 */ << H(TokLine) << H(4) |
| /* 53 */ << H(TokHashLiteral) << HS(L"buzz") |
| /* 61 */ << H(TokTestCall) |
| /* 62 */ << H(TokFuncTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-assignment-else-assignment") |
| << "foo: VAR =\nelse: VAR=" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokCondition) |
| /* 10 */ << H(TokBranch) |
| /* 11 */ /* then branch */ << I(11) |
| /* 13 */ << H(TokHashLiteral) << HS(L"VAR") |
| /* 20 */ << H(TokAssign) << H(0) |
| /* 22 */ << H(TokValueTerminator) |
| /* 23 */ << H(TokTerminator) |
| /* 24 */ /* else branch */ << I(13) |
| /* 26 */ << H(TokLine) << H(2) |
| /* 28 */ << H(TokHashLiteral) << HS(L"VAR") |
| /* 35 */ << H(TokAssign) << H(0) |
| /* 37 */ << H(TokValueTerminator) |
| /* 38 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-else-test-assignment") |
| << "foo\nelse: bar: VAR =" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokCondition) |
| /* 10 */ << H(TokBranch) |
| /* 11 */ /* then branch */ << I(0) |
| /* 13 */ /* else branch */ << I(27) |
| /* 15 */ << H(TokLine) << H(2) |
| /* 17 */ << H(TokHashLiteral) << HS(L"bar") |
| /* 24 */ << H(TokCondition) |
| /* 25 */ << H(TokBranch) |
| /* 26 */ /* then branch */ << I(11) |
| /* 28 */ << H(TokHashLiteral) << HS(L"VAR") |
| /* 35 */ << H(TokAssign) << H(0) |
| /* 37 */ << H(TokValueTerminator) |
| /* 38 */ << H(TokTerminator) |
| /* 39 */ /* else branch */ << I(0) |
| /* 41 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("one function") |
| << "foo()" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokTestCall) |
| /* 10 */ << H(TokFuncTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("one function (with spaces)") |
| << " foo( ) " |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokTestCall) |
| /* 10 */ << H(TokFuncTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("unterminated function call") |
| << "foo(\nfoo" |
| << TS() |
| << "in:1: Missing closing parenthesis in function call" |
| << false; |
| |
| QTest::newRow("function with arguments") |
| << "foo(blah, hi ho)" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokTestCall) |
| /* 10 */ << H(TokLiteral | TokNewStr) << S(L"blah") |
| /* 16 */ << H(TokArgSeparator) |
| /* 17 */ << H(TokLiteral | TokNewStr) << S(L"hi") |
| /* 21 */ << H(TokLiteral | TokNewStr) << S(L"ho") |
| /* 25 */ << H(TokFuncTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("function with empty arguments") |
| << "foo(,)" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokTestCall) |
| /* 10 */ << H(TokArgSeparator) |
| /* 11 */ << H(TokFuncTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("function with funny arguments") |
| << "foo(blah\\, \"hi , \\ho\" ,uh\\ ,\\oh ,, )" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokTestCall) |
| /* 10 */ << H(TokLiteral | TokNewStr) << S(L"blah\\") |
| /* 17 */ << H(TokArgSeparator) |
| /* 18 */ << H(TokLiteral | TokNewStr) << S(L"hi , \\ho") |
| /* 29 */ << H(TokArgSeparator) |
| /* 30 */ << H(TokLiteral | TokNewStr) << S(L"uh\\") |
| /* 35 */ << H(TokArgSeparator) |
| /* 36 */ << H(TokLiteral | TokNewStr) << S(L"\\oh") |
| /* 41 */ << H(TokArgSeparator) |
| /* 42 */ << H(TokArgSeparator) |
| /* 43 */ << H(TokFuncTerminator)) |
| << "WARNING: in:1: Unescaped backslashes are deprecated\n" |
| "WARNING: in:1: Unescaped backslashes are deprecated\n" |
| "WARNING: in:1: Unescaped backslashes are deprecated\n" |
| "WARNING: in:1: Unescaped backslashes are deprecated" |
| << true; |
| |
| QTest::newRow("function with nested call") |
| << "foo($$blah(hi ho))" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokTestCall) |
| /* 10 */ << H(TokFuncName | TokNewStr) << HS(L"blah") |
| /* 18 */ << H(TokLiteral | TokNewStr) << S(L"hi") |
| /* 22 */ << H(TokLiteral | TokNewStr) << S(L"ho") |
| /* 26 */ << H(TokFuncTerminator) |
| /* 27 */ << H(TokFuncTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("stand-alone parentheses") |
| << "()" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokTestCall) |
| /* 3 */ << H(TokFuncTerminator)) |
| << "in:1: Opening parenthesis without prior test name." |
| << false; |
| |
| QTest::newRow("bogus test and function") |
| << "foo bar()" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokTestCall) |
| /* 3 */ << H(TokFuncTerminator)) |
| << "in:1: Extra characters after test expression." |
| << false; |
| |
| // This is a rather questionable "feature" |
| QTest::newRow("two functions") |
| << "foo() bar()" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokTestCall) |
| /* 10 */ << H(TokFuncTerminator) |
| /* 11 */ << H(TokHashLiteral) << HS(L"bar") |
| /* 18 */ << H(TokTestCall) |
| /* 19 */ << H(TokFuncTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("function-AND-test") |
| << "foo():bar" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokTestCall) |
| /* 10 */ << H(TokFuncTerminator) |
| /* 11 */ << H(TokAnd) |
| /* 12 */ << H(TokHashLiteral) << HS(L"bar") |
| /* 19 */ << H(TokCondition)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-AND-function") |
| << "foo:bar()" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokCondition) |
| /* 10 */ << H(TokAnd) |
| /* 11 */ << H(TokHashLiteral) << HS(L"bar") |
| /* 18 */ << H(TokTestCall) |
| /* 19 */ << H(TokFuncTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("NOT-function-AND-test") |
| << "!foo():bar" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokNot) |
| /* 3 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 10 */ << H(TokTestCall) |
| /* 11 */ << H(TokFuncTerminator) |
| /* 12 */ << H(TokAnd) |
| /* 13 */ << H(TokHashLiteral) << HS(L"bar") |
| /* 20 */ << H(TokCondition)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-AND-NOT-function") |
| << "foo:!bar()" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"foo") |
| /* 9 */ << H(TokCondition) |
| /* 10 */ << H(TokAnd) |
| /* 11 */ << H(TokNot) |
| /* 12 */ << H(TokHashLiteral) << HS(L"bar") |
| /* 19 */ << H(TokTestCall) |
| /* 20 */ << H(TokFuncTerminator)) |
| << "" |
| << true; |
| } |
| |
| void tst_qmakelib::addParseControlStatements() |
| { |
| QTest::newRow("for(VAR, LIST) loop") |
| << "for(VAR, LIST)" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokForLoop) << HS(L"VAR") |
| /* 9 */ /* iterator */ << I(7) |
| /* 11 */ << H(TokLiteral | TokNewStr) << S(L"LIST") |
| /* 17 */ << H(TokValueTerminator) |
| /* 18 */ /* body */ << I(1) |
| /* 20 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("for(ever) loop") |
| << "for(ever)" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokForLoop) << HS(L"") |
| /* 6 */ /* iterator */ << I(9) |
| /* 8 */ << H(TokHashLiteral) << HS(L"ever") |
| /* 16 */ << H(TokValueTerminator) |
| /* 17 */ /* body */ << I(1) |
| /* 19 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| // This is a rather questionable "feature" |
| QTest::newRow("for($$blub) loop") |
| << "for($$blub)" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokForLoop) << HS(L"") |
| /* 6 */ /* iterator */ << I(9) |
| /* 8 */ << H(TokVariable | TokNewStr) << HS(L"blub") |
| /* 16 */ << H(TokValueTerminator) |
| /* 17 */ /* body */ << I(1) |
| /* 19 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-for-test-else-test") |
| << "true:for(VAR, LIST): true\nelse: true" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"true") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokBranch) |
| /* 12 */ /* then branch */ << I(31) |
| /* 14 */ << H(TokForLoop) << HS(L"VAR") |
| /* 21 */ /* iterator */ << I(7) |
| /* 23 */ << H(TokLiteral | TokNewStr) << S(L"LIST") |
| /* 29 */ << H(TokValueTerminator) |
| /* 30 */ /* body */ << I(12) |
| /* 32 */ << H(TokLine) << H(1) |
| /* 34 */ << H(TokHashLiteral) << HS(L"true") |
| /* 42 */ << H(TokCondition) |
| /* 43 */ << H(TokTerminator) |
| /* 44 */ << H(TokTerminator) |
| /* 45 */ /* else branch */ << I(12) |
| /* 47 */ << H(TokLine) << H(2) |
| /* 49 */ << H(TokHashLiteral) << HS(L"true") |
| /* 57 */ << H(TokCondition) |
| /* 58 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("next()") |
| << "for(ever): next()" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokForLoop) << HS(L"") |
| /* 6 */ /* iterator */ << I(9) |
| /* 8 */ << H(TokHashLiteral) << HS(L"ever") |
| /* 16 */ << H(TokValueTerminator) |
| /* 17 */ /* body */ << I(4) |
| /* 19 */ << H(TokLine) << H(1) |
| /* 21 */ << H(TokNext) |
| /* 22 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("break()") |
| << "for(ever): break()" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokForLoop) << HS(L"") |
| /* 6 */ /* iterator */ << I(9) |
| /* 8 */ << H(TokHashLiteral) << HS(L"ever") |
| /* 16 */ << H(TokValueTerminator) |
| /* 17 */ /* body */ << I(4) |
| /* 19 */ << H(TokLine) << H(1) |
| /* 21 */ << H(TokBreak) |
| /* 22 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("top-level return()") |
| << "return()" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokReturn)) |
| << "" |
| << true; |
| |
| QTest::newRow("else") |
| << "else" |
| << TS() |
| << "in:1: Unexpected 'else'." |
| << false; |
| |
| QTest::newRow("test-{else}") |
| << "test { else }" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"test") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokBranch) |
| /* 12 */ /* then branch */ << I(1) |
| /* 14 */ << H(TokTerminator) |
| /* 15 */ /* else branch */ << I(0)) |
| << "in:1: Unexpected 'else'." |
| << false; |
| |
| QTest::newRow("defineTest-{else}") |
| << "defineTest(fn) { else }" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokTestDef) << HS(L"fn") |
| /* 8 */ /* body */ << I(1) |
| /* 10 */ << H(TokTerminator)) |
| << "in:1: Unexpected 'else'." |
| << false; |
| |
| QTest::newRow("for-else") |
| << "for(ever) { else }" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokForLoop) << HS(L"") |
| /* 6 */ /* iterator */ << I(9) |
| /* 8 */ << H(TokHashLiteral) << HS(L"ever") |
| /* 16 */ << H(TokValueTerminator) |
| /* 17 */ /* body */ << I(1) |
| /* 19 */ << H(TokTerminator)) |
| << "in:1: Unexpected 'else'." |
| << false; |
| |
| QTest::newRow("double-test-else") |
| << "foo bar\nelse" |
| << TS( |
| /* 0 */ << H(TokBranch) |
| /* 1 */ /* then branch */ << I(0) |
| /* 3 */ /* else branch */ << I(1) // This seems weird |
| /* 5 */ << H(TokTerminator)) |
| << "in:1: Extra characters after test expression." |
| << false; |
| |
| QTest::newRow("test-function-else") |
| << "foo bar()\nelse" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokTestCall) // This seems pointless |
| /* 3 */ << H(TokFuncTerminator) |
| /* 4 */ << H(TokBranch) |
| /* 5 */ /* then branch */ << I(0) |
| /* 7 */ /* else branch */ << I(1) // This seems weird |
| /* 9 */ << H(TokTerminator)) |
| << "in:1: Extra characters after test expression." |
| << false; |
| } |
| |
| void tst_qmakelib::addParseBraces() |
| { |
| QTest::newRow("{}") |
| << "{ }" |
| << TS() |
| << "" |
| << true; |
| |
| QTest::newRow("{}-newlines") |
| << "\n\n{ }\n\n" |
| << TS() |
| << "" |
| << true; |
| |
| QTest::newRow("{") |
| << "{" |
| << TS() |
| << "in:2: Missing closing brace(s)." |
| << false; |
| |
| QTest::newRow("test {") |
| << "test {" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"test") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokBranch) |
| /* 12 */ /* then branch */ << I(1) |
| /* 14 */ << H(TokTerminator) |
| /* 15 */ /* else branch */ << I(0)) |
| << "in:2: Missing closing brace(s)." |
| << false; |
| |
| QTest::newRow("}") |
| << "}" |
| << TS() |
| << "in:1: Excess closing brace." |
| << false; |
| |
| QTest::newRow("{test}") |
| << "{ true }" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"true") |
| /* 10 */ << H(TokCondition)) |
| << "" |
| << true; |
| |
| QTest::newRow("{test-newlines}") |
| << "{\ntrue\n}" |
| << TS( |
| /* 0 */ << H(TokLine) << H(2) |
| /* 2 */ << H(TokHashLiteral) << HS(L"true") |
| /* 10 */ << H(TokCondition)) |
| << "" |
| << true; |
| |
| QTest::newRow("{assignment-test}-test") |
| << "{ VAR = { foo } bar } true" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"VAR") |
| /* 9 */ << H(TokAssign) << H(4) |
| /* 11 */ << H(TokLiteral | TokNewStr) << S(L"{") |
| /* 14 */ << H(TokLiteral | TokNewStr) << S(L"foo") |
| /* 19 */ << H(TokLiteral | TokNewStr) << S(L"}") |
| /* 22 */ << H(TokLiteral | TokNewStr) << S(L"bar") |
| /* 27 */ << H(TokValueTerminator) |
| /* 28 */ << H(TokHashLiteral) << HS(L"true") |
| /* 36 */ << H(TokCondition)) |
| << "" |
| << true; |
| |
| QTest::newRow("assignment with excess opening brace") |
| << "VAR = { { foo }" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"VAR") |
| /* 9 */ << H(TokAssign) << H(4) |
| /* 11 */ << H(TokLiteral | TokNewStr) << S(L"{") |
| /* 14 */ << H(TokLiteral | TokNewStr) << S(L"{") |
| /* 17 */ << H(TokLiteral | TokNewStr) << S(L"foo") |
| /* 22 */ << H(TokLiteral | TokNewStr) << S(L"}") |
| /* 25 */ << H(TokValueTerminator)) |
| << "WARNING: in:1: Possible braces mismatch" |
| << true; |
| |
| QTest::newRow("test-{}") |
| << "true {}" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"true") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokBranch) |
| /* 12 */ /* then branch */ << I(1) |
| /* 14 */ << H(TokTerminator) |
| /* 15 */ /* else branch */ << I(0)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-{newlines}") |
| << "true {\n}" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"true") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokBranch) |
| /* 12 */ /* then branch */ << I(1) |
| /* 14 */ << H(TokTerminator) |
| /* 15 */ /* else branch */ << I(0)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-{test}") |
| << "true { true }" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"true") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokBranch) |
| /* 12 */ /* then branch */ << I(10) |
| /* 14 */ << H(TokHashLiteral) << HS(L"true") |
| /* 22 */ << H(TokCondition) |
| /* 23 */ << H(TokTerminator) |
| /* 24 */ /* else branch */ << I(0)) |
| << "" |
| << true; |
| |
| QTest::newRow("test:-{test}") |
| << "true: { true }" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"true") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokBranch) |
| /* 12 */ /* then branch */ << I(10) |
| /* 14 */ << H(TokHashLiteral) << HS(L"true") |
| /* 22 */ << H(TokCondition) |
| /* 23 */ << H(TokTerminator) |
| /* 24 */ /* else branch */ << I(0)) |
| << "WARNING: in:1: Excess colon in front of opening brace." |
| << true; |
| |
| QTest::newRow("test-{test-newlines}") |
| << "true {\ntrue\n}" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"true") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokBranch) |
| /* 12 */ /* then branch */ << I(12) |
| /* 14 */ << H(TokLine) << H(2) |
| /* 16 */ << H(TokHashLiteral) << HS(L"true") |
| /* 24 */ << H(TokCondition) |
| /* 25 */ << H(TokTerminator) |
| /* 26 */ /* else branch */ << I(0)) |
| << "" |
| << true; |
| |
| QTest::newRow("test:-{test-newlines}") |
| << "true: {\ntrue\n}" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"true") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokBranch) |
| /* 12 */ /* then branch */ << I(12) |
| /* 14 */ << H(TokLine) << H(2) |
| /* 16 */ << H(TokHashLiteral) << HS(L"true") |
| /* 24 */ << H(TokCondition) |
| /* 25 */ << H(TokTerminator) |
| /* 26 */ /* else branch */ << I(0)) |
| << "WARNING: in:1: Excess colon in front of opening brace." |
| << true; |
| |
| QTest::newRow("test-{assignment}") |
| << "true { VAR = {foo} }" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"true") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokBranch) |
| /* 12 */ /* then branch */ << I(18) |
| /* 14 */ << H(TokHashLiteral) << HS(L"VAR") |
| /* 21 */ << H(TokAssign) << H(0) |
| /* 23 */ << H(TokLiteral | TokNewStr) << S(L"{foo}") |
| /* 30 */ << H(TokValueTerminator) |
| /* 31 */ << H(TokTerminator) |
| /* 32 */ /* else branch */ << I(0)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-{test-assignment}") |
| << "true { true: VAR = {foo} }" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"true") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokBranch) |
| /* 12 */ /* then branch */ << I(33) |
| /* 14 */ << H(TokHashLiteral) << HS(L"true") |
| /* 22 */ << H(TokCondition) |
| /* 23 */ << H(TokBranch) |
| /* 24 */ /* then branch */ << I(18) |
| /* 26 */ << H(TokHashLiteral) << HS(L"VAR") |
| /* 33 */ << H(TokAssign) << H(0) |
| /* 35 */ << H(TokLiteral | TokNewStr) << S(L"{foo}") |
| /* 42 */ << H(TokValueTerminator) |
| /* 43 */ << H(TokTerminator) |
| /* 44 */ /* else branch */ << I(0) |
| /* 46 */ << H(TokTerminator) |
| /* 47 */ /* else branch */ << I(0)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-{assignment-newlines}") |
| << "true {\nVAR = {foo}\n}" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"true") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokBranch) |
| /* 12 */ /* then branch */ << I(20) |
| /* 14 */ << H(TokLine) << H(2) |
| /* 16 */ << H(TokHashLiteral) << HS(L"VAR") |
| /* 23 */ << H(TokAssign) << H(0) |
| /* 25 */ << H(TokLiteral | TokNewStr) << S(L"{foo}") |
| /* 32 */ << H(TokValueTerminator) |
| /* 33 */ << H(TokTerminator) |
| /* 34 */ /* else branch */ << I(0)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-{}-else-test-{}") |
| << "true {} else: true {}" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"true") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokBranch) |
| /* 12 */ /* then branch */ << I(1) |
| /* 14 */ << H(TokTerminator) |
| /* 15 */ /* else branch */ << I(18) |
| /* 17 */ << H(TokLine) << H(1) |
| /* 19 */ << H(TokHashLiteral) << HS(L"true") |
| /* 27 */ << H(TokCondition) |
| /* 28 */ << H(TokBranch) |
| /* 29 */ /* then branch */ << I(1) |
| /* 31 */ << H(TokTerminator) |
| /* 32 */ /* else branch */ << I(0) |
| /* 34 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-{}-else-test-{}-newlines") |
| << "true {\n}\nelse: true {\n}" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"true") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokBranch) |
| /* 12 */ /* then branch */ << I(1) |
| /* 14 */ << H(TokTerminator) |
| /* 15 */ /* else branch */ << I(18) |
| /* 17 */ << H(TokLine) << H(3) |
| /* 19 */ << H(TokHashLiteral) << HS(L"true") |
| /* 27 */ << H(TokCondition) |
| /* 28 */ << H(TokBranch) |
| /* 29 */ /* then branch */ << I(1) |
| /* 31 */ << H(TokTerminator) |
| /* 32 */ /* else branch */ << I(0) |
| /* 34 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-{test}-else-test-{}-newlines") |
| << "true {\ntrue\n}\nelse: true {\n}" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"true") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokBranch) |
| /* 12 */ /* then branch */ << I(12) |
| /* 14 */ << H(TokLine) << H(2) |
| /* 16 */ << H(TokHashLiteral) << HS(L"true") |
| /* 24 */ << H(TokCondition) |
| /* 25 */ << H(TokTerminator) |
| /* 26 */ /* else branch */ << I(18) |
| /* 28 */ << H(TokLine) << H(4) |
| /* 30 */ << H(TokHashLiteral) << HS(L"true") |
| /* 38 */ << H(TokCondition) |
| /* 39 */ << H(TokBranch) |
| /* 40 */ /* then branch */ << I(1) |
| /* 42 */ << H(TokTerminator) |
| /* 43 */ /* else branch */ << I(0) |
| /* 45 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("for-{next}") |
| << "for(ever) { next() }" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokForLoop) << HS(L"") |
| /* 6 */ /* iterator */ << I(9) |
| /* 8 */ << H(TokHashLiteral) << HS(L"ever") |
| /* 16 */ << H(TokValueTerminator) |
| /* 17 */ /* body */ << I(4) |
| /* 19 */ << H(TokLine) << H(1) |
| /* 21 */ << H(TokNext) |
| /* 22 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("for:-{next}") |
| << "for(ever): { next() }" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokForLoop) << HS(L"") |
| /* 6 */ /* iterator */ << I(9) |
| /* 8 */ << H(TokHashLiteral) << HS(L"ever") |
| /* 16 */ << H(TokValueTerminator) |
| /* 17 */ /* body */ << I(4) |
| /* 19 */ << H(TokLine) << H(1) |
| /* 21 */ << H(TokNext) |
| /* 22 */ << H(TokTerminator)) |
| << "WARNING: in:1: Excess colon in front of opening brace." |
| << true; |
| |
| QTest::newRow("test-for-{test-else-test-newlines}") |
| << "true:for(VAR, LIST) {\ntrue\nelse: true\n}" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"true") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokBranch) |
| /* 12 */ /* then branch */ << I(48) |
| /* 14 */ << H(TokForLoop) << HS(L"VAR") |
| /* 21 */ /* iterator */ << I(7) |
| /* 23 */ << H(TokLiteral | TokNewStr) << S(L"LIST") |
| /* 29 */ << H(TokValueTerminator) |
| /* 30 */ /* body */ << I(29) |
| /* 32 */ << H(TokLine) << H(2) |
| /* 34 */ << H(TokHashLiteral) << HS(L"true") |
| /* 42 */ << H(TokCondition) |
| /* 43 */ << H(TokBranch) |
| /* 44 */ /* then branch */ << I(0) |
| /* 46 */ /* else branch */ << I(12) |
| /* 48 */ << H(TokLine) << H(3) |
| /* 50 */ << H(TokHashLiteral) << HS(L"true") |
| /* 58 */ << H(TokCondition) |
| /* 59 */ << H(TokTerminator) |
| /* 60 */ << H(TokTerminator) |
| /* 61 */ << H(TokTerminator) |
| /* 62 */ /* else branch */ << I(0)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-for-{test-else-test}") |
| << "true:for(VAR, LIST) { true\nelse: true }" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"true") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokBranch) |
| /* 12 */ /* then branch */ << I(48) |
| /* 14 */ << H(TokForLoop) << HS(L"VAR") |
| /* 21 */ /* iterator */ << I(7) |
| /* 23 */ << H(TokLiteral | TokNewStr) << S(L"LIST") |
| /* 29 */ << H(TokValueTerminator) |
| /* 30 */ /* body */ << I(29) |
| /* 32 */ << H(TokLine) << H(1) |
| /* 34 */ << H(TokHashLiteral) << HS(L"true") |
| /* 42 */ << H(TokCondition) |
| /* 43 */ << H(TokBranch) |
| /* 44 */ /* then branch */ << I(0) |
| /* 46 */ /* else branch */ << I(12) |
| /* 48 */ << H(TokLine) << H(2) |
| /* 50 */ << H(TokHashLiteral) << HS(L"true") |
| /* 58 */ << H(TokCondition) |
| /* 59 */ << H(TokTerminator) |
| /* 60 */ << H(TokTerminator) |
| /* 61 */ << H(TokTerminator) |
| /* 62 */ /* else branch */ << I(0)) |
| << "" |
| << true; |
| } |
| |
| void tst_qmakelib::addParseCustomFunctions() |
| { |
| QTest::newRow("defineTest-{newlines}") |
| << "defineTest(test) {\n}" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokTestDef) << HS(L"test") |
| /* 10 */ /* body */ << I(1) |
| /* 12 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("defineTest:-test") |
| << "defineTest(test): test" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokTestDef) << HS(L"test") |
| /* 10 */ /* body */ << I(12) |
| /* 12 */ << H(TokLine) << H(1) |
| /* 14 */ << H(TokHashLiteral) << HS(L"test") |
| /* 22 */ << H(TokCondition) |
| /* 23 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("defineTest-{test}") |
| << "defineTest(test) { test }" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokTestDef) << HS(L"test") |
| /* 10 */ /* body */ << I(12) |
| /* 12 */ << H(TokLine) << H(1) |
| /* 14 */ << H(TokHashLiteral) << HS(L"test") |
| /* 22 */ << H(TokCondition) |
| /* 23 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("defineTest-{return}") |
| << "defineTest(test) { return() }" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokTestDef) << HS(L"test") |
| /* 10 */ /* body */ << I(4) |
| /* 12 */ << H(TokLine) << H(1) |
| /* 14 */ << H(TokReturn) |
| /* 15 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("defineReplace-{return-stuff}") |
| << "defineReplace(stuff) { return(foo bar) }" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokReplaceDef) << HS(L"stuff") |
| /* 11 */ /* body */ << I(14) |
| /* 13 */ << H(TokLine) << H(1) |
| /* 15 */ << H(TokLiteral | TokNewStr) << S(L"foo") |
| /* 20 */ << H(TokLiteral | TokNewStr) << S(L"bar") |
| /* 25 */ << H(TokReturn) |
| /* 26 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-AND-defineTest-{}") |
| << "test: defineTest(test) {}" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"test") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokAnd) |
| /* 12 */ << H(TokTestDef) << HS(L"test") |
| /* 20 */ /* body */ << I(1) |
| /* 22 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-OR-defineTest-{}") |
| << "test| defineTest(test) {}" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"test") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokOr) |
| /* 12 */ << H(TokTestDef) << HS(L"test") |
| /* 20 */ /* body */ << I(1) |
| /* 22 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("bypassNesting()-{return}") |
| << "defineTest(test) { bypassNesting() { return(true) } }" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokTestDef) << HS(L"test") |
| /* 10 */ /* body */ << I(16) |
| /* 12 */ << H(TokLine) << H(1) |
| /* 14 */ << H(TokBypassNesting) |
| /* 15 */ /* block */ << I(10) |
| /* 17 */ << H(TokLine) << H(1) |
| /* 19 */ << H(TokLiteral | TokNewStr) << S(L"true") |
| /* 25 */ << H(TokReturn) |
| /* 26 */ << H(TokTerminator) |
| /* 27 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-AND-bypassNesting()-{}") |
| << "defineTest(test) { test: bypassNesting() {} }" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokTestDef) << HS(L"test") |
| /* 10 */ /* body */ << I(17) |
| /* 12 */ << H(TokLine) << H(1) |
| /* 14 */ << H(TokHashLiteral) << HS(L"test") |
| /* 22 */ << H(TokCondition) |
| /* 23 */ << H(TokAnd) |
| /* 24 */ << H(TokBypassNesting) |
| /* 25 */ /* block */ << I(1) |
| /* 27 */ << H(TokTerminator) |
| /* 28 */ << H(TokTerminator)) |
| << "" |
| << true; |
| |
| QTest::newRow("test-OR-bypassNesting()-{}") |
| << "defineTest(test) { test| bypassNesting() {} }" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokTestDef) << HS(L"test") |
| /* 10 */ /* body */ << I(17) |
| /* 12 */ << H(TokLine) << H(1) |
| /* 14 */ << H(TokHashLiteral) << HS(L"test") |
| /* 22 */ << H(TokCondition) |
| /* 23 */ << H(TokOr) |
| /* 24 */ << H(TokBypassNesting) |
| /* 25 */ /* block */ << I(1) |
| /* 27 */ << H(TokTerminator) |
| /* 28 */ << H(TokTerminator)) |
| << "" |
| << true; |
| } |
| |
| void tst_qmakelib::addParseAbuse() |
| { |
| QTest::newRow("!") |
| << "" |
| << TS() |
| << "" |
| << true; |
| |
| QTest::newRow("|") |
| << "" |
| << TS() |
| << "" |
| << true; |
| |
| QTest::newRow(":") |
| << "" |
| << TS() |
| << "" |
| << true; |
| |
| QTest::newRow("NOT-assignment") |
| << "!VAR =" |
| << TS() |
| << "in:1: Unexpected NOT operator in front of assignment." |
| << false; |
| |
| QTest::newRow("NOT-{}") |
| << "!{}" |
| << TS() |
| << "in:1: Unexpected NOT operator in front of opening brace." |
| << false; |
| |
| QTest::newRow("NOT-else") |
| << "test\n!else {}" |
| << TS() |
| << "in:2: Unexpected NOT operator in front of else." |
| << false; |
| |
| QTest::newRow("NOT-for-{}") |
| << "!for(ever) {}" |
| << TS() |
| << "in:1: Unexpected NOT operator in front of for()." |
| << false; |
| |
| QTest::newRow("NOT-defineTest-{}") |
| << "!defineTest(test) {}" |
| << TS() |
| << "in:1: Unexpected NOT operator in front of function definition." |
| << false; |
| |
| QTest::newRow("outer-bypassNesting()-{}") |
| << "bypassNesting() {}" |
| << TS() |
| << "in:1: Unexpected bypassNesting()." |
| << false; |
| |
| QTest::newRow("bypassNesting(arg)-{}") |
| << "defineTest(test) { bypassNesting(arg) {} }" |
| << TS() |
| << "in:1: bypassNesting() requires zero arguments." |
| << false; |
| |
| QTest::newRow("NOT-bypassNesting()-{}") |
| << "defineTest(test) { !bypassNesting() {} }" |
| << TS() |
| << "in:1: Unexpected NOT operator in front of bypassNesting()." |
| << false; |
| |
| QTest::newRow("AND-test") |
| << ":test" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"test") |
| /* 10 */ << H(TokCondition)) |
| << "in:1: AND operator without prior condition." |
| << false; |
| |
| QTest::newRow("test-AND-else") |
| << "test:else" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"test") |
| /* 10 */ << H(TokCondition)) |
| << "in:1: Unexpected AND operator in front of else." |
| << false; |
| |
| QTest::newRow("test-AND-AND-test") |
| << "test::test" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"test") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokAnd) |
| /* 12 */ << H(TokHashLiteral) << HS(L"test") |
| /* 20 */ << H(TokCondition)) |
| << "WARNING: in:1: Stray AND operator in front of AND operator." |
| << true; |
| |
| QTest::newRow("test-AND-OR-test") |
| << "test:|test" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"test") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokOr) |
| /* 12 */ << H(TokHashLiteral) << HS(L"test") |
| /* 20 */ << H(TokCondition)) |
| << "WARNING: in:1: Stray AND operator in front of OR operator." |
| << true; |
| |
| QTest::newRow("test-{AND-test}") |
| << "test { :test }" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"test") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokBranch) |
| /* 12 */ /* then branch */ << I(10) |
| /* 14 */ << H(TokHashLiteral) << HS(L"test") |
| /* 22 */ << H(TokCondition) |
| /* 23 */ << H(TokTerminator) |
| /* 24 */ /* else branch */ << I(0)) |
| << "in:1: AND operator without prior condition." |
| << false; |
| |
| QTest::newRow("test-OR-assignment") |
| << "foo| VAR =" |
| << TS() |
| << "in:1: Unexpected OR operator in front of assignment." |
| << false; |
| |
| QTest::newRow("test-OR-{}") |
| << "foo|{}" |
| << TS() |
| << "in:1: Unexpected OR operator in front of opening brace." |
| << false; |
| |
| QTest::newRow("test-OR-for") |
| << "foo|for(ever) {}" |
| << TS() |
| << "in:1: Unexpected OR operator in front of for()." |
| << false; |
| |
| QTest::newRow("OR-test") |
| << "|test" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"test") |
| /* 10 */ << H(TokCondition)) |
| << "in:1: OR operator without prior condition." |
| << false; |
| |
| QTest::newRow("test-OR-else") |
| << "test|else" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"test") |
| /* 10 */ << H(TokCondition)) |
| << "in:1: Unexpected OR operator in front of else." |
| << false; |
| |
| QTest::newRow("test-OR-OR-test") |
| << "test||test" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"test") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokOr) |
| /* 12 */ << H(TokHashLiteral) << HS(L"test") |
| /* 20 */ << H(TokCondition)) |
| << "WARNING: in:1: Stray OR operator in front of OR operator." |
| << true; |
| |
| QTest::newRow("test-OR-AND-test") |
| << "test|:test" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"test") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokAnd) |
| /* 12 */ << H(TokHashLiteral) << HS(L"test") |
| /* 20 */ << H(TokCondition)) |
| << "WARNING: in:1: Stray OR operator in front of AND operator." |
| << true; |
| |
| QTest::newRow("test-{OR-test}") |
| << "test { |test }" |
| << TS( |
| /* 0 */ << H(TokLine) << H(1) |
| /* 2 */ << H(TokHashLiteral) << HS(L"test") |
| /* 10 */ << H(TokCondition) |
| /* 11 */ << H(TokBranch) |
| /* 12 */ /* then branch */ << I(10) |
| /* 14 */ << H(TokHashLiteral) << HS(L"test") |
| /* 22 */ << H(TokCondition) |
| /* 23 */ << H(TokTerminator) |
| /* 24 */ /* else branch */ << I(0)) |
| << "in:1: OR operator without prior condition." |
| << false; |
| |
| // Token buffer overflow. Verify with Valgrind or asan. |
| QTest::newRow("QTCREATORBUG-16508") |
| << "a{b{c{d{" |
| << TS() |
| << "in:2: Missing closing brace(s)." |
| << false; |
| } |
| |
| void tst_qmakelib::proParser_data() |
| { |
| QTest::addColumn<QString>("in"); |
| QTest::addColumn<QString>("out"); |
| QTest::addColumn<QString>("msgs"); |
| QTest::addColumn<bool>("ok"); |
| |
| QTest::newRow("empty") |
| << "" |
| << TS() |
| << "" |
| << true; |
| |
| QTest::newRow("empty (whitespace)") |
| << " \t \t" |
| << TS() |
| << "" |
| << true; |
| |
| addParseOperators(); // Variable operators |
| |
| addParseValues(); |
| |
| addParseConditions(); // "Tests" |
| |
| addParseControlStatements(); |
| |
| addParseBraces(); |
| |
| addParseCustomFunctions(); |
| |
| addParseAbuse(); // Mostly operator abuse |
| |
| // option() (these produce no tokens) |
| |
| QTest::newRow("option(host_build)") |
| << "option(host_build)" |
| << TS() |
| << "" |
| << true; |
| |
| QTest::newRow("option()") |
| << "option()" |
| << TS() |
| << "in:1: option() requires one literal argument." |
| << false; |
| |
| QTest::newRow("option(host_build magic)") |
| << "option(host_build magic)" |
| << TS() |
| << "in:1: option() requires one literal argument." |
| << false; |
| |
| QTest::newRow("option(host_build, magic)") |
| << "option(host_build, magic)" |
| << TS() |
| << "in:1: option() requires one literal argument." |
| << false; |
| |
| QTest::newRow("option($$OPTION)") |
| << "option($$OPTION)" |
| << TS() |
| << "in:1: option() requires one literal argument." |
| << false; |
| |
| QTest::newRow("{option(host_build)}") |
| << "{option(host_build)}" |
| << TS() |
| << "in:1: option() must appear outside any control structures." |
| << false; |
| } |
| |
| QT_WARNING_POP |
| |
| void tst_qmakelib::proParser() |
| { |
| QFETCH(QString, in); |
| QFETCH(QString, out); |
| QFETCH(QString, msgs); |
| QFETCH(bool, ok); |
| |
| bool verified = true; |
| QMakeTestHandler handler; |
| handler.setExpectedMessages(msgs.split('\n', Qt::SkipEmptyParts)); |
| QMakeVfs vfs; |
| QMakeParser parser(0, &vfs, &handler); |
| ProFile *pro = parser.parsedProBlock(QStringRef(&in), 0, "in", 1, QMakeParser::FullGrammar); |
| if (handler.printedMessages()) { |
| qWarning("Got unexpected message(s)"); |
| verified = false; |
| } |
| QStringList missingMsgs = handler.expectedMessages(); |
| if (!missingMsgs.isEmpty()) { |
| foreach (const QString &msg, missingMsgs) |
| qWarning("Missing message: %s", qPrintable(msg)); |
| verified = false; |
| } |
| if (pro->isOk() != ok) { |
| static const char * const lbl[] = { "failure", "success" }; |
| qWarning("Expected %s, got %s", lbl[int(ok)], lbl[1 - int(ok)]); |
| verified = false; |
| } |
| if (pro->items() != out && (ok || !out.isEmpty())) { |
| qWarning("Bytecode mismatch.\nActual:%s\nExpected:%s", |
| qPrintable(QMakeParser::formatProBlock(pro->items())), |
| qPrintable(QMakeParser::formatProBlock(out))); |
| verified = false; |
| } |
| pro->deref(); |
| QVERIFY(verified); |
| } |
