v3
This commit is contained in:
parent
459e111f2f
commit
6ca06962d9
9 changed files with 642 additions and 21 deletions
|
|
@ -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 <CMyString.h>
|
||||
|
|
@ -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++)
|
||||
|
|
|
|||
|
|
@ -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 <iostream>
|
||||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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:
|
||||
|
|
|
|||
|
|
@ -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"
|
||||
|
||||
|
|
|
|||
|
|
@ -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 <memory>
|
||||
#include "CMyString.h"
|
||||
|
|
|
|||
595
feladat5/feladat5/UnitTest1.cpp
Normal file
595
feladat5/feladat5/UnitTest1.cpp
Normal file
|
|
@ -0,0 +1,595 @@
|
|||
// Tóth Dániel Mátyás | IFPQYY | v3
|
||||
#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 (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);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
|
@ -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() {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue