Merge branch 'main' of https://forgejo.damimani-alex.org/damimani/2026-27-cpp-homework
This commit is contained in:
commit
a8d170c45e
9 changed files with 1248 additions and 41 deletions
4
.github/copilot-instructions.md
vendored
Normal file
4
.github/copilot-instructions.md
vendored
Normal file
|
|
@ -0,0 +1,4 @@
|
||||||
|
# Copilot Instructions
|
||||||
|
|
||||||
|
## Project Guidelines
|
||||||
|
- The user requires CMyString.h to remain unchanged when fixing the implementation.
|
||||||
|
|
@ -1,4 +1,5 @@
|
||||||
// Tóth Dániel Mátyás | IFPQYY | v3
|
// Tóth Dániel Mátyás | IFPQYY | v2
|
||||||
|
#define _MYDEBUG
|
||||||
#include "pch.h"
|
#include "pch.h"
|
||||||
#include "CppUnitTest.h"
|
#include "CppUnitTest.h"
|
||||||
#include <CMyString.h>
|
#include <CMyString.h>
|
||||||
|
|
@ -385,6 +386,7 @@ namespace UnitTest1
|
||||||
CMyString('a', 10),
|
CMyString('a', 10),
|
||||||
CMyString("alma"),
|
CMyString("alma"),
|
||||||
CMyString("test"),
|
CMyString("test"),
|
||||||
|
CMyString("alma"),
|
||||||
};
|
};
|
||||||
int pos[] = {
|
int pos[] = {
|
||||||
0,
|
0,
|
||||||
|
|
@ -395,6 +397,7 @@ namespace UnitTest1
|
||||||
3,
|
3,
|
||||||
4,
|
4,
|
||||||
0,
|
0,
|
||||||
|
1,
|
||||||
};
|
};
|
||||||
int cnt[] = {
|
int cnt[] = {
|
||||||
1,
|
1,
|
||||||
|
|
@ -405,6 +408,7 @@ namespace UnitTest1
|
||||||
1,
|
1,
|
||||||
100,
|
100,
|
||||||
0,
|
0,
|
||||||
|
-1,
|
||||||
};
|
};
|
||||||
char* text[] = {
|
char* text[] = {
|
||||||
"",
|
"",
|
||||||
|
|
@ -415,6 +419,7 @@ namespace UnitTest1
|
||||||
"aaaaaaaaa",
|
"aaaaaaaaa",
|
||||||
"alma",
|
"alma",
|
||||||
"test",
|
"test",
|
||||||
|
"a"
|
||||||
};
|
};
|
||||||
int testcount = sizeof(pos) / sizeof(int);
|
int testcount = sizeof(pos) / sizeof(int);
|
||||||
for (size_t i = 0; i < testcount; i++)
|
for (size_t i = 0; i < testcount; i++)
|
||||||
|
|
@ -505,11 +510,12 @@ namespace UnitTest1
|
||||||
CMyString("test"),
|
CMyString("test"),
|
||||||
CMyString("test"),
|
CMyString("test"),
|
||||||
CMyString("test"),
|
CMyString("test"),
|
||||||
CMyString("test"),
|
CMyString("test"),
|
||||||
CMyString("test"),
|
CMyString("test"),
|
||||||
CMyString("banan"),
|
CMyString("banan"),
|
||||||
CMyString("banan"),
|
CMyString("banan"),
|
||||||
CMyString("alma"),
|
CMyString("alma"),
|
||||||
|
CMyString("ABCDE"),
|
||||||
};
|
};
|
||||||
const char* text[] = {
|
const char* text[] = {
|
||||||
"",
|
"",
|
||||||
|
|
@ -525,6 +531,7 @@ namespace UnitTest1
|
||||||
"narancs",
|
"narancs",
|
||||||
"narancs",
|
"narancs",
|
||||||
"dio",
|
"dio",
|
||||||
|
"BCDE",
|
||||||
};
|
};
|
||||||
size_t extraargs[][2] = {
|
size_t extraargs[][2] = {
|
||||||
{ 0, ~0 },
|
{ 0, ~0 },
|
||||||
|
|
@ -540,6 +547,7 @@ namespace UnitTest1
|
||||||
{ 0, ~0 },
|
{ 0, ~0 },
|
||||||
{ 2, 2 },
|
{ 2, 2 },
|
||||||
{ 3, 1 },
|
{ 3, 1 },
|
||||||
|
{ 0, 2 },
|
||||||
};
|
};
|
||||||
int sizes[][2] = {
|
int sizes[][2] = {
|
||||||
{ 0, 1 },
|
{ 0, 1 },
|
||||||
|
|
@ -555,6 +563,7 @@ namespace UnitTest1
|
||||||
{ 12, 26 },
|
{ 12, 26 },
|
||||||
{ 7, 16 },
|
{ 7, 16 },
|
||||||
{ 4, 5 },
|
{ 4, 5 },
|
||||||
|
{ 7, 16 },
|
||||||
};
|
};
|
||||||
const char* expected[] = {
|
const char* expected[] = {
|
||||||
"",
|
"",
|
||||||
|
|
@ -570,6 +579,7 @@ namespace UnitTest1
|
||||||
"banannarancs",
|
"banannarancs",
|
||||||
"bananra",
|
"bananra",
|
||||||
"alma",
|
"alma",
|
||||||
|
"ABCDEBC",
|
||||||
};
|
};
|
||||||
int testcount = sizeof(text) / sizeof(char*);
|
int testcount = sizeof(text) / sizeof(char*);
|
||||||
for (size_t i = 0; i < testcount; i++)
|
for (size_t i = 0; i < testcount; i++)
|
||||||
|
|
@ -591,5 +601,466 @@ namespace UnitTest1
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
TEST_METHOD(EqualsOperatorTests) {
|
||||||
|
CMyString a = CMyString("kutya");
|
||||||
|
CMyString b = CMyString("kutya");
|
||||||
|
CMyString c = CMyString("cica");
|
||||||
|
CMyString d;
|
||||||
|
CMyString e = CMyString("cicajuice");
|
||||||
|
Assert::IsTrue(a == b);
|
||||||
|
Assert::IsFalse(a == c);
|
||||||
|
Assert::IsFalse(a == d);
|
||||||
|
Assert::IsFalse(a == e);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_METHOD(IndexCheckTests) {
|
||||||
|
CMyString str[]{
|
||||||
|
CMyString(),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
};
|
||||||
|
size_t indexes[] = {
|
||||||
|
0,
|
||||||
|
0,
|
||||||
|
4,
|
||||||
|
3,
|
||||||
|
};
|
||||||
|
char expected[] = {
|
||||||
|
'\0', //will mark not valid characters with null
|
||||||
|
't',
|
||||||
|
'\0',
|
||||||
|
't',
|
||||||
|
};
|
||||||
|
size_t testcount = sizeof(expected) / sizeof(char);
|
||||||
|
for (size_t i = 0; i < testcount; i++)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
Assert::AreEqual(expected[i], str[i][indexes[i]]);
|
||||||
|
}
|
||||||
|
catch (const CMyStringException& e)
|
||||||
|
{
|
||||||
|
if (expected[i] == '\0')
|
||||||
|
{
|
||||||
|
Assert::AreEqual(CMyStringException::ErrOutOfRange, e.what());
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
Assert::IsTrue(false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (...)
|
||||||
|
{
|
||||||
|
Assert::IsTrue(false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_METHOD(ConstCharCastingTest) {
|
||||||
|
CMyString str = CMyString("test");
|
||||||
|
Assert::AreEqual(str.c_str(), (const char*)str);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_METHOD(MoveOperatorTests) {
|
||||||
|
CMyString a = CMyString();
|
||||||
|
CMyString b = CMyString("test");
|
||||||
|
a = move(b);
|
||||||
|
|
||||||
|
Assert::AreEqual("test", (const char*)a);
|
||||||
|
Assert::IsTrue(b.empty());
|
||||||
|
|
||||||
|
CMyString c = CMyString(move(a));
|
||||||
|
Assert::AreEqual("test", (const char*)c);
|
||||||
|
Assert::IsTrue(a.empty());
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_METHOD(AddStringOperatorTests) {
|
||||||
|
CMyString strbase[]{
|
||||||
|
CMyString(),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("banan"),
|
||||||
|
};
|
||||||
|
const char* text[] = {
|
||||||
|
"",
|
||||||
|
"test",
|
||||||
|
"a",
|
||||||
|
"narancs",
|
||||||
|
};
|
||||||
|
size_t extraargs[][2] = {
|
||||||
|
{ 0, ~0 },
|
||||||
|
{ 0, ~0 },
|
||||||
|
{ 0, ~0 },
|
||||||
|
{ 0, ~0 },
|
||||||
|
};
|
||||||
|
int sizes[][2] = {
|
||||||
|
{ 0, 1 },
|
||||||
|
{ 8, 18 },
|
||||||
|
{ 5, 12 },
|
||||||
|
{ 12, 26 },
|
||||||
|
};
|
||||||
|
const char* expected[] = {
|
||||||
|
"",
|
||||||
|
"testtest",
|
||||||
|
"testa",
|
||||||
|
"banannarancs",
|
||||||
|
};
|
||||||
|
int testcount = sizeof(expected) / sizeof(char*);
|
||||||
|
for (size_t i = 0; i < testcount; i++)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
CMyString res;
|
||||||
|
res = move(strbase[i] + text[i]);
|
||||||
|
Assert::AreEqual(expected[i], res.c_str());
|
||||||
|
Assert::AreEqual(sizes[i][0], (int)res.size());
|
||||||
|
Assert::AreEqual(sizes[i][1], (int)res.capacity());
|
||||||
|
|
||||||
|
CMyString stradd = CMyString(text[i]);
|
||||||
|
res = CMyString(move(strbase[i] + stradd));
|
||||||
|
Assert::AreEqual(expected[i], res.c_str());
|
||||||
|
Assert::AreEqual(sizes[i][0], (int)res.size());
|
||||||
|
Assert::AreEqual(sizes[i][1], (int)res.capacity());
|
||||||
|
|
||||||
|
strbase[i] += stradd;
|
||||||
|
Assert::AreEqual(expected[i], strbase[i].c_str());
|
||||||
|
Assert::AreEqual(sizes[i][0], (int)strbase[i].size());
|
||||||
|
Assert::AreEqual(sizes[i][1], (int)strbase[i].capacity());
|
||||||
|
}
|
||||||
|
catch (const CMyStringException& e)
|
||||||
|
{
|
||||||
|
Assert::AreEqual(expected[i], e.what());
|
||||||
|
}
|
||||||
|
catch (...)
|
||||||
|
{
|
||||||
|
Assert::IsTrue(false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
TEST_METHOD(SubstringTests) {
|
||||||
|
CMyString str[] = {
|
||||||
|
CMyString(),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("greek"),
|
||||||
|
};
|
||||||
|
size_t args[][2] = {
|
||||||
|
{ 0, ~0 },
|
||||||
|
{ 0, ~0 },
|
||||||
|
{ 2, ~0 },
|
||||||
|
{ 4, ~0 },
|
||||||
|
{ 5, ~0 },
|
||||||
|
{ 0, 1 },
|
||||||
|
{ 1, 1 },
|
||||||
|
{ 1, 999 },
|
||||||
|
{ 1, 0 },
|
||||||
|
{ 2, 2 },
|
||||||
|
};
|
||||||
|
char* expected[] = {
|
||||||
|
"",
|
||||||
|
"test",
|
||||||
|
"st",
|
||||||
|
"",
|
||||||
|
nullptr,
|
||||||
|
"t",
|
||||||
|
"e",
|
||||||
|
"est",
|
||||||
|
"",
|
||||||
|
"ee"
|
||||||
|
};
|
||||||
|
int sizes[] = {
|
||||||
|
0,
|
||||||
|
4,
|
||||||
|
2,
|
||||||
|
0,
|
||||||
|
0,
|
||||||
|
1,
|
||||||
|
1,
|
||||||
|
3,
|
||||||
|
0,
|
||||||
|
2,
|
||||||
|
};
|
||||||
|
size_t testcount = sizeof(expected) / sizeof(char*);
|
||||||
|
for (size_t i = 0; i < testcount; i++)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
CMyString res = str[i].substring(args[i][0], args[i][1]);
|
||||||
|
Assert::AreEqual(expected[i], res.c_str());
|
||||||
|
Assert::AreEqual(sizes[i], (int)res.size());
|
||||||
|
Assert::AreEqual(sizes[i] +1, (int)res.capacity());
|
||||||
|
}
|
||||||
|
catch (const CMyStringException& e)
|
||||||
|
{
|
||||||
|
if (expected[i] == nullptr)
|
||||||
|
{
|
||||||
|
Assert::AreEqual(CMyStringException::ErrOutOfRange, e.what());
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
Assert::IsTrue(false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (...)
|
||||||
|
{
|
||||||
|
Assert::IsTrue(false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_METHOD(SwapTest) {
|
||||||
|
CMyString a = CMyString("contentA");
|
||||||
|
CMyString b = CMyString("contentB");
|
||||||
|
a.swap(b);
|
||||||
|
Assert::AreEqual("contentB", (const char*)a);
|
||||||
|
Assert::AreEqual("contentA", (const char*)b);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_METHOD(FindTests) {
|
||||||
|
CMyString str[] = {
|
||||||
|
CMyString(),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("KORTEALMAEPER"),
|
||||||
|
CMyString("KORTEALMAEPER"),
|
||||||
|
CMyString("KORTEALMAEPER"),
|
||||||
|
};
|
||||||
|
char* find[] = {
|
||||||
|
"",
|
||||||
|
"",
|
||||||
|
nullptr,
|
||||||
|
"h",
|
||||||
|
"e",
|
||||||
|
"test",
|
||||||
|
"testt",
|
||||||
|
"est",
|
||||||
|
"kORTE",
|
||||||
|
"ALMa",
|
||||||
|
"EPEr",
|
||||||
|
};
|
||||||
|
int expected[] = {
|
||||||
|
-1,
|
||||||
|
-1,
|
||||||
|
-1,
|
||||||
|
-1,
|
||||||
|
1,
|
||||||
|
0,
|
||||||
|
-1,
|
||||||
|
1,
|
||||||
|
-1,
|
||||||
|
-1,
|
||||||
|
-1,
|
||||||
|
};
|
||||||
|
size_t testcount = sizeof(expected) / sizeof(int);
|
||||||
|
for (size_t i = 0; i < testcount; i++)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
Assert::AreEqual(expected[i], str[i].find(find[i]));
|
||||||
|
}
|
||||||
|
catch (...)
|
||||||
|
{
|
||||||
|
Assert::IsTrue(false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
TEST_METHOD(InsertTests) {
|
||||||
|
CMyString str[] = {
|
||||||
|
CMyString(),
|
||||||
|
CMyString(),
|
||||||
|
CMyString("ALMA"),
|
||||||
|
CMyString("AB"),
|
||||||
|
CMyString("ALMA"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
};
|
||||||
|
const char* inserttext[] = {
|
||||||
|
"",
|
||||||
|
"",
|
||||||
|
"XY",
|
||||||
|
str[3].c_str(),
|
||||||
|
"X",
|
||||||
|
"test",
|
||||||
|
nullptr,
|
||||||
|
};
|
||||||
|
int insertindex[] = {
|
||||||
|
0,
|
||||||
|
1,
|
||||||
|
2,
|
||||||
|
1,
|
||||||
|
5,
|
||||||
|
4,
|
||||||
|
4,
|
||||||
|
};
|
||||||
|
char* expected[] = {
|
||||||
|
"",
|
||||||
|
nullptr,
|
||||||
|
"ALXYMA",
|
||||||
|
"AABB",
|
||||||
|
nullptr,
|
||||||
|
"testtest",
|
||||||
|
"test",
|
||||||
|
};
|
||||||
|
int sizes[][2] = {
|
||||||
|
{ 0, 1 },
|
||||||
|
{ 0, 1 },
|
||||||
|
{ 6, 14 },
|
||||||
|
{ 4, 10 },
|
||||||
|
{ 4, 5 },
|
||||||
|
{ 8, 18 },
|
||||||
|
{ 4, 5 },
|
||||||
|
};
|
||||||
|
size_t testcount = sizeof(expected) / sizeof(char*);
|
||||||
|
for (size_t i = 0; i < testcount; i++)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
str[i].insert(insertindex[i], inserttext[i]);
|
||||||
|
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)
|
||||||
|
{
|
||||||
|
if (expected[i] == nullptr)
|
||||||
|
{
|
||||||
|
Assert::AreEqual(CMyStringException::ErrOutOfRange, e.what());
|
||||||
|
Assert::AreEqual(sizes[i][0], (int)str[i].size());
|
||||||
|
Assert::AreEqual(sizes[i][1], (int)str[i].capacity());
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
Assert::IsTrue(false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (...)
|
||||||
|
{
|
||||||
|
Assert::IsTrue(false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_METHOD(ReplaceTests) {
|
||||||
|
CMyString str[] = {
|
||||||
|
CMyString(),
|
||||||
|
CMyString(),
|
||||||
|
CMyString("ABCDEFG"),
|
||||||
|
CMyString("ABCDEFG"),
|
||||||
|
CMyString("ABCDEFG"),
|
||||||
|
CMyString("ABCDEFG"),
|
||||||
|
};
|
||||||
|
const char* inserttext[] = {
|
||||||
|
"",
|
||||||
|
"",
|
||||||
|
"X",
|
||||||
|
"XYZ123",
|
||||||
|
nullptr,
|
||||||
|
""
|
||||||
|
};
|
||||||
|
int insertindex[] = {
|
||||||
|
0,
|
||||||
|
1,
|
||||||
|
2,
|
||||||
|
2,
|
||||||
|
2,
|
||||||
|
0,
|
||||||
|
};
|
||||||
|
int count[] = {
|
||||||
|
0,
|
||||||
|
0,
|
||||||
|
3,
|
||||||
|
3,
|
||||||
|
3,
|
||||||
|
0,
|
||||||
|
};
|
||||||
|
char* expected[] = {
|
||||||
|
"",
|
||||||
|
nullptr,
|
||||||
|
"ABXFG",
|
||||||
|
"ABXYZ123FG",
|
||||||
|
"ABFG",
|
||||||
|
"ABCDEFG",
|
||||||
|
};
|
||||||
|
int sizes[][2] = {
|
||||||
|
{ 0, 1 },
|
||||||
|
{ 0, 1 },
|
||||||
|
{ 5, 8 },
|
||||||
|
{ 10, 22 },
|
||||||
|
{ 4, 8 },
|
||||||
|
{ 7, 8 },
|
||||||
|
};
|
||||||
|
size_t testcount = sizeof(expected) / sizeof(char*);
|
||||||
|
for (size_t i = 0; i < testcount; i++)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
str[i].replace(insertindex[i], count[i], inserttext[i]);
|
||||||
|
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)
|
||||||
|
{
|
||||||
|
if (expected[i] == nullptr)
|
||||||
|
{
|
||||||
|
Assert::AreEqual(CMyStringException::ErrOutOfRange, e.what());
|
||||||
|
Assert::AreEqual(sizes[i][0], (int)str[i].size());
|
||||||
|
Assert::AreEqual(sizes[i][1], (int)str[i].capacity());
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
Assert::IsTrue(false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (...)
|
||||||
|
{
|
||||||
|
Assert::IsTrue(false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_METHOD(SpecificTests) {
|
||||||
|
CMyString s = CMyString("ABCDE");
|
||||||
|
const char* const belsoForras = s.c_str() + 1;
|
||||||
|
s.append(belsoForras, 0, 2);
|
||||||
|
Assert::AreEqual("ABCDEBC", s.c_str());
|
||||||
|
Assert::AreEqual((size_t)7, s.size());
|
||||||
|
Assert::AreEqual((size_t)16, s.capacity());
|
||||||
|
|
||||||
|
CMyString g = CMyString("ALMA");
|
||||||
|
g.reserve(12);
|
||||||
|
Assert::AreEqual((size_t)4, g.size());
|
||||||
|
Assert::AreEqual((size_t)12, g.capacity());
|
||||||
|
const char* p = g.c_str();
|
||||||
|
g.insert(2, "XY");
|
||||||
|
Assert::AreEqual("ALXYMA", g.c_str());
|
||||||
|
Assert::AreEqual((size_t)6, g.size());
|
||||||
|
Assert::AreEqual((size_t)12, g.capacity());
|
||||||
|
Assert::IsTrue(p == g.c_str());
|
||||||
|
|
||||||
|
CMyString h = CMyString("ABCDEFG");
|
||||||
|
const char* oldaddr = h.c_str();
|
||||||
|
h.replace(2, 3, "X");
|
||||||
|
Assert::AreEqual("ABXFG", h.c_str());
|
||||||
|
Assert::AreEqual((size_t)5, h.size());
|
||||||
|
Assert::AreEqual((size_t)8, h.capacity());
|
||||||
|
Assert::IsTrue(oldaddr == h.c_str());
|
||||||
|
Assert::AreEqual('\0', h.c_str()[h.size()]);
|
||||||
|
}
|
||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -1,4 +1,4 @@
|
||||||
// Tóth Dániel Mátyás | IFPQYY | v3
|
// Tóth Dániel Mátyás | IFPQYY | v2
|
||||||
#include "CMyString.h"
|
#include "CMyString.h"
|
||||||
#include "CMyStringException.h"
|
#include "CMyStringException.h"
|
||||||
#include <iostream>
|
#include <iostream>
|
||||||
|
|
@ -41,11 +41,44 @@ static void reserveNoCheck(size_t* alloc, size_t* size, char** data, size_t news
|
||||||
*alloc = newsize;
|
*alloc = newsize;
|
||||||
*data = new char[*alloc];
|
*data = new char[*alloc];
|
||||||
CopyStr(*data, tmp, *size);
|
CopyStr(*data, tmp, *size);
|
||||||
delete tmp;
|
delete[] tmp;
|
||||||
|
}
|
||||||
|
static void insertStrAtIndex(const char* src, int pos, int delcnt, size_t* alloc, size_t* size, char** data) {
|
||||||
|
size_t sourceLength = strLength(src);
|
||||||
|
size_t oldSize = *size;
|
||||||
|
size_t newSize = oldSize - delcnt + sourceLength;
|
||||||
|
size_t newCapacity = (*alloc > newSize) ? *alloc : (newSize + 1) * 2;
|
||||||
|
char* cpy = nullptr;
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
cpy = new char[newCapacity];
|
||||||
|
CopyStr(cpy, *data, pos);
|
||||||
|
CopyStr(cpy + pos, src, sourceLength);
|
||||||
|
CopyStr(cpy + pos + sourceLength, *data + pos + delcnt, oldSize - pos - delcnt);
|
||||||
|
|
||||||
|
if (newSize+1 > *alloc)
|
||||||
|
{
|
||||||
|
reserveNoCheck(alloc, size, data, newCapacity);
|
||||||
|
}
|
||||||
|
CopyStr(*data, cpy, newSize);
|
||||||
|
delete[] cpy;
|
||||||
|
*size = newSize;
|
||||||
|
*alloc = newCapacity;
|
||||||
|
}
|
||||||
|
catch (...)
|
||||||
|
{
|
||||||
|
delete[] cpy;
|
||||||
|
throw;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
CMyString::CMyString() {
|
CMyString::CMyString() {
|
||||||
MakeEmptyStr(&m_nDataLength, &m_nAllocLength, &m_pchData);
|
MakeEmptyStr(&m_nDataLength, &m_nAllocLength, &m_pchData);
|
||||||
|
#ifdef _MYDEBUG
|
||||||
|
m_iCounter++;
|
||||||
|
#endif // _MYDEBUG
|
||||||
|
|
||||||
}
|
}
|
||||||
CMyString::CMyString(const char* psz) {
|
CMyString::CMyString(const char* psz) {
|
||||||
if (psz == nullptr)
|
if (psz == nullptr)
|
||||||
|
|
@ -63,6 +96,9 @@ CMyString::CMyString(const char* psz) {
|
||||||
m_pchData = new char[m_nAllocLength];
|
m_pchData = new char[m_nAllocLength];
|
||||||
CopyStr(m_pchData, psz, m_nDataLength);
|
CopyStr(m_pchData, psz, m_nDataLength);
|
||||||
}
|
}
|
||||||
|
#ifdef _MYDEBUG
|
||||||
|
m_iCounter++;
|
||||||
|
#endif // _MYDEBUG
|
||||||
}
|
}
|
||||||
CMyString::CMyString(char ch, size_t repeat) {
|
CMyString::CMyString(char ch, size_t repeat) {
|
||||||
if (ch == '\0')
|
if (ch == '\0')
|
||||||
|
|
@ -73,17 +109,17 @@ CMyString::CMyString(char ch, size_t repeat) {
|
||||||
{
|
{
|
||||||
throw CMyStringException(CMyStringException::ErrCount);
|
throw CMyStringException(CMyStringException::ErrCount);
|
||||||
}
|
}
|
||||||
else
|
m_nDataLength = 0;
|
||||||
|
m_nAllocLength = repeat + 1;
|
||||||
|
m_pchData = new char[m_nAllocLength];
|
||||||
|
while (m_nDataLength < repeat)
|
||||||
{
|
{
|
||||||
m_nDataLength = 0;
|
m_pchData[m_nDataLength++] = ch;
|
||||||
m_nAllocLength = repeat + 1;
|
|
||||||
m_pchData = new char[m_nAllocLength];
|
|
||||||
while (m_nDataLength < repeat)
|
|
||||||
{
|
|
||||||
m_pchData[m_nDataLength++] = ch;
|
|
||||||
}
|
|
||||||
m_pchData[m_nAllocLength-1] = '\0';
|
|
||||||
}
|
}
|
||||||
|
m_pchData[m_nAllocLength-1] = '\0';
|
||||||
|
#ifdef _MYDEBUG
|
||||||
|
m_iCounter++;
|
||||||
|
#endif // _MYDEBUG
|
||||||
}
|
}
|
||||||
CMyString::CMyString(const CMyString& str) {
|
CMyString::CMyString(const CMyString& str) {
|
||||||
if (str.empty())
|
if (str.empty())
|
||||||
|
|
@ -104,9 +140,15 @@ CMyString::CMyString(const CMyString& str) {
|
||||||
}
|
}
|
||||||
m_pchData[m_nDataLength] = '\0';
|
m_pchData[m_nDataLength] = '\0';
|
||||||
}
|
}
|
||||||
|
#ifdef _MYDEBUG
|
||||||
|
m_iCounter++;
|
||||||
|
#endif // _MYDEBUG
|
||||||
}
|
}
|
||||||
CMyString::~CMyString() {
|
CMyString::~CMyString() {
|
||||||
delete m_pchData;
|
delete[] m_pchData;
|
||||||
|
#ifdef _MYDEBUG
|
||||||
|
m_iCounter--;
|
||||||
|
#endif // _MYDEBUG
|
||||||
}
|
}
|
||||||
size_t CMyString::size() const {
|
size_t CMyString::size() const {
|
||||||
return m_nDataLength;
|
return m_nDataLength;
|
||||||
|
|
@ -155,6 +197,10 @@ void CMyString::erase(size_t pos, size_t count) {
|
||||||
{
|
{
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
if (count > m_nDataLength)
|
||||||
|
{
|
||||||
|
count = m_nDataLength;
|
||||||
|
}
|
||||||
if (pos + count > m_nDataLength)
|
if (pos + count > m_nDataLength)
|
||||||
{
|
{
|
||||||
count = m_nDataLength - pos;
|
count = m_nDataLength - pos;
|
||||||
|
|
@ -209,6 +255,8 @@ void CMyString::append(const char* psz, unsigned offset, unsigned count) {
|
||||||
throw CMyStringException(CMyStringException::ErrCount);
|
throw CMyStringException(CMyStringException::ErrCount);
|
||||||
}
|
}
|
||||||
size_t len = strLength(psz);
|
size_t len = strLength(psz);
|
||||||
|
char* cpy = new char[len];
|
||||||
|
CopyStr(cpy, psz, len);
|
||||||
if (offset == len)
|
if (offset == len)
|
||||||
{
|
{
|
||||||
return;
|
return;
|
||||||
|
|
@ -230,7 +278,7 @@ void CMyString::append(const char* psz, unsigned offset, unsigned count) {
|
||||||
size_t j = offset;
|
size_t j = offset;
|
||||||
while (j < range)
|
while (j < range)
|
||||||
{
|
{
|
||||||
m_pchData[i++] = psz[j++];
|
m_pchData[i++] = cpy[j++];
|
||||||
}
|
}
|
||||||
m_nDataLength = i;
|
m_nDataLength = i;
|
||||||
m_pchData[i] = '\0';
|
m_pchData[i] = '\0';
|
||||||
|
|
@ -249,8 +297,205 @@ CMyString& CMyString::operator=(const CMyString& str) {
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
MakeEmptyStr(&m_nDataLength, &m_nAllocLength, &m_pchData);
|
if (!empty())
|
||||||
|
{
|
||||||
|
MakeEmptyStr(&m_nDataLength, &m_nAllocLength, &m_pchData);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
CMyString::CMyString(CMyString&& str){
|
||||||
|
m_nDataLength = str.m_nDataLength;
|
||||||
|
m_nAllocLength = str.m_nAllocLength;
|
||||||
|
m_pchData = str.m_pchData;
|
||||||
|
str.m_nDataLength = 0;
|
||||||
|
str.m_nAllocLength = 1;
|
||||||
|
char* empty = new char[1];
|
||||||
|
empty[0] = '\0';
|
||||||
|
str.m_pchData = empty;
|
||||||
|
}
|
||||||
|
CMyString& CMyString::operator=(CMyString&& str){
|
||||||
|
if (this != &str)
|
||||||
|
{
|
||||||
|
char* empty = new char[1];
|
||||||
|
empty[0] = '\0';
|
||||||
|
delete[] m_pchData;
|
||||||
|
m_nDataLength = str.m_nDataLength;
|
||||||
|
m_nAllocLength = str.m_nAllocLength;
|
||||||
|
m_pchData = str.m_pchData;
|
||||||
|
str.m_nDataLength = 0;
|
||||||
|
str.m_nAllocLength = 1;
|
||||||
|
str.m_pchData = empty;
|
||||||
|
}
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
char& CMyString::operator[](size_t nIndex){
|
||||||
|
if (nIndex >= m_nDataLength)
|
||||||
|
{
|
||||||
|
throw CMyStringException(CMyStringException::ErrOutOfRange);
|
||||||
|
}
|
||||||
|
return m_pchData[nIndex];
|
||||||
|
}
|
||||||
|
bool CMyString::operator==(const CMyString& s1){
|
||||||
|
if (s1.capacity() != capacity())
|
||||||
|
{
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
if (s1.size() != size())
|
||||||
|
{
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
int i = 0;
|
||||||
|
const char* s1chararr = s1.c_str();
|
||||||
|
while (i < size())
|
||||||
|
{
|
||||||
|
if (m_pchData[i] != s1chararr[i])
|
||||||
|
{
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
i++;
|
||||||
|
}
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
CMyString& CMyString::operator+=(const CMyString& str){
|
||||||
|
append(str.c_str());
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
CMyString& CMyString::operator+=(const char* p){
|
||||||
|
append(p);
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
CMyString& CMyString::operator+(const CMyString& str1){
|
||||||
|
static CMyString res;
|
||||||
|
res = *this;
|
||||||
|
res.append(str1.c_str());
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
CMyString::operator const char* (){
|
||||||
|
return m_pchData;
|
||||||
|
}
|
||||||
|
CMyString CMyString::substring(size_t pos, size_t len){
|
||||||
|
if (pos > m_nDataLength)
|
||||||
|
{
|
||||||
|
throw CMyStringException(CMyStringException::ErrOutOfRange);
|
||||||
|
}
|
||||||
|
if (pos == m_nDataLength || len == 0)
|
||||||
|
{
|
||||||
|
return "";
|
||||||
|
}
|
||||||
|
if (len > m_nDataLength)
|
||||||
|
{
|
||||||
|
len = m_nDataLength;
|
||||||
|
}
|
||||||
|
if ((len + pos) > m_nDataLength)
|
||||||
|
{
|
||||||
|
len = m_nDataLength - pos;
|
||||||
|
}
|
||||||
|
char* cpy = new char[len + 1];
|
||||||
|
CopyStr(cpy, c_str() + pos, len);
|
||||||
|
CMyString substr = CMyString(cpy);
|
||||||
|
delete[] cpy;
|
||||||
|
return substr;
|
||||||
|
}
|
||||||
|
void CMyString::swap(CMyString& str1){
|
||||||
|
char* tempData = m_pchData;
|
||||||
|
size_t tempLength = m_nDataLength;
|
||||||
|
size_t tempAllocLength = m_nAllocLength;
|
||||||
|
|
||||||
|
m_pchData = str1.m_pchData;
|
||||||
|
m_nDataLength = str1.m_nDataLength;
|
||||||
|
m_nAllocLength = str1.m_nAllocLength;
|
||||||
|
|
||||||
|
str1.m_pchData = tempData;
|
||||||
|
str1.m_nDataLength = tempLength;
|
||||||
|
str1.m_nAllocLength = tempAllocLength;
|
||||||
|
}
|
||||||
|
int CMyString::find(const char* psz) const{
|
||||||
|
if (psz == nullptr || psz == "")
|
||||||
|
{
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
int pszlen = strLength(psz);
|
||||||
|
if (pszlen > m_nDataLength)
|
||||||
|
{
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
size_t i = 0;
|
||||||
|
size_t j = 0;
|
||||||
|
size_t ret = -1;
|
||||||
|
while (pszlen + i - j <= m_nDataLength && j < pszlen)
|
||||||
|
{
|
||||||
|
if (getat(i) == psz[j])
|
||||||
|
{
|
||||||
|
ret = ret == -1 ? i : ret;
|
||||||
|
j++;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
ret = -1;
|
||||||
|
j = 0;
|
||||||
|
}
|
||||||
|
i++;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
void CMyString::insert(size_t pos, const char* psz){
|
||||||
|
if (pos > m_nDataLength)
|
||||||
|
{
|
||||||
|
throw CMyStringException(CMyStringException::ErrOutOfRange);
|
||||||
|
}
|
||||||
|
if (psz == nullptr || psz == "")
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if (pos == m_nDataLength)
|
||||||
|
{
|
||||||
|
append(psz);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
insertStrAtIndex(psz, pos, 0, &m_nAllocLength, &m_nDataLength, &m_pchData);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
void CMyString::replace(size_t pos, size_t count, const char* psz){
|
||||||
|
if (pos > m_nDataLength)
|
||||||
|
{
|
||||||
|
throw CMyStringException(CMyStringException::ErrOutOfRange);
|
||||||
|
}
|
||||||
|
if (count > m_nDataLength)
|
||||||
|
{
|
||||||
|
count = m_nDataLength;
|
||||||
|
}
|
||||||
|
if ((count + pos) > m_nDataLength)
|
||||||
|
{
|
||||||
|
count = m_nDataLength - pos;
|
||||||
|
}
|
||||||
|
if (psz == nullptr)
|
||||||
|
{
|
||||||
|
psz = "";
|
||||||
|
}
|
||||||
|
if (pos == m_nDataLength)
|
||||||
|
{
|
||||||
|
append(psz);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
insertStrAtIndex(psz, pos, count, &m_nAllocLength, &m_nDataLength, &m_pchData);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
std::ostream& operator<<(std::ostream& os, CMyString& s) {
|
||||||
|
os << s.c_str();
|
||||||
|
return os;
|
||||||
|
}
|
||||||
|
|
||||||
|
#ifdef _MYDEBUG
|
||||||
|
void CMyString::clearobjcount() {
|
||||||
|
m_iCounter = 0;
|
||||||
|
}
|
||||||
|
unsigned CMyString::objcount() {
|
||||||
|
return m_iCounter;
|
||||||
|
}
|
||||||
|
#endif // _MYDEBUG
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,6 @@
|
||||||
// Tóth Dániel Mátyás | IFPQYY | v3
|
// Tóth Dániel Mátyás | IFPQYY | v2
|
||||||
#pragma once
|
#pragma once
|
||||||
|
#include <ostream>
|
||||||
class CMyString {
|
class CMyString {
|
||||||
public:
|
public:
|
||||||
CMyString();
|
CMyString();
|
||||||
|
|
@ -21,8 +22,30 @@ public:
|
||||||
void reverse();
|
void reverse();
|
||||||
void append(const char* psz, unsigned offset = 0, unsigned count = ~0);
|
void append(const char* psz, unsigned offset = 0, unsigned count = ~0);
|
||||||
CMyString& operator=(const CMyString& str);
|
CMyString& operator=(const CMyString& str);
|
||||||
|
CMyString(CMyString&& str);
|
||||||
|
CMyString& operator=(CMyString&& str);
|
||||||
|
char& operator[](size_t nIndex);
|
||||||
|
bool operator==(const CMyString& s1);
|
||||||
|
CMyString& operator+=(const CMyString& str);
|
||||||
|
CMyString& operator+=(const char* p);
|
||||||
|
CMyString& operator+(const CMyString& str1);
|
||||||
|
operator const char* ();
|
||||||
|
CMyString substring(size_t pos, size_t len = (~0));
|
||||||
|
void swap(CMyString& str1);
|
||||||
|
int find(const char* psz) const;
|
||||||
|
void insert(size_t pos, const char* psz);
|
||||||
|
void replace(size_t pos, size_t count, const char* psz);
|
||||||
private:
|
private:
|
||||||
char* m_pchData;
|
char* m_pchData;
|
||||||
size_t m_nDataLength;
|
size_t m_nDataLength;
|
||||||
size_t m_nAllocLength;
|
size_t m_nAllocLength;
|
||||||
};
|
#ifdef _MYDEBUG
|
||||||
|
public:
|
||||||
|
static void clearobjcount();
|
||||||
|
static unsigned objcount();
|
||||||
|
private:
|
||||||
|
static unsigned m_iCounter;
|
||||||
|
#endif // _MYDEBUG
|
||||||
|
};
|
||||||
|
|
||||||
|
std::ostream& operator<<(std::ostream& os, CMyString& s);
|
||||||
|
|
@ -1,6 +1,5 @@
|
||||||
// Tóth Dániel Mátyás | IFPQYY | v3
|
// Tóth Dániel Mátyás | IFPQYY | v2
|
||||||
#include "CMyStringException.h"
|
#include "CMyStringException.h"
|
||||||
#include "CMyString.h"
|
|
||||||
|
|
||||||
static int strLength(const char* str) {
|
static int strLength(const char* str) {
|
||||||
if (str == nullptr)
|
if (str == nullptr)
|
||||||
|
|
@ -15,21 +14,16 @@ static int strLength(const char* str) {
|
||||||
return cnt;
|
return cnt;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void CopyStr(char* dest, const char* src, size_t length) {
|
|
||||||
if (dest == nullptr || src == nullptr) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
size_t i;
|
|
||||||
for (i = 0; i < length; i++)
|
|
||||||
{
|
|
||||||
dest[i] = src[i];
|
|
||||||
}
|
|
||||||
dest[i] = '\0';
|
|
||||||
}
|
|
||||||
|
|
||||||
CMyStringException::CMyStringException(const char* input) {
|
CMyStringException::CMyStringException(const char* input) {
|
||||||
msg = CMyString(input);
|
size_t length = strLength(input);
|
||||||
|
|
||||||
|
msg = shared_ptr<char[]>(new char[length + 1]);
|
||||||
|
for (size_t i = 0; i < length; ++i)
|
||||||
|
{
|
||||||
|
msg[i] = input[i];
|
||||||
|
}
|
||||||
|
msg[length] = '\0';
|
||||||
}
|
}
|
||||||
const char* CMyStringException::what() const {
|
const char* CMyStringException::what() const {
|
||||||
return msg.c_str();
|
return msg.get();
|
||||||
}
|
}
|
||||||
|
|
@ -1,7 +1,6 @@
|
||||||
// Tóth Dániel Mátyás | IFPQYY | v3
|
// Tóth Dániel Mátyás | IFPQYY | v2
|
||||||
#pragma once
|
#pragma once
|
||||||
#include <memory>
|
#include <memory>
|
||||||
#include "CMyString.h"
|
|
||||||
using namespace std;
|
using namespace std;
|
||||||
class CMyStringException {
|
class CMyStringException {
|
||||||
public:
|
public:
|
||||||
|
|
@ -12,5 +11,5 @@ public:
|
||||||
static constexpr const char* ErrCount = "Hiba: karakterek száma 0!";
|
static constexpr const char* ErrCount = "Hiba: karakterek száma 0!";
|
||||||
static constexpr const char* ErrUnexpected = "Hiba: Nem várt hiba!";
|
static constexpr const char* ErrUnexpected = "Hiba: Nem várt hiba!";
|
||||||
private:
|
private:
|
||||||
CMyString msg;
|
shared_ptr<char[]> msg;
|
||||||
};
|
};
|
||||||
BIN
feladat5/feladat5/IFPQYY_feladat6v2.zip
Normal file
BIN
feladat5/feladat5/IFPQYY_feladat6v2.zip
Normal file
Binary file not shown.
|
|
@ -1,4 +1,5 @@
|
||||||
// Tóth Dániel Mátyás | IFPQYY | v3
|
// Tóth Dániel Mátyás | IFPQYY | v2
|
||||||
|
#define _MYDEBUG
|
||||||
#include "pch.h"
|
#include "pch.h"
|
||||||
#include "CppUnitTest.h"
|
#include "CppUnitTest.h"
|
||||||
#include <CMyString.h>
|
#include <CMyString.h>
|
||||||
|
|
@ -385,6 +386,7 @@ namespace UnitTest1
|
||||||
CMyString('a', 10),
|
CMyString('a', 10),
|
||||||
CMyString("alma"),
|
CMyString("alma"),
|
||||||
CMyString("test"),
|
CMyString("test"),
|
||||||
|
CMyString("alma"),
|
||||||
};
|
};
|
||||||
int pos[] = {
|
int pos[] = {
|
||||||
0,
|
0,
|
||||||
|
|
@ -395,6 +397,7 @@ namespace UnitTest1
|
||||||
3,
|
3,
|
||||||
4,
|
4,
|
||||||
0,
|
0,
|
||||||
|
1,
|
||||||
};
|
};
|
||||||
int cnt[] = {
|
int cnt[] = {
|
||||||
1,
|
1,
|
||||||
|
|
@ -405,6 +408,7 @@ namespace UnitTest1
|
||||||
1,
|
1,
|
||||||
100,
|
100,
|
||||||
0,
|
0,
|
||||||
|
-1,
|
||||||
};
|
};
|
||||||
char* text[] = {
|
char* text[] = {
|
||||||
"",
|
"",
|
||||||
|
|
@ -415,6 +419,7 @@ namespace UnitTest1
|
||||||
"aaaaaaaaa",
|
"aaaaaaaaa",
|
||||||
"alma",
|
"alma",
|
||||||
"test",
|
"test",
|
||||||
|
"a"
|
||||||
};
|
};
|
||||||
int testcount = sizeof(pos) / sizeof(int);
|
int testcount = sizeof(pos) / sizeof(int);
|
||||||
for (size_t i = 0; i < testcount; i++)
|
for (size_t i = 0; i < testcount; i++)
|
||||||
|
|
@ -505,11 +510,12 @@ namespace UnitTest1
|
||||||
CMyString("test"),
|
CMyString("test"),
|
||||||
CMyString("test"),
|
CMyString("test"),
|
||||||
CMyString("test"),
|
CMyString("test"),
|
||||||
CMyString("test"),
|
CMyString("test"),
|
||||||
CMyString("test"),
|
CMyString("test"),
|
||||||
CMyString("banan"),
|
CMyString("banan"),
|
||||||
CMyString("banan"),
|
CMyString("banan"),
|
||||||
CMyString("alma"),
|
CMyString("alma"),
|
||||||
|
CMyString("ABCDE"),
|
||||||
};
|
};
|
||||||
const char* text[] = {
|
const char* text[] = {
|
||||||
"",
|
"",
|
||||||
|
|
@ -525,6 +531,7 @@ namespace UnitTest1
|
||||||
"narancs",
|
"narancs",
|
||||||
"narancs",
|
"narancs",
|
||||||
"dio",
|
"dio",
|
||||||
|
"BCDE",
|
||||||
};
|
};
|
||||||
size_t extraargs[][2] = {
|
size_t extraargs[][2] = {
|
||||||
{ 0, ~0 },
|
{ 0, ~0 },
|
||||||
|
|
@ -540,6 +547,7 @@ namespace UnitTest1
|
||||||
{ 0, ~0 },
|
{ 0, ~0 },
|
||||||
{ 2, 2 },
|
{ 2, 2 },
|
||||||
{ 3, 1 },
|
{ 3, 1 },
|
||||||
|
{ 0, 2 },
|
||||||
};
|
};
|
||||||
int sizes[][2] = {
|
int sizes[][2] = {
|
||||||
{ 0, 1 },
|
{ 0, 1 },
|
||||||
|
|
@ -555,6 +563,7 @@ namespace UnitTest1
|
||||||
{ 12, 26 },
|
{ 12, 26 },
|
||||||
{ 7, 16 },
|
{ 7, 16 },
|
||||||
{ 4, 5 },
|
{ 4, 5 },
|
||||||
|
{ 7, 16 },
|
||||||
};
|
};
|
||||||
const char* expected[] = {
|
const char* expected[] = {
|
||||||
"",
|
"",
|
||||||
|
|
@ -570,6 +579,7 @@ namespace UnitTest1
|
||||||
"banannarancs",
|
"banannarancs",
|
||||||
"bananra",
|
"bananra",
|
||||||
"alma",
|
"alma",
|
||||||
|
"ABCDEBC",
|
||||||
};
|
};
|
||||||
int testcount = sizeof(text) / sizeof(char*);
|
int testcount = sizeof(text) / sizeof(char*);
|
||||||
for (size_t i = 0; i < testcount; i++)
|
for (size_t i = 0; i < testcount; i++)
|
||||||
|
|
@ -591,5 +601,466 @@ namespace UnitTest1
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
TEST_METHOD(EqualsOperatorTests) {
|
||||||
|
CMyString a = CMyString("kutya");
|
||||||
|
CMyString b = CMyString("kutya");
|
||||||
|
CMyString c = CMyString("cica");
|
||||||
|
CMyString d;
|
||||||
|
CMyString e = CMyString("cicajuice");
|
||||||
|
Assert::IsTrue(a == b);
|
||||||
|
Assert::IsFalse(a == c);
|
||||||
|
Assert::IsFalse(a == d);
|
||||||
|
Assert::IsFalse(a == e);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_METHOD(IndexCheckTests) {
|
||||||
|
CMyString str[]{
|
||||||
|
CMyString(),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
};
|
||||||
|
size_t indexes[] = {
|
||||||
|
0,
|
||||||
|
0,
|
||||||
|
4,
|
||||||
|
3,
|
||||||
|
};
|
||||||
|
char expected[] = {
|
||||||
|
'\0', //will mark not valid characters with null
|
||||||
|
't',
|
||||||
|
'\0',
|
||||||
|
't',
|
||||||
|
};
|
||||||
|
size_t testcount = sizeof(expected) / sizeof(char);
|
||||||
|
for (size_t i = 0; i < testcount; i++)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
Assert::AreEqual(expected[i], str[i][indexes[i]]);
|
||||||
|
}
|
||||||
|
catch (const CMyStringException& e)
|
||||||
|
{
|
||||||
|
if (expected[i] == '\0')
|
||||||
|
{
|
||||||
|
Assert::AreEqual(CMyStringException::ErrOutOfRange, e.what());
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
Assert::IsTrue(false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (...)
|
||||||
|
{
|
||||||
|
Assert::IsTrue(false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_METHOD(ConstCharCastingTest) {
|
||||||
|
CMyString str = CMyString("test");
|
||||||
|
Assert::AreEqual(str.c_str(), (const char*)str);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_METHOD(MoveOperatorTests) {
|
||||||
|
CMyString a = CMyString();
|
||||||
|
CMyString b = CMyString("test");
|
||||||
|
a = move(b);
|
||||||
|
|
||||||
|
Assert::AreEqual("test", (const char*)a);
|
||||||
|
Assert::IsTrue(b.empty());
|
||||||
|
|
||||||
|
CMyString c = CMyString(move(a));
|
||||||
|
Assert::AreEqual("test", (const char*)c);
|
||||||
|
Assert::IsTrue(a.empty());
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_METHOD(AddStringOperatorTests) {
|
||||||
|
CMyString strbase[]{
|
||||||
|
CMyString(),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("banan"),
|
||||||
|
};
|
||||||
|
const char* text[] = {
|
||||||
|
"",
|
||||||
|
"test",
|
||||||
|
"a",
|
||||||
|
"narancs",
|
||||||
|
};
|
||||||
|
size_t extraargs[][2] = {
|
||||||
|
{ 0, ~0 },
|
||||||
|
{ 0, ~0 },
|
||||||
|
{ 0, ~0 },
|
||||||
|
{ 0, ~0 },
|
||||||
|
};
|
||||||
|
int sizes[][2] = {
|
||||||
|
{ 0, 1 },
|
||||||
|
{ 8, 18 },
|
||||||
|
{ 5, 12 },
|
||||||
|
{ 12, 26 },
|
||||||
|
};
|
||||||
|
const char* expected[] = {
|
||||||
|
"",
|
||||||
|
"testtest",
|
||||||
|
"testa",
|
||||||
|
"banannarancs",
|
||||||
|
};
|
||||||
|
int testcount = sizeof(expected) / sizeof(char*);
|
||||||
|
for (size_t i = 0; i < testcount; i++)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
CMyString res;
|
||||||
|
res = move(strbase[i] + text[i]);
|
||||||
|
Assert::AreEqual(expected[i], res.c_str());
|
||||||
|
Assert::AreEqual(sizes[i][0], (int)res.size());
|
||||||
|
Assert::AreEqual(sizes[i][1], (int)res.capacity());
|
||||||
|
|
||||||
|
CMyString stradd = CMyString(text[i]);
|
||||||
|
res = CMyString(move(strbase[i] + stradd));
|
||||||
|
Assert::AreEqual(expected[i], res.c_str());
|
||||||
|
Assert::AreEqual(sizes[i][0], (int)res.size());
|
||||||
|
Assert::AreEqual(sizes[i][1], (int)res.capacity());
|
||||||
|
|
||||||
|
strbase[i] += stradd;
|
||||||
|
Assert::AreEqual(expected[i], strbase[i].c_str());
|
||||||
|
Assert::AreEqual(sizes[i][0], (int)strbase[i].size());
|
||||||
|
Assert::AreEqual(sizes[i][1], (int)strbase[i].capacity());
|
||||||
|
}
|
||||||
|
catch (const CMyStringException& e)
|
||||||
|
{
|
||||||
|
Assert::AreEqual(expected[i], e.what());
|
||||||
|
}
|
||||||
|
catch (...)
|
||||||
|
{
|
||||||
|
Assert::IsTrue(false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
TEST_METHOD(SubstringTests) {
|
||||||
|
CMyString str[] = {
|
||||||
|
CMyString(),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("greek"),
|
||||||
|
};
|
||||||
|
size_t args[][2] = {
|
||||||
|
{ 0, ~0 },
|
||||||
|
{ 0, ~0 },
|
||||||
|
{ 2, ~0 },
|
||||||
|
{ 4, ~0 },
|
||||||
|
{ 5, ~0 },
|
||||||
|
{ 0, 1 },
|
||||||
|
{ 1, 1 },
|
||||||
|
{ 1, 999 },
|
||||||
|
{ 1, 0 },
|
||||||
|
{ 2, 2 },
|
||||||
|
};
|
||||||
|
char* expected[] = {
|
||||||
|
"",
|
||||||
|
"test",
|
||||||
|
"st",
|
||||||
|
"",
|
||||||
|
nullptr,
|
||||||
|
"t",
|
||||||
|
"e",
|
||||||
|
"est",
|
||||||
|
"",
|
||||||
|
"ee"
|
||||||
|
};
|
||||||
|
int sizes[] = {
|
||||||
|
0,
|
||||||
|
4,
|
||||||
|
2,
|
||||||
|
0,
|
||||||
|
0,
|
||||||
|
1,
|
||||||
|
1,
|
||||||
|
3,
|
||||||
|
0,
|
||||||
|
2,
|
||||||
|
};
|
||||||
|
size_t testcount = sizeof(expected) / sizeof(char*);
|
||||||
|
for (size_t i = 0; i < testcount; i++)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
CMyString res = str[i].substring(args[i][0], args[i][1]);
|
||||||
|
Assert::AreEqual(expected[i], res.c_str());
|
||||||
|
Assert::AreEqual(sizes[i], (int)res.size());
|
||||||
|
Assert::AreEqual(sizes[i] +1, (int)res.capacity());
|
||||||
|
}
|
||||||
|
catch (const CMyStringException& e)
|
||||||
|
{
|
||||||
|
if (expected[i] == nullptr)
|
||||||
|
{
|
||||||
|
Assert::AreEqual(CMyStringException::ErrOutOfRange, e.what());
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
Assert::IsTrue(false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (...)
|
||||||
|
{
|
||||||
|
Assert::IsTrue(false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_METHOD(SwapTest) {
|
||||||
|
CMyString a = CMyString("contentA");
|
||||||
|
CMyString b = CMyString("contentB");
|
||||||
|
a.swap(b);
|
||||||
|
Assert::AreEqual("contentB", (const char*)a);
|
||||||
|
Assert::AreEqual("contentA", (const char*)b);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_METHOD(FindTests) {
|
||||||
|
CMyString str[] = {
|
||||||
|
CMyString(),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("KORTEALMAEPER"),
|
||||||
|
CMyString("KORTEALMAEPER"),
|
||||||
|
CMyString("KORTEALMAEPER"),
|
||||||
|
};
|
||||||
|
char* find[] = {
|
||||||
|
"",
|
||||||
|
"",
|
||||||
|
nullptr,
|
||||||
|
"h",
|
||||||
|
"e",
|
||||||
|
"test",
|
||||||
|
"testt",
|
||||||
|
"est",
|
||||||
|
"kORTE",
|
||||||
|
"ALMa",
|
||||||
|
"EPEr",
|
||||||
|
};
|
||||||
|
int expected[] = {
|
||||||
|
-1,
|
||||||
|
-1,
|
||||||
|
-1,
|
||||||
|
-1,
|
||||||
|
1,
|
||||||
|
0,
|
||||||
|
-1,
|
||||||
|
1,
|
||||||
|
-1,
|
||||||
|
-1,
|
||||||
|
-1,
|
||||||
|
};
|
||||||
|
size_t testcount = sizeof(expected) / sizeof(int);
|
||||||
|
for (size_t i = 0; i < testcount; i++)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
Assert::AreEqual(expected[i], str[i].find(find[i]));
|
||||||
|
}
|
||||||
|
catch (...)
|
||||||
|
{
|
||||||
|
Assert::IsTrue(false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
TEST_METHOD(InsertTests) {
|
||||||
|
CMyString str[] = {
|
||||||
|
CMyString(),
|
||||||
|
CMyString(),
|
||||||
|
CMyString("ALMA"),
|
||||||
|
CMyString("AB"),
|
||||||
|
CMyString("ALMA"),
|
||||||
|
CMyString("test"),
|
||||||
|
CMyString("test"),
|
||||||
|
};
|
||||||
|
const char* inserttext[] = {
|
||||||
|
"",
|
||||||
|
"",
|
||||||
|
"XY",
|
||||||
|
str[3].c_str(),
|
||||||
|
"X",
|
||||||
|
"test",
|
||||||
|
nullptr,
|
||||||
|
};
|
||||||
|
int insertindex[] = {
|
||||||
|
0,
|
||||||
|
1,
|
||||||
|
2,
|
||||||
|
1,
|
||||||
|
5,
|
||||||
|
4,
|
||||||
|
4,
|
||||||
|
};
|
||||||
|
char* expected[] = {
|
||||||
|
"",
|
||||||
|
nullptr,
|
||||||
|
"ALXYMA",
|
||||||
|
"AABB",
|
||||||
|
nullptr,
|
||||||
|
"testtest",
|
||||||
|
"test",
|
||||||
|
};
|
||||||
|
int sizes[][2] = {
|
||||||
|
{ 0, 1 },
|
||||||
|
{ 0, 1 },
|
||||||
|
{ 6, 14 },
|
||||||
|
{ 4, 10 },
|
||||||
|
{ 4, 5 },
|
||||||
|
{ 8, 18 },
|
||||||
|
{ 4, 5 },
|
||||||
|
};
|
||||||
|
size_t testcount = sizeof(expected) / sizeof(char*);
|
||||||
|
for (size_t i = 0; i < testcount; i++)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
str[i].insert(insertindex[i], inserttext[i]);
|
||||||
|
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)
|
||||||
|
{
|
||||||
|
if (expected[i] == nullptr)
|
||||||
|
{
|
||||||
|
Assert::AreEqual(CMyStringException::ErrOutOfRange, e.what());
|
||||||
|
Assert::AreEqual(sizes[i][0], (int)str[i].size());
|
||||||
|
Assert::AreEqual(sizes[i][1], (int)str[i].capacity());
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
Assert::IsTrue(false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (...)
|
||||||
|
{
|
||||||
|
Assert::IsTrue(false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_METHOD(ReplaceTests) {
|
||||||
|
CMyString str[] = {
|
||||||
|
CMyString(),
|
||||||
|
CMyString(),
|
||||||
|
CMyString("ABCDEFG"),
|
||||||
|
CMyString("ABCDEFG"),
|
||||||
|
CMyString("ABCDEFG"),
|
||||||
|
CMyString("ABCDEFG"),
|
||||||
|
};
|
||||||
|
const char* inserttext[] = {
|
||||||
|
"",
|
||||||
|
"",
|
||||||
|
"X",
|
||||||
|
"XYZ123",
|
||||||
|
nullptr,
|
||||||
|
""
|
||||||
|
};
|
||||||
|
int insertindex[] = {
|
||||||
|
0,
|
||||||
|
1,
|
||||||
|
2,
|
||||||
|
2,
|
||||||
|
2,
|
||||||
|
0,
|
||||||
|
};
|
||||||
|
int count[] = {
|
||||||
|
0,
|
||||||
|
0,
|
||||||
|
3,
|
||||||
|
3,
|
||||||
|
3,
|
||||||
|
0,
|
||||||
|
};
|
||||||
|
char* expected[] = {
|
||||||
|
"",
|
||||||
|
nullptr,
|
||||||
|
"ABXFG",
|
||||||
|
"ABXYZ123FG",
|
||||||
|
"ABFG",
|
||||||
|
"ABCDEFG",
|
||||||
|
};
|
||||||
|
int sizes[][2] = {
|
||||||
|
{ 0, 1 },
|
||||||
|
{ 0, 1 },
|
||||||
|
{ 5, 8 },
|
||||||
|
{ 10, 22 },
|
||||||
|
{ 4, 8 },
|
||||||
|
{ 7, 8 },
|
||||||
|
};
|
||||||
|
size_t testcount = sizeof(expected) / sizeof(char*);
|
||||||
|
for (size_t i = 0; i < testcount; i++)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
str[i].replace(insertindex[i], count[i], inserttext[i]);
|
||||||
|
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)
|
||||||
|
{
|
||||||
|
if (expected[i] == nullptr)
|
||||||
|
{
|
||||||
|
Assert::AreEqual(CMyStringException::ErrOutOfRange, e.what());
|
||||||
|
Assert::AreEqual(sizes[i][0], (int)str[i].size());
|
||||||
|
Assert::AreEqual(sizes[i][1], (int)str[i].capacity());
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
Assert::IsTrue(false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (...)
|
||||||
|
{
|
||||||
|
Assert::IsTrue(false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_METHOD(SpecificTests) {
|
||||||
|
CMyString s = CMyString("ABCDE");
|
||||||
|
const char* const belsoForras = s.c_str() + 1;
|
||||||
|
s.append(belsoForras, 0, 2);
|
||||||
|
Assert::AreEqual("ABCDEBC", s.c_str());
|
||||||
|
Assert::AreEqual((size_t)7, s.size());
|
||||||
|
Assert::AreEqual((size_t)16, s.capacity());
|
||||||
|
|
||||||
|
CMyString g = CMyString("ALMA");
|
||||||
|
g.reserve(12);
|
||||||
|
Assert::AreEqual((size_t)4, g.size());
|
||||||
|
Assert::AreEqual((size_t)12, g.capacity());
|
||||||
|
const char* p = g.c_str();
|
||||||
|
g.insert(2, "XY");
|
||||||
|
Assert::AreEqual("ALXYMA", g.c_str());
|
||||||
|
Assert::AreEqual((size_t)6, g.size());
|
||||||
|
Assert::AreEqual((size_t)12, g.capacity());
|
||||||
|
Assert::IsTrue(p == g.c_str());
|
||||||
|
|
||||||
|
CMyString h = CMyString("ABCDEFG");
|
||||||
|
const char* oldaddr = h.c_str();
|
||||||
|
h.replace(2, 3, "X");
|
||||||
|
Assert::AreEqual("ABXFG", h.c_str());
|
||||||
|
Assert::AreEqual((size_t)5, h.size());
|
||||||
|
Assert::AreEqual((size_t)8, h.capacity());
|
||||||
|
Assert::IsTrue(oldaddr == h.c_str());
|
||||||
|
Assert::AreEqual('\0', h.c_str()[h.size()]);
|
||||||
|
}
|
||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -1,4 +1,4 @@
|
||||||
// Tóth Dániel Mátyás | IFPQYY | v3
|
// Tóth Dániel Mátyás | IFPQYY | v2
|
||||||
#include "CMyString.h"
|
#include "CMyString.h"
|
||||||
|
|
||||||
int main() {
|
int main() {
|
||||||
|
|
|
||||||
Loading…
Add table
Add a link
Reference in a new issue