Differential D11907 Diff 31381 autotests/unit/lib/advancedqueryparsertest.cpp

Changeset View

Standalone View

View Options

autotests/unit/lib/advancedqueryparsertest.cpp

Show All 16 Lines
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 17​ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18 * 18​ *
19 */ 19​ */
20 20​
21#include "advancedqueryparser.h" 21​#include "advancedqueryparser.h"
22 22​
23#include <QTest> 23​#include <QTest>
24 24​
25​Q_DECLARE_METATYPE(Baloo::Term)
25using namespace Baloo; 26​using namespace Baloo;
26 27​
27class AdvancedQueryParserTest : public QObject 28​class AdvancedQueryParserTest : public QObject
28{ 29​{
29 Q_OBJECT 30​ Q_OBJECT
30private Q_SLOTS: 31​private Q_SLOTS:
31 32​
32 void testSimpleProperty(); 33​ void testSimpleProperty();
33 void testSimpleString(); 34​ void testSimpleString();
34 void testStringAndProperty(); 35​ void testStringAndProperty();
35 void testLogicalOps(); 36​ void testLogicalOps();
36 void testNesting(); 37​ void testNesting();
37 void testDateTime(); 38​ void testDateTime();
38 void testOperators(); 39​ void testOperators();
39 void testBinaryOperatorMissingFirstArg(); 40​ void testBinaryOperatorMissingFirstArg();
41​ void testNestedParentheses();
42​ void testNestedParentheses_data();
43​ void testOptimizedLogic();
44​ void testOptimizedLogic_data();
40}; 45​};
41 46​
42void AdvancedQueryParserTest::testSimpleProperty() 47​void AdvancedQueryParserTest::testSimpleProperty()
43{ 48​{
44 AdvancedQueryParser parser; 49​ AdvancedQueryParser parser;
45 Term term = parser.parse(QStringLiteral("artist:Coldplay")); 50​ Term term = parser.parse(QStringLiteral("artist:Coldplay"));
46 Term expectedTerm(QStringLiteral("artist"), "Coldplay"); 51​ Term expectedTerm(QStringLiteral("artist"), "Coldplay");
47 52​
▲ Show 20 Lines • Show All 146 Lines • ▼ Show 20 Line(s)
194void AdvancedQueryParserTest::testBinaryOperatorMissingFirstArg() 199​void AdvancedQueryParserTest::testBinaryOperatorMissingFirstArg()
195{ 200​{
196 AdvancedQueryParser parser; 201​ AdvancedQueryParser parser;
197 Term term = parser.parse(QStringLiteral("=:2")); 202​ Term term = parser.parse(QStringLiteral("=:2"));
198 Term expectedTerm; 203​ Term expectedTerm;
199 QCOMPARE(term, expectedTerm); 204​ QCOMPARE(term, expectedTerm);
200} 205​}
201 206​
207​void AdvancedQueryParserTest::testNestedParentheses()
208​{
209​ QFETCH(QString, searchInput);
210​ QFETCH(QString, failmessage);
211​ QFETCH(Term, expectedTerm);
212​
213​ AdvancedQueryParser parser;
214​ const auto testTerm = parser.parse(searchInput);
215​ qDebug() << " result term" << testTerm;
216​ qDebug() << "expected term" << expectedTerm;
217​ if (!failmessage.isEmpty()) {
218​ QEXPECT_FAIL("", qPrintable(failmessage), Continue);
219​ }
220​
221​ QCOMPARE(testTerm, expectedTerm);
222​}
223​
224​void AdvancedQueryParserTest::testNestedParentheses_data()
225​{
226​ QTest::addColumn<QString>("searchInput");
227​ QTest::addColumn<Term>("expectedTerm");
228​ QTest::addColumn<QString>("failmessage");
229​ const QString nofail;
brunsUnsubmitted
Done

remove

bruns: remove
230​ QString searchInput;
231​ searchInput = QStringLiteral("a AND b AND c AND d");
brunsUnsubmitted
Done

Remove the searchInput temporary and ...

bruns: Remove the searchInput temporary and ...
232​ QTest::newRow(qPrintable(searchInput))
233​ << searchInput
brunsUnsubmitted
Done

... use the QStringLiteral here

bruns: ... use the QStringLiteral here
234​ << Term{Term::And, QList<Term>{
235​ Term{QStringLiteral(""), QStringLiteral("a"), Term::Contains},
brunsUnsubmitted
Done

Term{QString(), QStringLiteral("a"), Term::Contains},

see http://blog.qt.io/blog/2014/06/13/qt-weekly-13-qstringliteral/

bruns: `Term{QString(), QStringLiteral("a"), Term::Contains},` see http://blog.qt.
236​ Term{QStringLiteral(""), QStringLiteral("b"), Term::Contains},
237​ Term{QStringLiteral(""), QStringLiteral("c"), Term::Contains},
238​ Term{QStringLiteral(""), QStringLiteral("d"), Term::Contains},
239​ }}
240​ << nofail
241​ ;
242​ searchInput = QStringLiteral("(a AND b) AND (c OR d)");
243​ QTest::newRow(qPrintable(searchInput))
244​ << searchInput
245​ << Term{Term::And, QList<Term>{
246​ Term{QStringLiteral(""), QStringLiteral("a"), Term::Contains},
247​ Term{QStringLiteral(""), QStringLiteral("b"), Term::Contains},
248​ Term{Term::Or, QList<Term>{
249​ Term{QStringLiteral(""), QStringLiteral("c"), Term::Contains},
250​ Term{QStringLiteral(""), QStringLiteral("d"), Term::Contains},
251​ }}
252​ }}
253​ << nofail
brunsUnsubmitted
Done

Just << QString()

bruns: Just `<< QString()`
254​ ;
255​ searchInput = QStringLiteral("(a AND (b AND (c AND d)))");
michaelhAuthorUnsubmitted
Done

What about this one? Drop it?

michaelh: What about this one? Drop it?
brunsUnsubmitted
Not Done

I think it should stay as it exercises the stack in the query parser

Pseudocode:

s[0] = a, AND
s[1] = b, AND
t = construct (c AND d)
t = Term( s[1].term, t, s[1].op)  
t = Term( s[0].term, t, s[0].op)
bruns: I think it should stay as it exercises the stack in the query parser Pseudocode: ``` s[0] = a…
256​ QTest::newRow(qPrintable(searchInput))
257​ << searchInput
258​ << Term{Term::And, QList<Term>{
259​ Term{QStringLiteral(""), QStringLiteral("a"), Term::Contains},
260​ Term{QStringLiteral(""), QStringLiteral("b"), Term::Contains},
261​ Term{QStringLiteral(""), QStringLiteral("c"), Term::Contains},
262​ Term{QStringLiteral(""), QStringLiteral("d"), Term::Contains},
263​ }}
264​ << QStringLiteral("no optimization")
brunsUnsubmitted
Done

Adds no information, just use QString() here (and twice below)

bruns: Adds no information, just use QString() here (and twice below)
michaelhAuthorUnsubmitted
Done

This test fails. "no optimization" serves as a flag, that it's expected to fail and as message why. See lines 217-219. That's why I thought of dropping it, because D11826 does not make it pass.

If we drop this test the failmessage column can be removed.

michaelh: This test fails. "no optimization" serves as a flag, that it's expected to fail and as message…
brunsUnsubmitted
Done

Ah, this makes it somewhat complicated ...

So the parsed query is semantically correct, only the term are not merged?
If yes, the best way here is to probably keep this row as is, but also add a check testing for the unoptimized term. The second check should then carry a comment mentioning it is only a fallback.

Anyway, please make the message somewhat more meaningful, e.g. "Fails to optimize for unknown reason, but output is semantically correct".

bruns: Ah, this makes it somewhat complicated ... So the parsed query is semantically correct, only…
265​ ;
266​
267​ searchInput = QStringLiteral("(a AND (b AND (c AND d)))");
268​ QTest::newRow(qPrintable(searchInput))
269​ << searchInput
270​ << Term{Term::And, QList<Term>{
271​ Term{QStringLiteral(""), QStringLiteral("a"), Term::Contains},
272​ Term{QStringLiteral(""), QStringLiteral("b"), Term::Contains},
273​ Term{QStringLiteral(""), QStringLiteral("c"), Term::Contains},
274​ Term{QStringLiteral(""), QStringLiteral("d"), Term::Contains},
275​ }}
276​ << QStringLiteral("no optimization")
277​ ;
278​}
279​
280​void AdvancedQueryParserTest::testOptimizedLogic()
281​{
282​ QFETCH(Term, testTerm);
283​ QFETCH(Term, expectedTerm);
284​ QFETCH(QString, failmessage);
285​ qDebug() << " result term" << testTerm;
286​ qDebug() << "expected term" << expectedTerm;
287​
288​ if (!failmessage.isEmpty()) {
289​ QEXPECT_FAIL("", qPrintable(failmessage), Continue);
290​ }
brunsUnsubmitted
Done

Use "a && b && c && d", makes grepping in case of failure easier?

bruns: Use "a && b && c && d", makes grepping in case of failure easier?
291​ QCOMPARE(testTerm, expectedTerm);
292​}
293​
294​void AdvancedQueryParserTest::testOptimizedLogic_data()
295​{
296​ QTest::addColumn<Term>("testTerm");
297​ QTest::addColumn<Term>("expectedTerm");
298​ QTest::addColumn<QString>("failmessage");
299​
300​ // a && b && c && d can be combined into one AND term with 4 subterms
301​ QTest::addRow("&&")
302​ << (Term{QStringLiteral(""), QStringLiteral("a"), Term::Contains}
303​ && Term{QStringLiteral(""), QStringLiteral("b"), Term::Contains}
304​ && Term{QStringLiteral(""), QStringLiteral("c"), Term::Contains}
305​ && Term{QStringLiteral(""), QStringLiteral("d"), Term::Contains})
brunsUnsubmitted
Done

dito, "(a && b) && (c || d)"

bruns: dito, "(a && b) && (c || d)"
306​ << Term{Term::And, QList<Term>{
307​ Term{QStringLiteral(""), QStringLiteral("a"), Term::Contains},
308​ Term{QStringLiteral(""), QStringLiteral("b"), Term::Contains},
309​ Term{QStringLiteral(""), QStringLiteral("c"), Term::Contains},
310​ Term{QStringLiteral(""), QStringLiteral("d"), Term::Contains},
311​ }}
312​ << QStringLiteral("No optimization");
313​
314​
315​ // (a AND b) AND (c OR d) can be merged as (a AND b AND (c OR D)
316​ QTest::addRow("(&&) AND (||)")
317​ << ((Term{QStringLiteral(""), QStringLiteral("a"), Term::Contains}
318​ && Term{QStringLiteral(""), QStringLiteral("b"), Term::Contains})
319​ && (Term{QStringLiteral(""), QStringLiteral("c"), Term::Contains}
320​ || Term{QStringLiteral(""), QStringLiteral("d"), Term::Contains}
321​ ))
322​ << Term{Term::And, QList<Term>{
323​ Term{QStringLiteral(""), QStringLiteral("a"), Term::Contains},
324​ Term{QStringLiteral(""), QStringLiteral("b"), Term::Contains},
325​ Term{Term::Or, QList<Term>{
326​ Term{QStringLiteral(""), QStringLiteral("c"), Term::Contains},
327​ Term{QStringLiteral(""), QStringLiteral("d"), Term::Contains}
328​ }}
329​ }}
330​ << QStringLiteral("No optimization");
331​}
202 332​
203QTEST_MAIN(AdvancedQueryParserTest) 333​QTEST_MAIN(AdvancedQueryParserTest)
204 334​
205#include "advancedqueryparsertest.moc" 335​#include "advancedqueryparsertest.moc"
brunsUnsubmitted
Done

better use a different name, phrase has a special meaning, i.e. Baloo:EngineQuery:Phrase

bruns: better use a different name, phrase has a special meaning, i.e. Baloo:EngineQuery:Phrase