diff --git a/Program Files/Microsoft Visual Studio/18/Community/VC/Tools/MSVC/14.51.36231/include/__msvc_ostream.hpp b/Program Files/Microsoft Visual Studio/18/Community/VC/Tools/MSVC/14.51.36231/include/__msvc_ostream.hpp deleted file mode 100644 index e69de29..0000000 diff --git a/Program Files/Microsoft Visual Studio/18/Community/VC/Tools/MSVC/14.51.36231/include/__msvc_string_view.hpp b/Program Files/Microsoft Visual Studio/18/Community/VC/Tools/MSVC/14.51.36231/include/__msvc_string_view.hpp deleted file mode 100644 index e69de29..0000000 diff --git a/feladat5/UnitTest1/UnitTest1.cpp b/feladat5/UnitTest1/UnitTest1.cpp index 11d5b30..4ce6dcc 100644 --- a/feladat5/UnitTest1/UnitTest1.cpp +++ b/feladat5/UnitTest1/UnitTest1.cpp @@ -1,4 +1,4 @@ -// Tóth Dániel Mátyás | IFPQYY | v2 +// Tóth Dániel Mátyás | IFPQYY | v3 #include "pch.h" #include "CppUnitTest.h" #include @@ -108,7 +108,14 @@ namespace UnitTest1 } } catch (const CMyStringException& e) { - Assert::AreEqual(CMyStringException::ErrInvalidChar, e.what()); + if (repeatchargs[i] == '\0') + { + Assert::AreEqual(CMyStringException::ErrInvalidChar, e.what()); + } + else + { + Assert::AreEqual(CMyStringException::ErrCount, e.what()); + } } catch (...) { @@ -226,8 +233,14 @@ namespace UnitTest1 Assert::IsTrue(false); } } - CMyString str1 = CMyString("test"); - CMyString str2 = str1; + CMyString str1 = CMyString("narancsnarancsnarancs"); + CMyString str2 = CMyString("eper"); + const char* cptr = str1.c_str(); + str1 = str2; + str1.shrink_to_fit(); + Assert::AreEqual((size_t)4, str1.size()); + Assert::AreEqual((size_t)5, str1.capacity()); + Assert::AreNotEqual(cptr, str1.c_str()); } TEST_METHOD(GetAtTests) { @@ -452,6 +465,7 @@ namespace UnitTest1 Assert::IsTrue(false); } } + } TEST_METHOD(ReverseTests) { CMyString str[]{ @@ -495,6 +509,7 @@ namespace UnitTest1 CMyString("test"), CMyString("banan"), CMyString("banan"), + CMyString("alma"), }; const char* text[] = { "", @@ -509,6 +524,7 @@ namespace UnitTest1 "a", "narancs", "narancs", + "dio", }; size_t extraargs[][2] = { { 0, ~0 }, @@ -523,6 +539,7 @@ namespace UnitTest1 { 0, ~0 }, { 0, ~0 }, { 2, 2 }, + { 3, 1 }, }; int sizes[][2] = { { 0, 1 }, @@ -537,6 +554,7 @@ namespace UnitTest1 { 5, 12 }, { 12, 26 }, { 7, 16 }, + { 4, 5 }, }; const char* expected[] = { "", @@ -551,6 +569,7 @@ namespace UnitTest1 "testa", "banannarancs", "bananra", + "alma", }; int testcount = sizeof(text) / sizeof(char*); for (size_t i = 0; i < testcount; i++) diff --git a/feladat5/feladat5/CMyString.cpp b/feladat5/feladat5/CMyString.cpp index 26ec905..92aa8e0 100644 --- a/feladat5/feladat5/CMyString.cpp +++ b/feladat5/feladat5/CMyString.cpp @@ -1,4 +1,4 @@ -// Tóth Dániel Mátyás | IFPQYY | v2 +// Tóth Dániel Mátyás | IFPQYY | v3 #include "CMyString.h" #include "CMyStringException.h" #include @@ -36,6 +36,14 @@ static void MakeEmptyStr(size_t* datalngth, size_t* alloclngth, char** ptr) { (*ptr)[0] = '\0'; } +static void reserveNoCheck(size_t* alloc, size_t* size, char** data, size_t newsize) { + char* tmp = *data; + *alloc = newsize; + *data = new char[*alloc]; + CopyStr(*data, tmp, *size); + delete tmp; +} + CMyString::CMyString() { MakeEmptyStr(&m_nDataLength, &m_nAllocLength, &m_pchData); } @@ -63,7 +71,7 @@ CMyString::CMyString(char ch, size_t repeat) { } if (repeat == 0) { - MakeEmptyStr(&m_nDataLength, &m_nAllocLength, &m_pchData); + throw CMyStringException(CMyStringException::ErrCount); } else { @@ -136,21 +144,17 @@ void CMyString::reserve(size_t newcapacity) { { return; } - char* tmp = m_pchData; - m_nAllocLength = newcapacity; - m_pchData = new char[m_nAllocLength]; - CopyStr(m_pchData, tmp, m_nDataLength); - delete tmp; + reserveNoCheck(&m_nAllocLength, &m_nDataLength, &m_pchData, newcapacity); } void CMyString::erase(size_t pos, size_t count) { - if (empty()) - { - return; - } if (pos > m_nDataLength) { throw CMyStringException(CMyStringException::ErrOutOfRange); } + if (empty()) + { + return; + } if (pos + count > m_nDataLength) { count = m_nDataLength - pos; @@ -181,8 +185,7 @@ void CMyString::display() const { } } void CMyString::shrink_to_fit() { - m_nAllocLength = m_nDataLength + 1; - this->reserve(m_nAllocLength); + reserveNoCheck(&m_nAllocLength, &m_nDataLength, &m_pchData, m_nDataLength+1); } void CMyString::reverse() { if (!empty()) @@ -206,6 +209,10 @@ void CMyString::append(const char* psz, unsigned offset, unsigned count) { throw CMyStringException(CMyStringException::ErrCount); } size_t len = strLength(psz); + if (offset == len) + { + return; + } if (count == ~0) { count = len - offset; diff --git a/feladat5/feladat5/CMyString.h b/feladat5/feladat5/CMyString.h index 4a793ea..11ceac5 100644 --- a/feladat5/feladat5/CMyString.h +++ b/feladat5/feladat5/CMyString.h @@ -1,4 +1,4 @@ -// Tóth Dániel Mátyás | IFPQYY | v2 +// Tóth Dániel Mátyás | IFPQYY | v3 #pragma once class CMyString { public: diff --git a/feladat5/feladat5/CMyStringException.cpp b/feladat5/feladat5/CMyStringException.cpp index 78630ff..222c3d2 100644 --- a/feladat5/feladat5/CMyStringException.cpp +++ b/feladat5/feladat5/CMyStringException.cpp @@ -1,4 +1,4 @@ -// Tóth Dániel Mátyás | IFPQYY | v2 +// Tóth Dániel Mátyás | IFPQYY | v3 #include "CMyStringException.h" #include "CMyString.h" diff --git a/feladat5/feladat5/CMyStringException.h b/feladat5/feladat5/CMyStringException.h index a3bd759..fcb0761 100644 --- a/feladat5/feladat5/CMyStringException.h +++ b/feladat5/feladat5/CMyStringException.h @@ -1,4 +1,4 @@ -// Tóth Dániel Mátyás | IFPQYY | v2 +// Tóth Dániel Mátyás | IFPQYY | v3 #pragma once #include #include "CMyString.h" diff --git a/feladat5/feladat5/UnitTest1.cpp b/feladat5/feladat5/UnitTest1.cpp new file mode 100644 index 0000000..4ce6dcc --- /dev/null +++ b/feladat5/feladat5/UnitTest1.cpp @@ -0,0 +1,595 @@ +// Tóth Dániel Mátyás | IFPQYY | v3 +#include "pch.h" +#include "CppUnitTest.h" +#include +#include + +using namespace Microsoft::VisualStudio::CppUnitTestFramework; + +namespace UnitTest1 +{ + TEST_CLASS(UnitTest1) + { + public: + TEST_METHOD(EmptyTests) + { + CMyString empty = CMyString(); + Assert::AreEqual(0, (int)empty.size()); + Assert::AreEqual(1, (int)empty.capacity()); + Assert::IsTrue(empty.empty()); + } + + TEST_METHOD(c_strTests) + { + try + { + char* tmp = "txt"; + CMyString str = CMyString((const char*)tmp); + Assert::IsFalse(tmp == str.c_str()); //memory addr + Assert::AreEqual(tmp, str.c_str()); //value + } + catch (...) + { + Assert::IsTrue(false); + } + } + + TEST_METHOD(StringConstructionTests) + { + + //char* constructor + char* pszargs[] = { + {nullptr}, + {""}, + {"test"}, + {"long text aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, + }; + int pszres[] = { + 0, + 0, + 4, + 48, + }; + int testcount = sizeof(pszres) / sizeof(int); + for (size_t i = 0; i < testcount; i++) + { + try + { + CMyString pszctor = CMyString(pszargs[i]); + Assert::AreEqual(pszres[i], (int)pszctor.size()); + Assert::AreEqual((pszres[i]) + 1, (int)pszctor.capacity()); + if (pszargs[i] != nullptr) + { + Assert::AreEqual(pszargs[i], pszctor.c_str()); + } + } + catch (...) + { + Assert::IsTrue(false); + } + } + + //repeat constructor + char repeatchargs[] = { + '\0', + '\0', + 'a', + 'a', + }; + int repeatcntargs[] = { + 0, + 5, + 0, + 5, + }; + int repeatres[] = { + 0, + 0, + 0, + 5, + }; + char* repeattextres[] = { + nullptr, + nullptr, + nullptr, + "aaaaa", + }; + testcount = sizeof(repeatres) / sizeof(int); + for (size_t i = 0; i < testcount; i++) + { + try + { + CMyString repeatctor = CMyString(repeatchargs[i], repeatcntargs[i]); + Assert::AreEqual(repeatres[i], (int)repeatctor.size()); + Assert::AreEqual((repeatres[i]) + 1, (int)repeatctor.capacity()); + if (repeattextres[i] != nullptr) + { + Assert::AreEqual(repeattextres[i], repeatctor.c_str()); + } + } + catch (const CMyStringException& e) { + if (repeatchargs[i] == '\0') + { + Assert::AreEqual(CMyStringException::ErrInvalidChar, e.what()); + } + else + { + Assert::AreEqual(CMyStringException::ErrCount, e.what()); + } + } + catch (...) + { + Assert::IsTrue(false); + } + } + + //copy constructor + CMyString strargs[] = { + CMyString(), + CMyString("test"), + CMyString('a', 10), + CMyString("really long text thats to be cleared"), + }; + strargs[3].clear(); + int strres[] = { + 0, + 4, + 10, + 0, + }; + int allocLengths[] = { + 1, + 5, + 11, + 1, + }; + char* cpytextres[] = { + "", + "test", + "aaaaaaaaaa", + "", + }; + testcount = sizeof(strres) / sizeof(int); + for (size_t i = 0; i < testcount; i++) + { + try + { + CMyString cpy = CMyString(strargs[i]); + CMyString strctor = CMyString(cpy); + Assert::AreEqual(strres[i], (int)strctor.size()); + Assert::AreEqual((allocLengths[i]), (int)strctor.capacity()); + Assert::AreEqual(cpytextres[i], strctor.c_str()); + } + catch (...) + { + Assert::IsTrue(false); + } + } + } + + TEST_METHOD(ClearTests) { + CMyString str[]{ + CMyString(), + CMyString("test"), + CMyString('a', 10), + CMyString(CMyString("to be copied then cleared")), + }; + int allocLengths[] = { + 1, + 5, + 11, + 26, + }; + int testcount = sizeof(allocLengths) / sizeof(int); + for (size_t i = 0; i < testcount; i++) + { + try + { + str[i].clear(); + Assert::IsTrue(str[i].empty()); + Assert::AreEqual(allocLengths[i], (int)str[i].capacity()); + } + catch (...) + { + Assert::IsTrue(false); + } + } + } + TEST_METHOD(EqualOperatorTests) { + CMyString preps[]{ + CMyString(), + CMyString("testtesttest"), + CMyString("testtesttest"), + CMyString("test"), + CMyString("dio"), + }; + CMyString strs[]{ + CMyString("test"), + CMyString("test"), + CMyString("testtesttesttest"), + CMyString("testtesttesttest"), + CMyString("narancs"), + }; + int expected[][2] = { + { 4, 5 }, + { 4, 13 }, + { 16, 17 }, + { 16, 17 }, + { 7, 8 }, + }; + int testcount = sizeof(expected) / (sizeof(int) * 2); + for (size_t i = 0; i < testcount; i++) + { + try + { + CMyString res = preps[i]; + res = strs[i]; + Assert::AreEqual(expected[i][0], (int)res.size()); + Assert::AreEqual(expected[i][1], (int)res.capacity()); + Assert::AreEqual(strs[i].c_str(), res.c_str()); + } + catch (...) + { + Assert::IsTrue(false); + } + } + CMyString str1 = CMyString("narancsnarancsnarancs"); + CMyString str2 = CMyString("eper"); + const char* cptr = str1.c_str(); + str1 = str2; + str1.shrink_to_fit(); + Assert::AreEqual((size_t)4, str1.size()); + Assert::AreEqual((size_t)5, str1.capacity()); + Assert::AreNotEqual(cptr, str1.c_str()); + } + + TEST_METHOD(GetAtTests) { + CMyString str[]{ + CMyString(), + CMyString(), + CMyString("test"), + CMyString("test"), + CMyString("test"), + CMyString('a', 10), + CMyString(CMyString("to be copied then cleared")), + }; + int pos[] = { + 1, + 0, + 4, + -1, + 1, + 9, + 12, + }; + char character[] = { + '\0', + '\0', + '\0', + '\0', //first four are invalid + 'e', + 'a', + ' ', + }; + int testcount = sizeof(pos) / sizeof(int); + for (size_t i = 0; i < testcount; i++) + { + try + { + Assert::AreEqual(character[i], str[i].getat(pos[i])); + } + catch(const CMyStringException& e) + { + if (i < 4) + { + Assert::AreEqual(CMyStringException::ErrOutOfRange, e.what()); + } + else + { + Assert::IsTrue(false); + } + } + catch (...) + { + Assert::IsTrue(false); + } + } + } + TEST_METHOD(SetAtTests) { + CMyString str[]{ + CMyString(), + CMyString("test"), + CMyString("test"), + CMyString('a', 10), + }; + int pos[] = { + 0, + 4, + -1, + 3, + }; + char* text[] = { + '\0', + '\0', + '\0', //first three are invalid + "aaataaaaaa", + }; + int testcount = sizeof(pos) / sizeof(int); + for (size_t i = 0; i < testcount; i++) + { + try + { + str[i].setat(pos[i], 't'); + Assert::AreEqual(text[i], str[i].c_str()); + } + catch (const CMyStringException& e) + { + if (i < 3) + { + Assert::AreEqual(CMyStringException::ErrOutOfRange, e.what()); + } + else + { + Assert::IsTrue(false); + } + } + catch (...) + { + Assert::IsTrue(false); + } + } + } + + TEST_METHOD(ReserveTests) { + CMyString str = CMyString("test"); + int allocs[] = { + 1, + 5, + 10, + 33, + }; + int expected[] = { + 5, + 5, + 10, + 33, + }; + + int testcount = sizeof(allocs) / sizeof(int); + for (size_t i = 0; i < testcount; i++) + { + try + { + const char* ptr = str.c_str(); + str.reserve(allocs[i]); + Assert::AreEqual(expected[i], (int)str.capacity()); + if (i < 2) + { + Assert::AreEqual(ptr, str.c_str()); + } + } + catch (...) + { + Assert::IsTrue(false); + } + } + } + + TEST_METHOD(EraseTests) { + CMyString str[]{ + CMyString(), + CMyString("test"), + CMyString("test"), + CMyString("test"), + CMyString("test"), + CMyString('a', 10), + CMyString("alma"), + CMyString("test"), + }; + int pos[] = { + 0, + 4, + -1, + 3, + 3, + 3, + 4, + 0, + }; + int cnt[] = { + 1, + 1, + 1, + 0, + 1, + 1, + 100, + 0, + }; + char* text[] = { + "", + "test", + NULL, + "test", + "tes", + "aaaaaaaaa", + "alma", + "test", + }; + int testcount = sizeof(pos) / sizeof(int); + for (size_t i = 0; i < testcount; i++) + { + try + { + str[i].erase(pos[i], cnt[i]); + Assert::AreEqual(text[i], str[i].c_str()); + } + catch (const CMyStringException& e) + { + Assert::AreEqual(CMyStringException::ErrOutOfRange, e.what()); + } + catch (...) + { + Assert::IsTrue(false); + } + } + } + TEST_METHOD(ShrinkToFitTests) { + CMyString str[]{ + CMyString("test"), + CMyString("test"), + CMyString(), + }; + int eraseargs[][2] = { + { 0, 0 }, + { 0, 4 }, + { 0, 0 }, + }; + int res[][2] = { + { 4, 5 }, + { 0, 1 }, + { 0, 1 }, + }; + int testcount = sizeof(res) / sizeof(int) / 2; + for (size_t i = 0; i < testcount; i++) + { + try + { + str[i].erase(eraseargs[i][0], eraseargs[i][1]); + str[i].shrink_to_fit(); + Assert::AreEqual(res[i][0], (int)str[i].size()); + Assert::AreEqual(res[i][1], (int)str[i].capacity()); + } + catch (...) + { + Assert::IsTrue(false); + } + } + + } + TEST_METHOD(ReverseTests) { + CMyString str[]{ + CMyString(), + CMyString("bal"), + CMyString("test"), + CMyString("disestablishmentarianism"), + }; + char* text[] = { + "", + "lab", + "tset", + "msinairatnemhsilbatsesid" + }; + int testcount = sizeof(text) / sizeof(char*); + for (size_t i = 0; i < testcount; i++) + { + try + { + str[i].reverse(); + Assert::AreEqual(text[i], str[i].c_str()); + } + catch (...) + { + Assert::IsTrue(false); + } + } + } + + TEST_METHOD(AppendTests) { + CMyString str[]{ + CMyString(), + CMyString(), + CMyString("test"), + CMyString("test"), + CMyString("test"), + CMyString("test"), + CMyString("test"), + CMyString("test"), + CMyString("test"), + CMyString("test"), + CMyString("banan"), + CMyString("banan"), + CMyString("alma"), + }; + const char* text[] = { + "", + nullptr, + str[2].c_str(), + "test", + "test", + "test", + "test", + "", + "test", + "a", + "narancs", + "narancs", + "dio", + }; + size_t extraargs[][2] = { + { 0, ~0 }, + { 0, ~0 }, + { 0, ~0 }, + { 0, ~0 }, + { 5, ~0 }, + { 0, 5 }, + { 2, 3 }, + { 1, 0 }, + { 4, ~0 }, + { 0, ~0 }, + { 0, ~0 }, + { 2, 2 }, + { 3, 1 }, + }; + int sizes[][2] = { + { 0, 1 }, + { 0, 1 }, + { 4, 5 }, + { 8, 18 }, + { 4, 5 }, + { 4, 5 }, + { 4, 5 }, + { 4, 5 }, + { 4, 5 }, + { 5, 12 }, + { 12, 26 }, + { 7, 16 }, + { 4, 5 }, + }; + const char* expected[] = { + "", + "", + "test", + "testtest", + CMyStringException::ErrOutOfRange, + CMyStringException::ErrOutOfRange, + CMyStringException::ErrOutOfRange, + CMyStringException::ErrCount, + "test", + "testa", + "banannarancs", + "bananra", + "alma", + }; + int testcount = sizeof(text) / sizeof(char*); + for (size_t i = 0; i < testcount; i++) + { + try + { + str[i].append(text[i], extraargs[i][0], extraargs[i][1]); + Assert::AreEqual(expected[i], str[i].c_str()); + Assert::AreEqual(sizes[i][0], (int)str[i].size()); + Assert::AreEqual(sizes[i][1], (int)str[i].capacity()); + } + catch (const CMyStringException& e) + { + Assert::AreEqual(expected[i], e.what()); + } + catch (...) + { + Assert::IsTrue(false); + } + } + } + }; +} diff --git a/feladat5/feladat5/main.cpp b/feladat5/feladat5/main.cpp index 3399460..f68ceaa 100644 --- a/feladat5/feladat5/main.cpp +++ b/feladat5/feladat5/main.cpp @@ -1,4 +1,4 @@ -// Tóth Dániel Mátyás | IFPQYY | v2 +// Tóth Dániel Mátyás | IFPQYY | v3 #include "CMyString.h" int main() {