533 lines
9.7 KiB
C++
533 lines
9.7 KiB
C++
// Tóth Dániel Mátyás | IFPQYY | v1
|
|
#include "pch.h"
|
|
#include "CppUnitTest.h"
|
|
#include <CMyString.h>
|
|
#include <CMyStringException.h>
|
|
|
|
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 (...)
|
|
{
|
|
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 strs[]{
|
|
CMyString("test"),
|
|
CMyString("test"),
|
|
CMyString("testtesttesttest"),
|
|
CMyString("testtesttesttest"),
|
|
};
|
|
int expected[][2] = {
|
|
{ 4, 10 },
|
|
{ 4, 13 },
|
|
{ 16, 34 },
|
|
{ 16, 34 },
|
|
};
|
|
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("test");
|
|
CMyString str2 = str1;
|
|
}
|
|
|
|
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) {
|
|
int allocs[] = {
|
|
1,
|
|
5,
|
|
10,
|
|
33,
|
|
};
|
|
|
|
int testcount = sizeof(allocs) / sizeof(int);
|
|
for (size_t i = 0; i < testcount; i++)
|
|
{
|
|
try
|
|
{
|
|
CMyString str = CMyString("test");
|
|
str.reserve(allocs[i]);
|
|
Assert::AreEqual(allocs[i], (int)str.capacity());
|
|
}
|
|
catch (const CMyStringException& e)
|
|
{
|
|
Assert::AreEqual(CMyStringException::ErrOutOfRange, e.what());
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_METHOD(EraseTests) {
|
|
CMyString str[]{
|
|
CMyString(),
|
|
CMyString("test"),
|
|
CMyString("test"),
|
|
CMyString("test"),
|
|
CMyString("test"),
|
|
CMyString('a', 10),
|
|
};
|
|
int pos[] = {
|
|
0,
|
|
4,
|
|
-1,
|
|
3,
|
|
3,
|
|
3,
|
|
};
|
|
int cnt[] = {
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
1,
|
|
1,
|
|
};
|
|
char* text[] = {
|
|
"",
|
|
NULL,
|
|
NULL,
|
|
"test",
|
|
"tes",
|
|
"aaaaaaaaa",
|
|
};
|
|
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)
|
|
{
|
|
if (i < 3)
|
|
{
|
|
Assert::AreEqual(CMyStringException::ErrOutOfRange, e.what());
|
|
}
|
|
else
|
|
{
|
|
Assert::IsTrue(false);
|
|
}
|
|
}
|
|
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"),
|
|
};
|
|
const char* text[] = {
|
|
"",
|
|
nullptr,
|
|
str[2].c_str(),
|
|
"test",
|
|
"test",
|
|
"test",
|
|
"test",
|
|
};
|
|
size_t extraargs[][2] = {
|
|
{ 0, ~0 },
|
|
{ 0, ~0 },
|
|
{ 0, ~0 },
|
|
{ 0, ~0 },
|
|
{ 4, ~0 },
|
|
{ 0, 5 },
|
|
{ 2, 3 },
|
|
};
|
|
int sizes[][2] = {
|
|
{ 0, 1 },
|
|
{ 0, 1 },
|
|
{ 4, 5 },
|
|
{ 8, 16 },
|
|
{ 4, 5 },
|
|
{ 4, 5 },
|
|
{ 4, 5 },
|
|
};
|
|
const char* expected[] = {
|
|
"",
|
|
"",
|
|
"test",
|
|
"testtest",
|
|
CMyStringException::ErrOutOfRange,
|
|
CMyStringException::ErrOutOfRange,
|
|
CMyStringException::ErrOutOfRange,
|
|
};
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|