From 1562179bdc3f10417a56d6e3a2333183b8e9b8ad Mon Sep 17 00:00:00 2001 From: Pesc0 Date: Sat, 11 Mar 2023 15:48:12 +0100 Subject: [PATCH] MappedName unit tests almost complete --- src/App/MappedName.h | 13 +- tests/src/App/MappedName.cpp | 420 ++++++++++++++++++++++++++++++++--- 2 files changed, 397 insertions(+), 36 deletions(-) diff --git a/src/App/MappedName.h b/src/App/MappedName.h index 89b6bf56ea..89e95fd4ad 100644 --- a/src/App/MappedName.h +++ b/src/App/MappedName.h @@ -93,11 +93,9 @@ public: : data(other.data + other.postfix), postfix(postfix), raw(false) {} -#if QT_VERSION >= 0x050200 MappedName(MappedName &&other) : data(std::move(other.data)), postfix(std::move(other.postfix)), raw(other.raw) {} -#endif static MappedName fromRawData(const char * name, int size = -1) { @@ -165,7 +163,6 @@ public: } -#if QT_VERSION >= 0x050200 MappedName & operator=(MappedName &&other) { this->data = std::move(other.data); @@ -173,7 +170,6 @@ public: this->raw = other.raw; return *this; } -#endif friend std::ostream & operator<<(std::ostream & s, const MappedName & n) { @@ -368,6 +364,8 @@ public: return s.c_str() + offset; } + //if offset is inside data return data, if offset is > data.size + //(ends up in postfix) return postfix const char * toConstString(int offset, int &size) const { if (offset < 0) @@ -486,6 +484,7 @@ public: char operator[](int index) const { + //FIXME overflow underflow checks? if (index >= this->data.size()) return this->postfix[index - this->data.size()]; return this->data[index]; @@ -558,7 +557,7 @@ public: { if (!d) return -1; - if (startpos < 0 || startpos > this->postfix.size()) { + if (startpos < 0 || startpos > this->postfix.size()) { //FIXME should be this->data.size if (startpos > postfix.size()) startpos -= postfix.size(); int res = this->postfix.lastIndexOf(d, startpos); @@ -613,11 +612,7 @@ public: std::size_t hash() const { -#if QT_VERSION >= 0x050000 return qHash(data, qHash(postfix)); -#else - return qHash(data) ^ qHash(postfix); -#endif } private: diff --git a/tests/src/App/MappedName.cpp b/tests/src/App/MappedName.cpp index dc3ae1b383..5ddee750d8 100644 --- a/tests/src/App/MappedName.cpp +++ b/tests/src/App/MappedName.cpp @@ -6,13 +6,14 @@ #include "App/ComplexGeoData.h" #include +#include // clang-format off TEST(MappedName, defaultConstruction) { - auto mappedName = Data::MappedName(); + Data::MappedName mappedName = Data::MappedName(); EXPECT_EQ(mappedName.isRaw(), false); EXPECT_EQ(mappedName.empty(), true); EXPECT_EQ(mappedName.size(), 0); @@ -20,7 +21,7 @@ TEST(MappedName, defaultConstruction) TEST(MappedName, namedConstruction) { - auto mappedName = Data::MappedName("TEST"); + Data::MappedName mappedName = Data::MappedName("TEST"); EXPECT_EQ(mappedName.isRaw(), false); EXPECT_EQ(mappedName.empty(), false); EXPECT_EQ(mappedName.size(), 4); @@ -30,7 +31,7 @@ TEST(MappedName, namedConstruction) TEST(MappedName, namedConstructionWithMaxSize) { - auto mappedName = Data::MappedName("TEST", 2); + Data::MappedName mappedName = Data::MappedName("TEST", 2); EXPECT_EQ(mappedName.isRaw(), false); EXPECT_EQ(mappedName.empty(), false); EXPECT_EQ(mappedName.size(), 2); @@ -41,7 +42,7 @@ TEST(MappedName, namedConstructionWithMaxSize) TEST(MappedName, namedConstructionDiscardPrefix) { std::string name = Data::ComplexGeoData::elementMapPrefix() + "TEST"; - auto mappedName = Data::MappedName(name.c_str()); + Data::MappedName mappedName = Data::MappedName(name.c_str()); EXPECT_EQ(mappedName.isRaw(), false); EXPECT_EQ(mappedName.empty(), false); EXPECT_EQ(mappedName.size(), 4); @@ -52,7 +53,7 @@ TEST(MappedName, namedConstructionDiscardPrefix) TEST(MappedName, stringNamedConstruction) { - auto mappedName = Data::MappedName(std::string("TEST")); + Data::MappedName mappedName = Data::MappedName(std::string("TEST")); EXPECT_EQ(mappedName.isRaw(), false); EXPECT_EQ(mappedName.empty(), false); EXPECT_EQ(mappedName.size(), 4); @@ -63,7 +64,7 @@ TEST(MappedName, stringNamedConstruction) TEST(MappedName, stringNamedConstructionDiscardPrefix) { std::string name = Data::ComplexGeoData::elementMapPrefix() + "TEST"; - auto mappedName = Data::MappedName(name); + Data::MappedName mappedName = Data::MappedName(name); EXPECT_EQ(mappedName.isRaw(), false); EXPECT_EQ(mappedName.empty(), false); EXPECT_EQ(mappedName.size(), 4); @@ -74,8 +75,8 @@ TEST(MappedName, stringNamedConstructionDiscardPrefix) TEST(MappedName, copyConstructor) { - auto temp = Data::MappedName("TEST"); - auto mappedName = Data::MappedName(temp); + Data::MappedName temp = Data::MappedName("TEST"); + Data::MappedName mappedName = Data::MappedName(temp); EXPECT_EQ(mappedName.isRaw(), false); EXPECT_EQ(mappedName.empty(), false); EXPECT_EQ(mappedName.size(), 4); @@ -86,8 +87,8 @@ TEST(MappedName, copyConstructor) TEST(MappedName, copyConstructorWithPostfix) { - auto temp = Data::MappedName("TEST"); - auto mappedName = Data::MappedName(temp, "POSTFIXTEST"); + Data::MappedName temp = Data::MappedName("TEST"); + Data::MappedName mappedName = Data::MappedName(temp, "POSTFIXTEST"); EXPECT_EQ(mappedName.isRaw(), false); EXPECT_EQ(mappedName.empty(), false); EXPECT_EQ(mappedName.size(), 15); @@ -97,8 +98,8 @@ TEST(MappedName, copyConstructorWithPostfix) TEST(MappedName, constructorWithPostfixAndCopy) { - auto temp = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); - auto mappedName = Data::MappedName(temp, "ANOTHERPOSTFIX"); + Data::MappedName temp = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); + Data::MappedName mappedName = Data::MappedName(temp, "ANOTHERPOSTFIX"); EXPECT_EQ(mappedName.isRaw(), false); EXPECT_EQ(mappedName.empty(), false); EXPECT_EQ(mappedName.size(), 29); @@ -108,8 +109,8 @@ TEST(MappedName, constructorWithPostfixAndCopy) TEST(MappedName, copyConstructorStartpos) { - auto temp = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); - auto mappedName = Data::MappedName(temp, 2, -1); + Data::MappedName temp = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); + Data::MappedName mappedName = Data::MappedName(temp, 2, -1); EXPECT_EQ(mappedName.isRaw(), false); EXPECT_EQ(mappedName.empty(), false); EXPECT_EQ(mappedName.size(), 13); @@ -119,8 +120,8 @@ TEST(MappedName, copyConstructorStartpos) TEST(MappedName, copyConstructorStartposAndSize) { - auto temp = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); - auto mappedName = Data::MappedName(temp, 2, 6); + Data::MappedName temp = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); + Data::MappedName mappedName = Data::MappedName(temp, 2, 6); EXPECT_EQ(mappedName.isRaw(), false); EXPECT_EQ(mappedName.empty(), false); EXPECT_EQ(mappedName.size(), 6); @@ -128,11 +129,10 @@ TEST(MappedName, copyConstructorStartposAndSize) EXPECT_EQ(mappedName.postfixBytes(), QByteArray("POST")); } -#if QT_VERSION >= 0x050200 TEST(MappedName, moveConstructor) { - auto temp = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); - auto mappedName = Data::MappedName(std::move(temp)); + Data::MappedName temp = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); + Data::MappedName mappedName = Data::MappedName(std::move(temp)); EXPECT_EQ(mappedName.isRaw(), false); EXPECT_EQ(mappedName.empty(), false); EXPECT_EQ(mappedName.size(), 15); @@ -145,11 +145,10 @@ TEST(MappedName, moveConstructor) EXPECT_EQ(temp.dataBytes(), QByteArray()); EXPECT_EQ(temp.postfixBytes(), QByteArray()); } -#endif TEST(MappedName, fromRawData) { - auto mappedName = Data::MappedName::fromRawData("TEST\0\0TEST", 10); + Data::MappedName mappedName = Data::MappedName::fromRawData("TEST\0\0TEST", 10); EXPECT_EQ(mappedName.isRaw(), true); EXPECT_EQ(mappedName.empty(), false); EXPECT_EQ(mappedName.size(), 10); @@ -159,7 +158,7 @@ TEST(MappedName, fromRawData) TEST(MappedName, fromRawDataQByteArray) { - auto mappedName = Data::MappedName::fromRawData(QByteArray("TEST\0\0TEST", 10)); + Data::MappedName mappedName = Data::MappedName::fromRawData(QByteArray("TEST\0\0TEST", 10)); EXPECT_EQ(mappedName.isRaw(), true); EXPECT_EQ(mappedName.empty(), false); EXPECT_EQ(mappedName.size(), 10); @@ -169,9 +168,9 @@ TEST(MappedName, fromRawDataQByteArray) TEST(MappedName, fromRawDataCopy) { - auto temp = Data::MappedName::fromRawData(QByteArray("TEST\0\0TEST", 10)); + Data::MappedName temp = Data::MappedName::fromRawData(QByteArray("TEST\0\0TEST", 10)); temp.append("TESTPOSTFIX"); - auto mappedName = Data::MappedName::fromRawData(temp, 0); + Data::MappedName mappedName = Data::MappedName::fromRawData(temp, 0); EXPECT_EQ(mappedName.isRaw(), true); EXPECT_EQ(mappedName.empty(), false); EXPECT_EQ(mappedName.size(), 21); @@ -182,7 +181,7 @@ TEST(MappedName, fromRawDataCopy) TEST(MappedName, fromRawDataCopyStartposAndSize) { - auto temp = Data::MappedName::fromRawData(QByteArray("TEST\0\0TEST", 10)); + Data::MappedName temp = Data::MappedName::fromRawData(QByteArray("TEST\0\0TEST", 10)); temp.append("ABCDEFGHIJKLM"); //postfix /* This block is OK EXPECT_EQ(temp.isRaw(), true); @@ -192,7 +191,7 @@ TEST(MappedName, fromRawDataCopyStartposAndSize) EXPECT_EQ(temp.postfixBytes(), QByteArray("ABCDEFGHIJKLM")); */ - auto mappedName = Data::MappedName::fromRawData(temp, 2, 13); + Data::MappedName mappedName = Data::MappedName::fromRawData(temp, 2, 13); EXPECT_EQ(mappedName.isRaw(), true); EXPECT_EQ(mappedName.empty(), false); EXPECT_EQ(mappedName.size(), 13); @@ -203,8 +202,375 @@ TEST(MappedName, fromRawDataCopyStartposAndSize) EXPECT_EQ(mappedName.postfixBytes(), QByteArray("ABCDE")); } -//TODO raw postfix? +//TODO raw postfix? answer: apparently postfix will never be raw. See copy() + +TEST(MappedName, assignmentOperator) +{ + Data::MappedName temp = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); + Data::MappedName mappedName = temp; + EXPECT_EQ(mappedName.isRaw(), false); + EXPECT_EQ(mappedName.empty(), false); + EXPECT_EQ(mappedName.size(), 15); + EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST")); + EXPECT_EQ(mappedName.postfixBytes(), QByteArray("POSTFIXTEST")); +} + +TEST(MappedName, assignmentOperatorString) +{ + Data::MappedName mappedName; + mappedName = std::string("TEST"); + EXPECT_EQ(mappedName.isRaw(), false); + EXPECT_EQ(mappedName.empty(), false); + EXPECT_EQ(mappedName.size(), 4); + EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST")); + EXPECT_EQ(mappedName.postfixBytes(), QByteArray()); +} + +TEST(MappedName, assignmentOperatorConstCharPtr) +{ + Data::MappedName mappedName; + mappedName = "TEST"; + EXPECT_EQ(mappedName.isRaw(), false); + EXPECT_EQ(mappedName.empty(), false); + EXPECT_EQ(mappedName.size(), 4); + EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST")); + EXPECT_EQ(mappedName.postfixBytes(), QByteArray()); +} + +TEST(MappedName, operatorEqualMove) +{ + Data::MappedName temp = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); + Data::MappedName mappedName = std::move(temp); + EXPECT_EQ(mappedName.isRaw(), false); + EXPECT_EQ(mappedName.empty(), false); + EXPECT_EQ(mappedName.size(), 15); + EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST")); + EXPECT_EQ(mappedName.postfixBytes(), QByteArray("POSTFIXTEST")); + + EXPECT_EQ(temp.isRaw(), false); + EXPECT_EQ(temp.empty(), true); + EXPECT_EQ(temp.size(), 0); + EXPECT_EQ(temp.dataBytes(), QByteArray()); + EXPECT_EQ(temp.postfixBytes(), QByteArray()); +} + +TEST(MappedName, streamInsertionOperator) +{ + Data::MappedName mappedName = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); + + EXPECT_EQ(mappedName.isRaw(), false); + EXPECT_EQ(mappedName.empty(), false); + EXPECT_EQ(mappedName.size(), 15); + EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST")); + EXPECT_EQ(mappedName.postfixBytes(), QByteArray("POSTFIXTEST")); + + std::stringstream ss; + ss << mappedName; + EXPECT_EQ(ss.str(), std::string("TESTPOSTFIXTEST")); +} +TEST(MappedName, comparisonOperators) +{ + Data::MappedName mappedName1 = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); + Data::MappedName mappedName2 = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); + Data::MappedName mappedName3 = Data::MappedName(Data::MappedName("TESTPOST"), "FIXTEST"); + Data::MappedName mappedName4 = Data::MappedName(Data::MappedName("THIS"), "ISDIFFERENT"); + + EXPECT_EQ(mappedName1 == mappedName1, true); + EXPECT_EQ(mappedName1 == mappedName2, true); + EXPECT_EQ(mappedName1 == mappedName3, true); + EXPECT_EQ(mappedName1 == mappedName4, false); + + EXPECT_EQ(mappedName1 != mappedName1, false); + EXPECT_EQ(mappedName1 != mappedName2, false); + EXPECT_EQ(mappedName1 != mappedName3, false); + EXPECT_EQ(mappedName1 != mappedName4, true); +} + +TEST(MappedName, additionOperators) +{ + Data::MappedName mappedName1 = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); + mappedName1 += "POST1"; + mappedName1 += std::string("POST2"); + mappedName1 += QByteArray("POST3"); + mappedName1 += Data::MappedName("POST4"); + + EXPECT_EQ(mappedName1.isRaw(), false); + EXPECT_EQ(mappedName1.empty(), false); + EXPECT_EQ(mappedName1.size(), 35); + EXPECT_EQ(mappedName1.dataBytes(), QByteArray("TEST")); + EXPECT_EQ(mappedName1.postfixBytes(), QByteArray("POSTFIXTESTPOST1POST2POST3POST4")); + + mappedName1 = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); + mappedName1 = mappedName1 + Data::MappedName("POST5"); + mappedName1 = mappedName1 + "POST6"; + mappedName1 = mappedName1 + std::string("POST7"); + mappedName1 = mappedName1 + QByteArray("POST8"); + + EXPECT_EQ(mappedName1.isRaw(), false); + EXPECT_EQ(mappedName1.empty(), false); + EXPECT_EQ(mappedName1.size(), 35); + EXPECT_EQ(mappedName1.dataBytes(), QByteArray("TEST")); + EXPECT_EQ(mappedName1.postfixBytes(), QByteArray("POSTFIXTESTPOST5POST6POST7POST8")); +} + + +TEST(MappedName, append) +{ + Data::MappedName mappedName = Data::MappedName(); + mappedName.append("TEST"); + EXPECT_EQ(mappedName.isRaw(), false); + EXPECT_EQ(mappedName.empty(), false); + EXPECT_EQ(mappedName.size(), 4); + EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST")); + EXPECT_EQ(mappedName.postfixBytes(), QByteArray("")); + + mappedName.append("POSTFIX"); + EXPECT_EQ(mappedName.isRaw(), false); + EXPECT_EQ(mappedName.empty(), false); + EXPECT_EQ(mappedName.size(), 11); + EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST")); + EXPECT_EQ(mappedName.postfixBytes(), QByteArray("POSTFIX")); + + mappedName.append("ANOTHERPOSTFIX", 5); + EXPECT_EQ(mappedName.isRaw(), false); + EXPECT_EQ(mappedName.empty(), false); + EXPECT_EQ(mappedName.size(), 16); + EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST")); + EXPECT_EQ(mappedName.postfixBytes(), QByteArray("POSTFIXANOTH")); +} + + +TEST(MappedName, appendMappedNameObj) +{ + Data::MappedName mappedName = Data::MappedName(); + + mappedName.append(Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST")); + EXPECT_EQ(mappedName.isRaw(), false); + EXPECT_EQ(mappedName.empty(), false); + EXPECT_EQ(mappedName.size(), 15); + EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST")); + EXPECT_EQ(mappedName.postfixBytes(), QByteArray("POSTFIXTEST")); + + mappedName.append(Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"), 2, 7); + EXPECT_EQ(mappedName.isRaw(), false); + EXPECT_EQ(mappedName.empty(), false); + EXPECT_EQ(mappedName.size(), 22); + EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST")); + EXPECT_EQ(mappedName.postfixBytes(), QByteArray("POSTFIXTESTSTPOSTF")); +} + +TEST(MappedName, toString) +{ + Data::MappedName mappedName = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); + EXPECT_EQ(mappedName.toString(0), "TESTPOSTFIXTEST"); + EXPECT_EQ(mappedName.toString(0), std::string("TESTPOSTFIXTEST")); + EXPECT_EQ(mappedName.toString(2, 8), "STPOSTFI"); + EXPECT_EQ(mappedName.toString(2, 8), std::string("STPOSTFI")); +} + + +TEST(MappedName, toConstString) +{ + Data::MappedName mappedName = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); + int size; + const char *temp = mappedName.toConstString(0, size); + EXPECT_EQ(QByteArray(temp, size), QByteArray("TEST")); + EXPECT_EQ(size, 4); + const char *temp2 = mappedName.toConstString(7, size); + EXPECT_EQ(QByteArray(temp2, size), QByteArray("TFIXTEST")); + EXPECT_EQ(size, 8); +} + +TEST(MappedName, toRawBytes) +{ + Data::MappedName mappedName = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); + EXPECT_EQ(mappedName.toRawBytes(), QByteArray("TESTPOSTFIXTEST")); + EXPECT_EQ(mappedName.toRawBytes(3), QByteArray("TPOSTFIXTEST")); + EXPECT_EQ(mappedName.toRawBytes(7, 3), QByteArray("TFI")); + EXPECT_EQ(mappedName.toRawBytes(502, 5), QByteArray()); +} + +TEST(MappedName, toBytes) +{ + Data::MappedName mappedName = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); + EXPECT_EQ(mappedName.toBytes(), QByteArray("TESTPOSTFIXTEST")); +} + + +TEST(MappedName, compare) +{ + Data::MappedName mappedName1 = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); + Data::MappedName mappedName2 = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); + Data::MappedName mappedName3 = Data::MappedName(Data::MappedName("TESTPOST"), "FIXTEST"); + Data::MappedName mappedName4 = Data::MappedName(Data::MappedName("THIS"), "ISDIFFERENT"); + Data::MappedName mappedName5 = Data::MappedName(Data::MappedName("SH"), "ORTHER"); + Data::MappedName mappedName6 = Data::MappedName(Data::MappedName("VERYVERYVERY"), "VERYMUCHLONGER"); + + EXPECT_EQ(mappedName1.compare(mappedName1), 0); + EXPECT_EQ(mappedName1.compare(mappedName2), 0); + EXPECT_EQ(mappedName1.compare(mappedName3), 0); + EXPECT_EQ(mappedName1.compare(mappedName4), -1); + EXPECT_EQ(mappedName1.compare(mappedName5), 1); + EXPECT_EQ(mappedName1.compare(mappedName6), -1); + + EXPECT_EQ(mappedName1 < mappedName1, false); + EXPECT_EQ(mappedName1 < mappedName2, false); + EXPECT_EQ(mappedName1 < mappedName3, false); + EXPECT_EQ(mappedName1 < mappedName4, true); + EXPECT_EQ(mappedName1 < mappedName5, false); + EXPECT_EQ(mappedName1 < mappedName6, true); +} + +TEST(MappedName, indexOperator) +{ + Data::MappedName mappedName = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); + EXPECT_EQ(mappedName[0], 'T'); + EXPECT_EQ(mappedName[1], 'E'); + EXPECT_EQ(mappedName[2], 'S'); + EXPECT_EQ(mappedName[3], 'T'); + EXPECT_EQ(mappedName[4], 'P'); + EXPECT_EQ(mappedName[5], 'O'); + EXPECT_EQ(mappedName[6], 'S'); + EXPECT_EQ(mappedName[7], 'T'); + EXPECT_EQ(mappedName[8], 'F'); + EXPECT_EQ(mappedName[9], 'I'); +} + +TEST(MappedName, copy) +{ + Data::MappedName mappedName = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); + Data::MappedName mappedName2 = mappedName.copy(); + EXPECT_EQ(mappedName, mappedName2); +} + + +TEST(MappedName, compact) +{ + Data::MappedName mappedName = Data::MappedName::fromRawData("TEST\0\0TEST", 10); + EXPECT_EQ(mappedName.isRaw(), true); + EXPECT_EQ(mappedName.empty(), false); + EXPECT_EQ(mappedName.size(), 10); + EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST\0\0TEST", 10)); + EXPECT_EQ(mappedName.postfixBytes(), QByteArray()); + + mappedName.compact(); + EXPECT_EQ(mappedName.isRaw(), false); + EXPECT_EQ(mappedName.empty(), false); + EXPECT_EQ(mappedName.size(), 10); + EXPECT_EQ(mappedName.dataBytes(), QByteArray("TEST\0\0TEST", 10)); + EXPECT_EQ(mappedName.postfixBytes(), QByteArray()); +} + +TEST(MappedName, boolOperator) +{ + Data::MappedName mappedName = Data::MappedName(); + EXPECT_EQ((bool)mappedName, false); + mappedName.append("TEST"); + EXPECT_EQ((bool)mappedName, true); +} + +TEST(MappedName, clear) +{ + Data::MappedName mappedName = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); + EXPECT_EQ(mappedName.empty(), false); + mappedName.clear(); + EXPECT_EQ(mappedName.empty(), true); +} + +TEST(MappedName, find) +{ + Data::MappedName mappedName = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); + EXPECT_EQ(mappedName.find(nullptr), -1); + EXPECT_EQ(mappedName.find(""), 0); + EXPECT_EQ(mappedName.find("TEST"), 0); + EXPECT_EQ(mappedName.find("STPO"), -1); //sentence must be fully contained in data or postfix + EXPECT_EQ(mappedName.find("POST"), 4); + EXPECT_EQ(mappedName.find("ST", 3), 6); //found in postfix + EXPECT_EQ(mappedName.find("POST", 4), 4); + EXPECT_EQ(mappedName.find("POST", 5), -1); + + EXPECT_EQ(mappedName.find(std::string("")), 0); +} + + +TEST(MappedName, rfind) +{ + Data::MappedName mappedName = Data::MappedName(Data::MappedName("TEST"), "POSTFIXTEST"); + EXPECT_EQ(mappedName.rfind(nullptr), -1); + EXPECT_EQ(mappedName.rfind(""), mappedName.size()); + EXPECT_EQ(mappedName.rfind("TEST"), 11); + EXPECT_EQ(mappedName.rfind("STPO"), -1); //sentence must be fully contained in data or postfix + EXPECT_EQ(mappedName.rfind("POST"), 4); + + + //FIXME looks broken + EXPECT_EQ(mappedName.rfind("ST"), 13); + EXPECT_EQ(mappedName.rfind("ST", 0), -1); + EXPECT_EQ(mappedName.rfind("ST", 1), -1); + EXPECT_EQ(mappedName.rfind("ST", 2), 2); + EXPECT_EQ(mappedName.rfind("ST", 3), 2); + EXPECT_EQ(mappedName.rfind("ST", 4), 2); + EXPECT_EQ(mappedName.rfind("ST", 5), -1); + EXPECT_EQ(mappedName.rfind("ST", 6), -1); + EXPECT_EQ(mappedName.rfind("ST", 7), -1); + EXPECT_EQ(mappedName.rfind("ST", 8), -1); + EXPECT_EQ(mappedName.rfind("ST", 9), -1); + EXPECT_EQ(mappedName.rfind("ST", 10), -1); + EXPECT_EQ(mappedName.rfind("ST", 11), -1); + EXPECT_EQ(mappedName.rfind("ST", 12), 2); + EXPECT_EQ(mappedName.rfind("ST", 13), 6); + EXPECT_EQ(mappedName.rfind("ST", 14), 6); + EXPECT_EQ(mappedName.rfind("ST", 15), 6); + EXPECT_EQ(mappedName.rfind("ST", 16), 6); + EXPECT_EQ(mappedName.rfind("ST", 17), 6); + EXPECT_EQ(mappedName.rfind("ST", 18), 6); + EXPECT_EQ(mappedName.rfind("ST", 19), 6); + EXPECT_EQ(mappedName.rfind("ST", 20), 13); + EXPECT_EQ(mappedName.rfind("ST", 21), 13); + EXPECT_EQ(mappedName.rfind("ST", 22), 13); + EXPECT_EQ(mappedName.rfind("ST", 23), 2); + EXPECT_EQ(mappedName.rfind("ST", 24), 2); + EXPECT_EQ(mappedName.rfind("ST", 25), 2); + EXPECT_EQ(mappedName.rfind("ST", 26), 2); + EXPECT_EQ(mappedName.rfind("ST", 27), 2); + EXPECT_EQ(mappedName.rfind("ST", 28), 2); + //EXPECT_EQ(mappedName.rfind("POST", 7), 4); + //EXPECT_EQ(mappedName.rfind("POST", 8), -1); + + EXPECT_EQ(mappedName.rfind(std::string("")), mappedName.size()); +} + +TEST(MappedName, endswith) +{ + Data::MappedName mappedName = Data::MappedName("TEST"); + EXPECT_EQ(mappedName.endsWith(nullptr), false); + EXPECT_EQ(mappedName.endsWith("TEST"), true); + EXPECT_EQ(mappedName.endsWith("WASD"), false); + + EXPECT_EQ(mappedName.endsWith(std::string("TEST")), true); + + mappedName.append("POSTFIX"); + + EXPECT_EQ(mappedName.endsWith(nullptr), false); + EXPECT_EQ(mappedName.endsWith("TEST"), false); + EXPECT_EQ(mappedName.endsWith("FIX"), true); +} + + +TEST(MappedName, startsWith) +{ + Data::MappedName mappedName = Data::MappedName("TEST"); + EXPECT_EQ(mappedName.startsWith(QByteArray()), true); + EXPECT_EQ(mappedName.startsWith("TEST"), true); + EXPECT_EQ(mappedName.startsWith("WASD"), false); + + EXPECT_EQ(mappedName.startsWith(nullptr), false); + EXPECT_EQ(mappedName.startsWith("TEST"), true); + EXPECT_EQ(mappedName.startsWith(std::string("TEST")), true); +} + +//TODO test hash function // clang-format on \ No newline at end of file