StarMirror/qTox
1
0
Fork 0
mirror of https://github.com/qTox/qTox.git synced 2024-03-22 14:00:36 +08:00
Code Issues Projects Releases Wiki Activity
bb26d4a086
qTox/test/chatlog/textformatter_test.cpp
jenli669 04a9bc46f4
docs(copyright): update and add copyright info 
zealously updates and adds qTox copyright information.

Fixes #5713
2019-06-28 01:18:26 +02:00

539 lines
20 KiB
C++
Raw Blame History

/*
Copyright © 2017-2019 by The qTox Project Contributors
This file is part of qTox, a Qt-based graphical interface for Tox.
qTox is libre software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
qTox is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with qTox. If not, see <http://www.gnu.org/licenses/>.
*/
#include "src/chatlog/textformatter.h"
#include <QtTest/QtTest>
#include <QString>
#include <ctime>
#include <functional>
#define PAIR_FORMAT(input, output) {QStringLiteral(input), QStringLiteral(output)}
using StringPair = QPair<QString, QString>;
static const StringPair TAGS[] {
PAIR_FORMAT("<b>", "</b>"),
PAIR_FORMAT("<i>", "</i>"),
PAIR_FORMAT("<u>", "</u>"),
PAIR_FORMAT("<s>", "</s>"),
PAIR_FORMAT("<font color=#595959><code>", "</code></font>"),
};
enum StyleType {
BOLD,
ITALIC,
UNDERLINE,
STRIKE,
CODE,
};
/**
* @brief The MarkdownToTags struct maps sequence of markdown symbols to HTML tags according this
* sequence
*/
struct MarkdownToTags
{
QString markdownSequence;
StringPair htmlTags;
};
static const QVector<MarkdownToTags> SINGLE_SIGN_MARKDOWN {
{QStringLiteral("*"), TAGS[StyleType::BOLD]},
{QStringLiteral("/"), TAGS[StyleType::ITALIC]},
{QStringLiteral("_"), TAGS[StyleType::UNDERLINE]},
{QStringLiteral("~"), TAGS[StyleType::STRIKE]},
{QStringLiteral("`"), TAGS[StyleType::CODE]},
};
static const QVector<MarkdownToTags> DOUBLE_SIGN_MARKDOWN {
{QStringLiteral("**"), TAGS[StyleType::BOLD]},
{QStringLiteral("//"), TAGS[StyleType::ITALIC]},
{QStringLiteral("__"), TAGS[StyleType::UNDERLINE]},
{QStringLiteral("~~"), TAGS[StyleType::STRIKE]},
};
static const QVector<MarkdownToTags> MULTI_SIGN_MARKDOWN {
{QStringLiteral("```"), TAGS[StyleType::CODE]},
};
/**
* @brief Creates single container from two
*/
template<class Container>
static Container concat(const Container& first, const Container& last)
{
Container result;
result.reserve(first.size() + last.size());
result.append(first);
result.append(last);
return result;
}
static const QVector<MarkdownToTags> ALL_MARKDOWN_TYPES = concat(concat(SINGLE_SIGN_MARKDOWN,
DOUBLE_SIGN_MARKDOWN),
MULTI_SIGN_MARKDOWN);
static const QVector<MarkdownToTags> SINGLE_AND_DOUBLE_MARKDOWN = concat(SINGLE_SIGN_MARKDOWN,
DOUBLE_SIGN_MARKDOWN);
// any markdown type must work for this data the same way
static const QVector<StringPair> COMMON_WORK_CASES {
PAIR_FORMAT("%1a%1", "%2%1a%1%3"),
PAIR_FORMAT("%1aa%1", "%2%1aa%1%3"),
PAIR_FORMAT("%1aaa%1", "%2%1aaa%1%3"),
// Must allow same formatting more than one time
PAIR_FORMAT("%1aaa%1 %1aaa%1", "%2%1aaa%1%3 %2%1aaa%1%3"),
};
static const QVector<StringPair> SINGLE_SIGN_WORK_CASES {
PAIR_FORMAT("a %1a%1", "a %2%1a%1%3"),
PAIR_FORMAT("%1a%1 a", "%2%1a%1%3 a"),
PAIR_FORMAT("a %1a%1 a", "a %2%1a%1%3 a"),
// "Lazy" matching
PAIR_FORMAT("%1aaa%1 aaa%1", "%2%1aaa%1%3 aaa%4"),
};
// only double-sign markdown must work for this data
static const QVector<StringPair> DOUBLE_SIGN_WORK_CASES {
// Must apply formatting to strings which contain reserved symbols
PAIR_FORMAT("%1aaa%2%1", "%3%1aaa%2%1%4"),
PAIR_FORMAT("%1%2aaa%1", "%3%1%2aaa%1%4"),
PAIR_FORMAT("%1aaa%2aaa%1", "%3%1aaa%2aaa%1%4"),
PAIR_FORMAT("%1%2%2aaa%1", "%3%1%2%2aaa%1%4"),
PAIR_FORMAT("%1aaa%2%2%1", "%3%1aaa%2%2%1%4"),
PAIR_FORMAT("%1aaa%2%2aaa%1", "%3%1aaa%2%2aaa%1%4"),
};
// only multi-sign markdown must work for this data
static const QVector<StringPair> MULTI_SIGN_WORK_CASES {
PAIR_FORMAT("%1int main()\n{ return 0;\n}%1", "%2%1"
"int main()\n{ return 0;\n}"
"%1%3"),
// allows new line and spaces to go right after ``` sequence
PAIR_FORMAT("%1\nint main()\n{ return 0;\n}\n%1", "%2%1"
"\nint main()\n{ return 0;\n}\n"
"%1%3"),
PAIR_FORMAT("%1 int main()\n{ return 0;\n} %1", "%2%1"
" int main()\n{ return 0;\n} "
"%1%3"),
};
// any type of markdown must fail for this data
static const QVector<QString> COMMON_EXCEPTIONS {
// No empty formatting string
QStringLiteral("%1%1"),
// Formatting string must be enclosed by whitespace symbols, newlines or message start/end
QStringLiteral("a%1aa%1a"), QStringLiteral("%1aa%1a"), QStringLiteral("a%1aa%1"),
QStringLiteral("a %1aa%1a"), QStringLiteral("a%1aa%1 a"),
QStringLiteral("a\n%1aa%1a"), QStringLiteral("a%1aa%1\na"),
};
static const QVector<QString> SINGLE_AND_DOUBLE_SIGN_EXCEPTIONS {
// Formatting text must not start/end with whitespace symbols
QStringLiteral("%1 %1"), QStringLiteral("%1 a%1"), QStringLiteral("%1a %1"),
// No newlines
QStringLiteral("%1\n%1"), QStringLiteral("%1aa\n%1"), QStringLiteral("%1\naa%1"),
QStringLiteral("%1aa\naa%1"),
};
// only single-sign markdown must fail for this data
static const QVector<QString> SINGLE_SIGN_EXCEPTIONS {
// Reserved symbols within formatting string are disallowed
QStringLiteral("%1aa%1a%1"), QStringLiteral("%1aa%1%1"), QStringLiteral("%1%1aa%1"),
QStringLiteral("%1%1%1"),
};
static const QVector<StringPair> MIXED_FORMATTING_SPECIAL_CASES {
// Must allow mixed formatting if there is no tag overlap in result
PAIR_FORMAT("aaa *aaa /aaa/ aaa*", "aaa <b>aaa <i>aaa</i> aaa</b>"),
PAIR_FORMAT("aaa *aaa /aaa* aaa/", "aaa *aaa <i>aaa* aaa</i>"),
};
#define MAKE_LINK(url) "<a href=\"" url "\">" url "</a>"
#define MAKE_WWW_LINK(url) "<a href=\"http://" url "\">" url "</a>"
static const QVector<QPair<QString, QString>> URL_CASES {
PAIR_FORMAT("https://github.com/qTox/qTox/issues/4233",
MAKE_LINK("https://github.com/qTox/qTox/issues/4233")),
PAIR_FORMAT("www.youtube.com", MAKE_WWW_LINK("www.youtube.com")),
PAIR_FORMAT("https://url.com/some*url/some*more*url/",
MAKE_LINK("https://url.com/some*url/some*more*url/")),
PAIR_FORMAT("https://url.com/some_url/some_more_url/",
MAKE_LINK("https://url.com/some_url/some_more_url/")),
PAIR_FORMAT("https://url.com/some~url/some~more~url/",
MAKE_LINK("https://url.com/some~url/some~more~url/")),
// Test case from issue #4275
PAIR_FORMAT("http://www.metacritic.com/game/pc/mass-effect-andromeda\n"
"http://www.metacritic.com/game/playstation-4/mass-effect-andromeda\n"
"http://www.metacritic.com/game/xbox-one/mass-effect-andromeda",
MAKE_LINK("http://www.metacritic.com/game/pc/mass-effect-andromeda") "\n"
MAKE_LINK("http://www.metacritic.com/game/playstation-4/mass-effect-andromeda") "\n"
MAKE_LINK("http://www.metacritic.com/game/xbox-one/mass-effect-andromeda")),
PAIR_FORMAT("http://site.com/part1/part2 "
"http://site.com/part3 and one more time "
"www.site.com/part1/part2",
MAKE_LINK("http://site.com/part1/part2") " "
MAKE_LINK("http://site.com/part3") " and one more time "
MAKE_WWW_LINK("www.site.com/part1/part2")),
PAIR_FORMAT("https://127.0.0.1/asd\n"
"https://ABCD:EF01:2345:6789:ABCD:EF01:2345:6789/\n"
"ftp://2001:DB8::8:800:200C:417A/\n"
"http://::1/\n"
"http://::/\n"
"https://127.0.0.1:8080/asd "
"https://[ABCD:EF01:2345:6789:ABCD:EF01:2345:6789]:8080/ "
"ftp://[2001:DB8::8:800:200C:417A]:21/ "
"http://[::1]:22/ "
"http://[::]:20/ ",
MAKE_LINK("https://127.0.0.1/asd") "\n"
MAKE_LINK("https://ABCD:EF01:2345:6789:ABCD:EF01:2345:6789/") "\n"
MAKE_LINK("ftp://2001:DB8::8:800:200C:417A/") "\n"
MAKE_LINK("http://::1/") "\n"
MAKE_LINK("http://::/") "\n"
MAKE_LINK("https://127.0.0.1:8080/asd") " "
MAKE_LINK("https://[ABCD:EF01:2345:6789:ABCD:EF01:2345:6789]:8080/") " "
MAKE_LINK("ftp://[2001:DB8::8:800:200C:417A]:21/") " "
MAKE_LINK("http://[::1]:22/") " "
MAKE_LINK("http://[::]:20/") " "
),
// Test case from issue #4853 (include unicode, ending brackets that are part of URL)
PAIR_FORMAT("https://ja.wikipedia.org/wiki/印章",
MAKE_LINK("https://ja.wikipedia.org/wiki/印章")),
PAIR_FORMAT("https://en.wikipedia.org/wiki/Seal_(East_Asia)",
MAKE_LINK("https://en.wikipedia.org/wiki/Seal_(East_Asia)")),
// Test cases from issue #4295 (exclude surrounding quotes, brackets, ending punctuation)
PAIR_FORMAT("(http://www.google.com)",
"(" MAKE_LINK("http://www.google.com") ")"),
PAIR_FORMAT("&quot;http://www.google.com&quot;",
"&quot;" MAKE_LINK("http://www.google.com") "&quot;"),
PAIR_FORMAT("http://www.google.com.",
MAKE_LINK("http://www.google.com") "."),
PAIR_FORMAT("http://www.google.com,",
MAKE_LINK("http://www.google.com") ","),
PAIR_FORMAT("http://www.google.com?",
MAKE_LINK("http://www.google.com") "?"),
PAIR_FORMAT("https://google.com?gfe_rd=cr",
MAKE_LINK("https://google.com?gfe_rd=cr")),
PAIR_FORMAT("[&quot;https://en.wikipedia.org/wiki/Seal_(East_Asia)&quot;]?",
"[&quot;" MAKE_LINK("https://en.wikipedia.org/wiki/Seal_(East_Asia)") "&quot;]?")
};
#undef PAIR_FORMAT
using MarkdownFunction = QString (*)(const QString&, bool);
using InputProcessor = std::function<QString(const QString&, const MarkdownToTags&)>;
using OutputProcessor = std::function<QString(const QString&, const MarkdownToTags&, bool)>;
/**
* @brief Testing cases where markdown must work
* @param applyMarkdown Function which is used to apply markdown
* @param markdownToTags Which markdown type to test
* @param testData Test data - string pairs "Source message - Message after formatting"
* @param showSymbols True if it is supposed to leave markdown symbols after formatting, false
* otherwise
* @param processInput Test data is a template, which must be expanded with concrete markdown
* symbols, everytime in different way. This function determines how to expand source message
* depending on user need
* @param processOutput Same as previous parameter but is applied to markdown output
*/
static void workCasesTest(MarkdownFunction applyMarkdown,
const QVector<MarkdownToTags>& markdownToTags,
const QVector<StringPair>& testData,
bool showSymbols,
InputProcessor processInput = nullptr,
OutputProcessor processOutput = nullptr)
{
for (const MarkdownToTags& mtt: markdownToTags) {
for (const StringPair& data: testData) {
const QString input = processInput != nullptr ? processInput(data.first, mtt)
: data.first;
QString output = processOutput != nullptr ? processOutput(data.second, mtt, showSymbols)
: data.second;
QString result = applyMarkdown(input, showSymbols);
QVERIFY(output == result);
}
}
}
/**
* @brief Testing cases where markdown must not to work
* @param applyMarkdown Function which is used to apply markdown
* @param markdownToTags Which markdown type to test
* @param exceptions Collection of "source message - markdown result" pairs representing cases
* where markdown must not to work
* @param showSymbols True if it is supposed to leave markdown symbols after formatting, false
* otherwise
*/
static void exceptionsTest(MarkdownFunction applyMarkdown,
const QVector<MarkdownToTags>& markdownToTags,
const QVector<QString>& exceptions,
bool showSymbols)
{
for (const MarkdownToTags& mtt: markdownToTags) {
for (const QString& e: exceptions) {
QString processedException = e.arg(mtt.markdownSequence);
QVERIFY(processedException == applyMarkdown(processedException, showSymbols));
}
}
}
/**
* @brief Testing some uncommon work cases
* @param applyMarkdown Function which is used to apply markdown
* @param pairs Collection of "source message - markdown result" pairs representing cases where
* markdown must not to work
*/
static void specialCasesTest(MarkdownFunction applyMarkdown,
const QVector<StringPair>& pairs)
{
for (const auto& p : pairs) {
QString result = applyMarkdown(p.first, false);
QVERIFY(p.second == result);
}
}
using UrlHighlightFunction = QString(*)(const QString&);
/**
* @brief Function for testing URL highlighting
* @param data Test data - map of "URL - HTML-wrapped URL"
*/
static void urlHighlightTest(UrlHighlightFunction function, const QVector<QPair<QString, QString>>& data)
{
for (const QPair<QString, QString>& p : data) {
QString result = function(p.first);
QVERIFY(p.second == result);
}
}
class TestTextFormatter : public QObject
{
Q_OBJECT
private slots:
void commonWorkCasesShowSymbols();
void commonWorkCasesHideSymbols();
void singleSignWorkCasesShowSymbols();
void singleSignWorkCasesHideSymbols();
void doubleSignWorkCasesShowSymbols();
void doubleSignWorkCasesHideSymbols();
void multiSignWorkCasesHideSymbols();
void multiSignWorkCasesShowSymbols();
void commonExceptionsShowSymbols();
void commonExceptionsHideSymbols();
void singleSignExceptionsShowSymbols();
void singleSignExceptionsHideSymbols();
void singleAndDoubleMarkdownExceptionsShowSymbols();
void singleAndDoubleMarkdownExceptionsHideSymbols();
void mixedFormattingSpecialCases();
void urlTest();
private:
const MarkdownFunction markdownFunction = applyMarkdown;
UrlHighlightFunction urlHighlightFunction = highlightURI;
};
static QString commonWorkCasesProcessInput(const QString& str, const MarkdownToTags& mtt)
{
return str.arg(mtt.markdownSequence);
}
static QString commonWorkCasesProcessOutput(const QString& str,
const MarkdownToTags& mtt,
bool showSymbols)
{
const StringPair& tags = mtt.htmlTags;
return str.arg(showSymbols ? mtt.markdownSequence : QString{}).arg(tags.first).arg(tags.second);
}
void TestTextFormatter::commonWorkCasesShowSymbols()
{
workCasesTest(markdownFunction,
ALL_MARKDOWN_TYPES,
COMMON_WORK_CASES,
true,
commonWorkCasesProcessInput,
commonWorkCasesProcessOutput);
}
void TestTextFormatter::commonWorkCasesHideSymbols()
{
workCasesTest(markdownFunction,
ALL_MARKDOWN_TYPES,
COMMON_WORK_CASES,
false,
commonWorkCasesProcessInput,
commonWorkCasesProcessOutput);
}
static QString singleSignWorkCasesProcessInput(const QString& str, const MarkdownToTags& mtt)
{
return str.arg(mtt.markdownSequence);
}
static QString singleSignWorkCasesProcessOutput(const QString& str,
const MarkdownToTags& mtt,
bool showSymbols)
{
const StringPair& tags = mtt.htmlTags;
return str.arg(showSymbols ? mtt.markdownSequence : "")
.arg(tags.first)
.arg(tags.second)
.arg(mtt.markdownSequence);
}
void TestTextFormatter::singleSignWorkCasesShowSymbols()
{
workCasesTest(markdownFunction,
SINGLE_SIGN_MARKDOWN,
SINGLE_SIGN_WORK_CASES,
true,
singleSignWorkCasesProcessInput,
singleSignWorkCasesProcessOutput);
}
void TestTextFormatter::singleSignWorkCasesHideSymbols()
{
workCasesTest(markdownFunction,
SINGLE_SIGN_MARKDOWN,
SINGLE_SIGN_WORK_CASES,
false,
singleSignWorkCasesProcessInput,
singleSignWorkCasesProcessOutput);
}
static QString doubleSignWorkCasesProcessInput(const QString& str, const MarkdownToTags& mtt)
{
return str.arg(mtt.markdownSequence).arg(mtt.markdownSequence[0]);
}
static QString doubleSignWorkCasesProcessOutput(const QString& str,
const MarkdownToTags& mtt,
bool showSymbols)
{
const StringPair& tags = mtt.htmlTags;
return str.arg(showSymbols ? mtt.markdownSequence : "")
.arg(mtt.markdownSequence[0])
.arg(tags.first)
.arg(tags.second);
}
void TestTextFormatter::doubleSignWorkCasesShowSymbols()
{
workCasesTest(markdownFunction,
DOUBLE_SIGN_MARKDOWN,
DOUBLE_SIGN_WORK_CASES,
true,
doubleSignWorkCasesProcessInput,
doubleSignWorkCasesProcessOutput);
}
void TestTextFormatter::doubleSignWorkCasesHideSymbols()
{
workCasesTest(markdownFunction,
DOUBLE_SIGN_MARKDOWN,
DOUBLE_SIGN_WORK_CASES,
false,
doubleSignWorkCasesProcessInput,
doubleSignWorkCasesProcessOutput);
}
static QString multiSignWorkCasesProcessInput(const QString& str, const MarkdownToTags& mtt)
{
return str.arg(mtt.markdownSequence);
}
static QString multiSignWorkCasesProcessOutput(const QString& str,
const MarkdownToTags& mtt,
bool showSymbols)
{
const auto tags = mtt.htmlTags;
return str.arg(showSymbols ? mtt.markdownSequence : "", tags.first, tags.second);
}
void TestTextFormatter::multiSignWorkCasesHideSymbols()
{
workCasesTest(markdownFunction,
MULTI_SIGN_MARKDOWN,
MULTI_SIGN_WORK_CASES,
false,
multiSignWorkCasesProcessInput,
multiSignWorkCasesProcessOutput);
}
void TestTextFormatter::multiSignWorkCasesShowSymbols()
{
workCasesTest(markdownFunction,
MULTI_SIGN_MARKDOWN,
MULTI_SIGN_WORK_CASES,
true,
multiSignWorkCasesProcessInput,
multiSignWorkCasesProcessOutput);
}
void TestTextFormatter::commonExceptionsShowSymbols()
{
exceptionsTest(markdownFunction, ALL_MARKDOWN_TYPES, COMMON_EXCEPTIONS, true);
}
void TestTextFormatter::commonExceptionsHideSymbols()
{
exceptionsTest(markdownFunction, ALL_MARKDOWN_TYPES, COMMON_EXCEPTIONS, false);
}
void TestTextFormatter::singleSignExceptionsShowSymbols()
{
exceptionsTest(markdownFunction, SINGLE_SIGN_MARKDOWN, SINGLE_SIGN_EXCEPTIONS, true);
}
void TestTextFormatter::singleSignExceptionsHideSymbols()
{
exceptionsTest(markdownFunction, SINGLE_SIGN_MARKDOWN, SINGLE_SIGN_EXCEPTIONS, false);
}
void TestTextFormatter::singleAndDoubleMarkdownExceptionsShowSymbols()
{
exceptionsTest(markdownFunction,
SINGLE_AND_DOUBLE_MARKDOWN,
SINGLE_AND_DOUBLE_SIGN_EXCEPTIONS,
true);
}
void TestTextFormatter::singleAndDoubleMarkdownExceptionsHideSymbols()
{
exceptionsTest(markdownFunction,
SINGLE_AND_DOUBLE_MARKDOWN,
SINGLE_AND_DOUBLE_SIGN_EXCEPTIONS,
false);
}
void TestTextFormatter::mixedFormattingSpecialCases()
{
specialCasesTest(markdownFunction, MIXED_FORMATTING_SPECIAL_CASES);
}
void TestTextFormatter::urlTest()
{
urlHighlightTest(urlHighlightFunction, URL_CASES);
}
QTEST_GUILESS_MAIN(TestTextFormatter)
#include "textformatter_test.moc"
Reference in New Issue View Git Blame Copy Permalink