2026-27-cpp-homework/feladat5/UnitTest1/UnitTest1.cpp

// 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);
				}
			}
		}
	};
}