leonetienne/StringTools
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Switched to Catch2 testing framework

Browse Source
This commit is contained in:
Leonetienne 2022-02-11 01:32:43 +01:00
parent e3932dbdce
commit a516b3aa6f
8 changed files with 18456 additions and 778 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
StringTools/Test/CMakeLists.txt Normal file
View File

@ -0,0 +1,18 @@
cmake_minimum_required(VERSION 3.16)
project(Tests)
set(CMAKE_CXX_STANDARD 17)
include_directories(..)
link_directories(../StringTools/cmake-build-debug)
add_executable(Tests
Catch2.h
main.cpp
Lower.cpp
Upper.cpp
Replace_Char.cpp
Replace_String.cpp
)
target_link_libraries(Tests Stringtools)

17965
StringTools/Test/Catch2.h Normal file
View File

File diff suppressed because it is too large Load Diff

288
StringTools/Test/Lower.cpp
View File

@ -1,226 +1,72 @@
#include "CppUnitTest.h"
#include "../StringTools/StringTools.h"
#include <StringTools/StringTools.h>
#include "Catch2.h"
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
namespace _StringTools
// Tests that lowering an empty string returns an empty string
TEST_CASE(__FILE__"/EmptyString", "[LOWER]")
{
TEST_CLASS(_Lower)
{
public:
// Setup
const std::string in = "";
// Tests that lowering an empty string returns an empty string
TEST_METHOD(EmptyString)
{
// Setup
const std::string in = "";
// Exercise
const std::string out = StringTools::Lower(in);
// Exercise
const std::string out = StringTools::Lower(in);
// Verify
Assert::AreEqual("", out.c_str());
return;
}
// Tests that lowering a string without any letters returns an itself
TEST_METHOD(Symbols)
{
// Setup
const std::string in = "66! _-\n*";
// Exercise
const std::string out = StringTools::Lower(in);
// Verify
Assert::AreEqual("66! _-\n*", out.c_str());
return;
}
// Tests that lowering a string of lowercase letters returns itself
TEST_METHOD(AlreadyLowered)
{
// Setup
const std::string in = "ughareyouserious";
// Exercise
const std::string out = StringTools::Lower(in);
// Verify
Assert::AreEqual("ughareyouserious", out.c_str());
return;
}
// Tests that lowering a string of uppercase letters returns the lowercase version
TEST_METHOD(Uppercase)
{
// Setup
const std::string in = "UGHAREYOUSERIOUS";
// Exercise
const std::string out = StringTools::Lower(in);
// Verify
Assert::AreEqual("ughareyouserious", out.c_str());
return;
}
// Tests that lowering a string of uppercase, lowercase letters and symbols returns the lowercase version
TEST_METHOD(Mixed)
{
// Setup
const std::string in = "Ugh, Are You Serious?! DON'T DO THAT!!!";
// Exercise
const std::string out = StringTools::Lower(in);
// Verify
Assert::AreEqual("ugh, are you serious?! don't do that!!!", out.c_str());
return;
}
// Tests that lowering already lowered umlautes returns itself
TEST_METHOD(Umlautes_already_lower_a)
{
// Setup
const std::string in = "äáàâ";
// Exercise
const std::string out = StringTools::Lower(in);
// Verify
Assert::AreEqual("äáàâ", out.c_str());
}
// Tests that lowering uppercase umlautes returns the lowered umlautes
TEST_METHOD(Umlautes_upper_a)
{
// Setup
const std::string in = "ÄÁÀÂ";
// Exercise
const std::string out = StringTools::Lower(in);
// Verify
Assert::AreEqual("äáàâ", out.c_str());
}
// Tests that lowering already lowered umlautes returns itself
TEST_METHOD(Umlautes_already_lower_e)
{
// Setup
const std::string in = "éèê";
// Exercise
const std::string out = StringTools::Lower(in);
// Verify
Assert::AreEqual("éèê", out.c_str());
}
// Tests that lowering uppercase umlautes returns the lowered umlautes
TEST_METHOD(Umlautes_upper_e)
{
// Setup
const std::string in = "ÉÈÊ";
// Exercise
const std::string out = StringTools::Lower(in);
// Verify
Assert::AreEqual("éèê", out.c_str());
}
// Tests that lowering already lowered umlautes returns itself
TEST_METHOD(Umlautes_already_lower_u)
{
// Setup
const std::string in = "üúùû";
// Exercise
const std::string out = StringTools::Lower(in);
// Verify
Assert::AreEqual("üúùû", out.c_str());
}
// Tests that lowering uppercase umlautes returns the lowered umlautes
TEST_METHOD(Umlautes_upper_u)
{
// Setup
const std::string in = "ÜÚÙÛ";
// Exercise
const std::string out = StringTools::Lower(in);
// Verify
Assert::AreEqual("üúùû", out.c_str());
}
// Tests that lowering already lowered umlautes returns itself
TEST_METHOD(Umlautes_already_lower_o)
{
// Setup
const std::string in = "öóòô";
// Exercise
const std::string out = StringTools::Lower(in);
// Verify
Assert::AreEqual("öóòô", out.c_str());
}
// Tests that lowering uppercase umlautes returns the lowered umlautes
TEST_METHOD(Umlautes_upper_o)
{
// Setup
const std::string in = "ÖÓÒÔ";
// Exercise
const std::string out = StringTools::Lower(in);
// Verify
Assert::AreEqual("öóòô", out.c_str());
}
// Tests that lowering already lowered umlautes returns itself
TEST_METHOD(Umlautes_already_lower_i)
{
// Setup
const std::string in = "íìî";
// Exercise
const std::string out = StringTools::Lower(in);
// Verify
Assert::AreEqual("íìî", out.c_str());
}
// Tests that lowering uppercase umlautes returns the lowered umlautes
TEST_METHOD(Umlautes_upper_i)
{
// Setup
const std::string in = "ÍÌÎ";
// Exercise
const std::string out = StringTools::Lower(in);
// Verify
Assert::AreEqual("íìî", out.c_str());
}
// Tests that lowering a string of uppercase, lowercase letters and symbols returns the lowercase version, even with umlauts
TEST_METHOD(Mixed_with_umlautes)
{
// Setup
const std::string in = "Ügh, Àrä Yóü Serîöûs?! DÓN'T DÒ THÄT!!!";
// Exercise
const std::string out = StringTools::Lower(in);
// Verify
Assert::AreEqual("ügh, àrä yóü serîöûs?! dón't dò thät!!!", out.c_str());
return;
}
};
// Verify
REQUIRE(out == "");
return;
}
// Tests that lowering a string without any letters returns itself
TEST_CASE(__FILE__"/Symbols", "[LOWER]")
{
// Setup
const std::string in = "66! _-\n*";
// Exercise
const std::string out = StringTools::Lower(in);
// Verify
REQUIRE(out == "66! _-\n*");
return;
}
// Tests that lowering a string of lowercase letters returns itself
TEST_CASE(__FILE__"/AlreadyLowered", "[LOWER]")
{
// Setup
const std::string in = "ughareyouserious";
// Exercise
const std::string out = StringTools::Lower(in);
// Verify
REQUIRE(out == "ughareyouserious");
return;
}
// Tests that lowering a string of uppercase letters returns the lowercase version
TEST_CASE(__FILE__"/Uppercase", "[LOWER]")
{
// Setup
const std::string in = "UGHAREYOUSERIOUS";
// Exercise
const std::string out = StringTools::Lower(in);
// Verify
REQUIRE(out == "ughareyouserious");
return;
}
// Tests that lowering a string of uppercase, lowercase letters and symbols returns the lowercase version
TEST_CASE(__FILE__"/Mixed", "[LOWER]")
{
// Setup
const std::string in = "Ugh, Are You Serious?! DON'T DO THAT!!!";
// Exercise
const std::string out = StringTools::Lower(in);
// Verify
REQUIRE(out == "ugh, are you serious?! don't do that!!!");
return;
}

312
StringTools/Test/Replace_Char.cpp
View File

@ -1,166 +1,156 @@
#include "CppUnitTest.h"
#include "../StringTools/StringTools.h"
#include <StringTools/StringTools.h>
#include "Catch2.h"
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
namespace _StringTools
// Tests that replacing something in an empty string returns an empty string
TEST_CASE(__FILE__"/EmptyString")
{
TEST_CLASS(_Replace_Char)
{
public:
// Tests that replacing something in an empty string returns an empty string
TEST_METHOD(EmptyString)
{
// Setup
const std::string in = "";
// Setup
const std::string in = "";
// Exercise
const std::string out = StringTools::Replace(in, 'a', "Subst");
// Exercise
const std::string out = StringTools::Replace(in, 'a', "Subst");
// Verify
Assert::AreEqual(out.c_str(), "");
return;
}
// Tests that replacing a char to an empty string works
TEST_METHOD(Single_ReplaceToEmpty)
{
// Setup
const std::string in = "i";
// Exercise
const std::string out = StringTools::Replace(in, 'i', "");
// Verify
Assert::AreEqual(out.c_str(), "");
return;
}
// Tests that replacing to a single char works
TEST_METHOD(Single_ReplaceToSingleChar)
{
// Setup
const std::string in = "a";
// Exercise
const std::string out = StringTools::Replace(in, 'a', "i");
// Verify
Assert::AreEqual(out.c_str(), "i");
return;
}
// Tests that replacing to a single char works, passing a char
TEST_METHOD(Single_ReplaceToSingleChar_AsChar)
{
// Setup
const std::string in = "Oilbanger";
// Exercise
const std::string out = StringTools::Replace(in, 'a', 'i');
// Verify
Assert::AreEqual(out.c_str(), "Oilbinger");
return;
}
// Tests that replacing the find to something longer works
TEST_METHOD(Single_ReplaceToLonger)
{
// Setup
const std::string in = "Littled";
// Exercise
const std::string out = StringTools::Replace(in, 'd', "binger");
// Verify
Assert::AreEqual(out.c_str(), "Littlebinger");
return;
}
// Tests that replacing a char to an empty string works
TEST_METHOD(Multiple_ReplaceToEmpty)
{
// Setup
const std::string in = "dirty dogs dig dirt daringly";
// Exercise
const std::string out = StringTools::Replace(in, 'd', "");
// Verify
Assert::AreEqual(out.c_str(), "irty ogs ig irt aringly");
return;
}
// Tests that replacing to a single char works
TEST_METHOD(Multiple_ReplaceToSingleChar)
{
// Setup
const std::string in = "Oilbanger, Bangerfanger, Lattle brattle oaly skattle.";
// Exercise
const std::string out = StringTools::Replace(in, 'a', "i");
// Verify
Assert::AreEqual(out.c_str(), "Oilbinger, Bingerfinger, Little brittle oily skittle.");
return;
}
// Tests that replacing to a single char works, passing a char
TEST_METHOD(Multiple_ReplaceToSingleChar_AsChar)
{
// Setup
const std::string in = "Oilbanger, Bangerfanger, Lattle brattle oaly skattle.";
// Exercise
const std::string out = StringTools::Replace(in, 'a', 'i');
// Verify
Assert::AreEqual(out.c_str(), "Oilbinger, Bingerfinger, Little brittle oily skittle.");
return;
}
// Tests that replacing the find to something longer works
TEST_METHOD(Multiple_ReplaceToLonger)
{
// Setup
const std::string in = "d d d d d d d d";
// Exercise
const std::string out = StringTools::Replace(in, 'd', "bla");
// Verify
Assert::AreEqual(out.c_str(), "bla bla bla bla bla bla bla bla");
return;
}
// Tests that the replacer ignores chars put in by the replacer
TEST_METHOD(ReplacerIgnoresReplaced)
{
// Setup
const std::string in = "b b b b b b b b";
// Exercise
const std::string out = StringTools::Replace(in, 'b', "bla");
// Verify
Assert::AreEqual(out.c_str(), "bla bla bla bla bla bla bla bla");
return;
}
// Tests that replacing succesive findings works
TEST_METHOD(Replace_Successive)
{
// Setup
const std::string in = "bbbbbbbb";
// Exercise
const std::string out = StringTools::Replace(in, 'b', "bla");
// Verify
Assert::AreEqual(out.c_str(), "blablablablablablablabla");
return;
}
};
// Verify
REQUIRE(out == "");
return;
}
// Tests that replacing a char to an empty string works
TEST_CASE(__FILE__"/Single_ReplaceToEmpty")
{
// Setup
const std::string in = "i";
// Exercise
const std::string out = StringTools::Replace(in, 'i', "");
// Verify
REQUIRE(out == "");
return;
}
// Tests that replacing to a single char works
TEST_CASE(__FILE__"/Single_ReplaceToSingleChar")
{
// Setup
const std::string in = "a";
// Exercise
const std::string out = StringTools::Replace(in, 'a', "i");
// Verify
REQUIRE(out == "i");
return;
}
// Tests that replacing to a single char works, passing a char
TEST_CASE(__FILE__"/Single_ReplaceToSingleChar_AsChar")
{
// Setup
const std::string in = "Oilbanger";
// Exercise
const std::string out = StringTools::Replace(in, 'a', 'i');
// Verify
REQUIRE(out == "Oilbinger");
return;
}
// Tests that replacing the find to something longer works
TEST_CASE(__FILE__"/Single_ReplaceToLonger")
{
// Setup
const std::string in = "Littled";
// Exercise
const std::string out = StringTools::Replace(in, 'd', "binger");
// Verify
REQUIRE(out == "Littlebinger");
return;
}
// Tests that replacing a char to an empty string works
TEST_CASE(__FILE__"/Multiple_ReplaceToEmpty")
{
// Setup
const std::string in = "dirty dogs dig dirt daringly";
// Exercise
const std::string out = StringTools::Replace(in, 'd', "");
// Verify
REQUIRE(out == "irty ogs ig irt aringly");
return;
}
// Tests that replacing to a single char works
TEST_CASE(__FILE__"/Multiple_ReplaceToSingleChar")
{
// Setup
const std::string in = "Oilbanger, Bangerfanger, Lattle brattle oaly skattle.";
// Exercise
const std::string out = StringTools::Replace(in, 'a', "i");
// Verify
REQUIRE(out == "Oilbinger, Bingerfinger, Little brittle oily skittle.");
return;
}
// Tests that replacing to a single char works, passing a char
TEST_CASE(__FILE__"/Multiple_ReplaceToSingleChar_AsChar")
{
// Setup
const std::string in = "Oilbanger, Bangerfanger, Lattle brattle oaly skattle.";
// Exercise
const std::string out = StringTools::Replace(in, 'a', 'i');
// Verify
REQUIRE(out == "Oilbinger, Bingerfinger, Little brittle oily skittle.");
return;
}
// Tests that replacing the find to something longer works
TEST_CASE(__FILE__"/Multiple_ReplaceToLonger")
{
// Setup
const std::string in = "d d d d d d d d";
// Exercise
const std::string out = StringTools::Replace(in, 'd', "bla");
// Verify
REQUIRE(out == "bla bla bla bla bla bla bla bla");
return;
}
// Tests that the replacer ignores chars put in by the replacer
TEST_CASE(__FILE__"/ReplacerIgnoresReplaced")
{
// Setup
const std::string in = "b b b b b b b b";
// Exercise
const std::string out = StringTools::Replace(in, 'b', "bla");
// Verify
REQUIRE(out == "bla bla bla bla bla bla bla bla");
return;
}
// Tests that replacing succesive findings works
TEST_CASE(__FILE__"/Replace_Successive")
{
// Setup
const std::string in = "bbbbbbbb";
// Exercise
const std::string out = StringTools::Replace(in, 'b', "bla");
// Verify
REQUIRE(out == "blablablablablablablabla");
return;
}

340
StringTools/Test/Replace_String.cpp
View File

@ -1,180 +1,170 @@
#include "CppUnitTest.h"
#include "../StringTools/StringTools.h"
#include <StringTools/StringTools.h>
#include "Catch2.h"
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
namespace _StringTools
// Tests that replacing something in an empty string returns an empty string
TEST_CASE(__FILE__"/EmptyString")
{
TEST_CLASS(_Replace_String)
{
public:
// Setup
const std::string in = "";
// Tests that replacing something in an empty string returns an empty string
TEST_METHOD(EmptyString)
{
// Setup
const std::string in = "";
// Exercise
const std::string out = StringTools::Replace(in, "burger", "Subst");
// Exercise
const std::string out = StringTools::Replace(in, "burger", "Subst");
// Verify
Assert::AreEqual(out.c_str(), "");
return;
}
// Tests that replacing a string to an empty string works
TEST_METHOD(Single_ReplaceToEmpty)
{
// Setup
const std::string in = "Squarepants";
// Exercise
const std::string out = StringTools::Replace(in, "Squarepants", "");
// Verify
Assert::AreEqual(out.c_str(), "");
return;
}
// Tests that replacing to a single char works
TEST_METHOD(Single_ReplaceToSingleChar)
{
// Setup
const std::string in = "Squarepants";
// Exercise
const std::string out = StringTools::Replace(in, "Squarepants", "i");
// Verify
Assert::AreEqual(out.c_str(), "i");
return;
}
// Tests that replacing to a single char works, passing a char
TEST_METHOD(Single_ReplaceToSingleChar_AsChar)
{
// Setup
const std::string in = "Oilbanger";
// Exercise
const std::string out = StringTools::Replace(in, "Oilbanger", 'i');
// Verify
Assert::AreEqual(out.c_str(), "i");
return;
}
// Tests that replacing the find to something longer works
TEST_METHOD(Single_ReplaceToLonger)
{
// Setup
const std::string in = "LittleDong";
// Exercise
const std::string out = StringTools::Replace(in, "Dong", "Binger");
// Verify
Assert::AreEqual(out.c_str(), "LittleBinger");
return;
}
// Tests that replacing a string to an empty string works
TEST_METHOD(Multiple_ReplaceToEmpty)
{
// Setup
const std::string in = "The fucking dogs are fucking eating the fucking chicken.";
// Exercise
const std::string out = StringTools::Replace(in, "fucking ", "");
// Verify
Assert::AreEqual(out.c_str(), "The dogs are eating the chicken.");
return;
}
// Tests that replacing to a single char works
TEST_METHOD(Multiple_ReplaceToSingleChar)
{
// Setup
const std::string in = "Oilbsmearynger, Bsmearyngerfsmearynger, Lsmearyttle brsmearyttle osmearyly sksmearyttle.";
// Exercise
const std::string out = StringTools::Replace(in, "smeary", "i");
// Verify
Assert::AreEqual(out.c_str(), "Oilbinger, Bingerfinger, Little brittle oily skittle.");
return;
}
// Tests that replacing to a single char works, passing a char
TEST_METHOD(Multiple_ReplaceToSingleChar_AsChar)
{
// Setup
const std::string in = "Oilbsmearynger, Bsmearyngerfsmearynger, Lsmearyttle brsmearyttle osmearyly sksmearyttle.";
// Exercise
const std::string out = StringTools::Replace(in, "smeary", 'i');
// Verify
Assert::AreEqual(out.c_str(), "Oilbinger, Bingerfinger, Little brittle oily skittle.");
return;
}
// Tests that replacing the find to something longer works
TEST_METHOD(Multiple_ReplaceToLonger)
{
// Setup
const std::string in = "honk honk honk honk honk honk honk honk";
// Exercise
const std::string out = StringTools::Replace(in, "honk", "hallery");
// Verify
Assert::AreEqual(out.c_str(), "hallery hallery hallery hallery hallery hallery hallery hallery");
return;
}
// Tests that the replacer ignores chars put in by the replacer
TEST_METHOD(ReplacerIgnoresReplaced)
{
// Setup
const std::string in = "honk honk honk honk honk honk honk honk";
// Exercise
const std::string out = StringTools::Replace(in, "honk", "honka");
// Verify
Assert::AreEqual(out.c_str(), "honka honka honka honka honka honka honka honka");
return;
}
// Tests that replacing succesive findings works
TEST_METHOD(Replace_Successive)
{
// Setup
const std::string in = "honkhonkhonkhonkhonkhonkhonkhonk";
// Exercise
const std::string out = StringTools::Replace(in, "honk", "hallery");
// Verify
Assert::AreEqual(out.c_str(), "halleryhalleryhalleryhalleryhalleryhalleryhalleryhallery");
return;
}
// Tests that if find.length() == 0, it returns just the input
TEST_METHOD(Find_Length0_Returns_Input)
{
// Setup
const std::string in = "Littled";
// Exercise
const std::string out = StringTools::Replace(in, "", "binger");
// Verify
Assert::AreEqual(out.c_str(), "Littled");
return;
}
};
// Verify
REQUIRE(out == "");
return;
}
// Tests that replacing a string to an empty string works
TEST_CASE(__FILE__"/Single_ReplaceToEmpty")
{
// Setup
const std::string in = "Squarepants";
// Exercise
const std::string out = StringTools::Replace(in, "Squarepants", "");
// Verify
REQUIRE(out == "");
return;
}
// Tests that replacing to a single char works
TEST_CASE(__FILE__"/Single_ReplaceToSingleChar")
{
// Setup
const std::string in = "Squarepants";
// Exercise
const std::string out = StringTools::Replace(in, "Squarepants", "i");
// Verify
REQUIRE(out == "i");
return;
}
// Tests that replacing to a single char works, passing a char
TEST_CASE(__FILE__"/Single_ReplaceToSingleChar_AsChar")
{
// Setup
const std::string in = "Oilbanger";
// Exercise
const std::string out = StringTools::Replace(in, "Oilbanger", 'i');
// Verify
REQUIRE(out == "i");
return;
}
// Tests that replacing the find to something longer works
TEST_CASE(__FILE__"/Single_ReplaceToLonger")
{
// Setup
const std::string in = "LittleDong";
// Exercise
const std::string out = StringTools::Replace(in, "Dong", "Binger");
// Verify
REQUIRE(out == "LittleBinger");
return;
}
// Tests that replacing a string to an empty string works
TEST_CASE(__FILE__"/Multiple_ReplaceToEmpty")
{
// Setup
const std::string in = "The fucking dogs are fucking eating the fucking chicken.";
// Exercise
const std::string out = StringTools::Replace(in, "fucking ", "");
// Verify
REQUIRE(out == "The dogs are eating the chicken.");
return;
}
// Tests that replacing to a single char works
TEST_CASE(__FILE__"/Multiple_ReplaceToSingleChar")
{
// Setup
const std::string in = "Oilbsmearynger, Bsmearyngerfsmearynger, Lsmearyttle brsmearyttle osmearyly sksmearyttle.";
// Exercise
const std::string out = StringTools::Replace(in, "smeary", "i");
// Verify
REQUIRE(out == "Oilbinger, Bingerfinger, Little brittle oily skittle.");
return;
}
// Tests that replacing to a single char works, passing a char
TEST_CASE(__FILE__"/Multiple_ReplaceToSingleChar_AsChar")
{
// Setup
const std::string in = "Oilbsmearynger, Bsmearyngerfsmearynger, Lsmearyttle brsmearyttle osmearyly sksmearyttle.";
// Exercise
const std::string out = StringTools::Replace(in, "smeary", 'i');
// Verify
REQUIRE(out == "Oilbinger, Bingerfinger, Little brittle oily skittle.");
return;
}
// Tests that replacing the find to something longer works
TEST_CASE(__FILE__"/Multiple_ReplaceToLonger")
{
// Setup
const std::string in = "honk honk honk honk honk honk honk honk";
// Exercise
const std::string out = StringTools::Replace(in, "honk", "hallery");
// Verify
REQUIRE(out == "hallery hallery hallery hallery hallery hallery hallery hallery");
return;
}
// Tests that the replacer ignores chars put in by the replacer
TEST_CASE(__FILE__"/ReplacerIgnoresReplaced")
{
// Setup
const std::string in = "honk honk honk honk honk honk honk honk";
// Exercise
const std::string out = StringTools::Replace(in, "honk", "honka");
// Verify
REQUIRE(out == "honka honka honka honka honka honka honka honka");
return;
}
// Tests that replacing successive findings works
TEST_CASE(__FILE__"/Replace_Successive")
{
// Setup
const std::string in = "honkhonkhonkhonkhonkhonkhonkhonk";
// Exercise
const std::string out = StringTools::Replace(in, "honk", "hallery");
// Verify
REQUIRE(out == "halleryhalleryhalleryhalleryhalleryhalleryhalleryhallery");
return;
}
// Tests that if find.length() == 0, it returns just the input
TEST_CASE(__FILE__"/Find_Length0_Returns_Input")
{
// Setup
const std::string in = "Littled";
// Exercise
const std::string out = StringTools::Replace(in, "", "binger");
// Verify
REQUIRE(out == "Littled");
return;
}

288
StringTools/Test/Upper.cpp
View File

@ -1,226 +1,72 @@
#include "CppUnitTest.h"
#include "../StringTools/StringTools.h"
#include <StringTools/StringTools.h>
#include "Catch2.h"
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
namespace _StringTools
// Tests that uppering an empty string returns an empty string
TEST_CASE(__FILE__"/EmptyString", "[UPPER]")
{
TEST_CLASS(_Upper)
{
public:
// Setup
const std::string in = "";
// Tests that uppering an empty string returns an empty string
TEST_METHOD(EmptyString)
{
// Setup
const std::string in = "";
// Exercise
const std::string out = StringTools::Upper(in);
// Exercise
const std::string out = StringTools::Upper(in);
// Verify
Assert::AreEqual("", out.c_str());
return;
}
// Tests that uppering a string without any letters returns an itself
TEST_METHOD(Symbols)
{
// Setup
const std::string in = "66! _-\n*";
// Exercise
const std::string out = StringTools::Upper(in);
// Verify
Assert::AreEqual("66! _-\n*", out.c_str());
return;
}
// Tests that uppering a string of uppercase letters returns itself
TEST_METHOD(AlreadyUppered)
{
// Setup
const std::string in = "UGHAREYOUSERIOUS";
// Exercise
const std::string out = StringTools::Upper(in);
// Verify
Assert::AreEqual("UGHAREYOUSERIOUS", out.c_str());
return;
}
// Tests that uppering a string of lowercase letters returns the uppercase version
TEST_METHOD(Lowercase)
{
// Setup
const std::string in = "ughareyouserious";
// Exercise
const std::string out = StringTools::Upper(in);
// Verify
Assert::AreEqual("UGHAREYOUSERIOUS", out.c_str());
return;
}
// Tests that uppering a string of uppercase, lowercase letters and symbols returns the uppercase version
TEST_METHOD(Mixed)
{
// Setup
const std::string in = "Ugh, Are You Serious?! DON'T do that!!!";
// Exercise
const std::string out = StringTools::Upper(in);
// Verify
Assert::AreEqual("UGH, ARE YOU SERIOUS?! DON'T DO THAT!!!", out.c_str());
return;
}
// Tests that uppering already uppered umlautes returns itself
TEST_METHOD(Umlautes_already_upper_a)
{
// Setup
const std::string in = "ÄÁÀÂ";
// Exercise
const std::string out = StringTools::Upper(in);
// Verify
Assert::AreEqual("ÄÁÀÂ", out.c_str());
}
// Tests that uppering uppercase umlautes returns the upper umlautes
TEST_METHOD(Umlautes_upper_a)
{
// Setup
const std::string in = "äáàâ";
// Exercise
const std::string out = StringTools::Upper(in);
// Verify
Assert::AreEqual("ÄÁÀÂ", out.c_str());
}
// Tests that uppering already uppered umlautes returns itself
TEST_METHOD(Umlautes_already_upper_e)
{
// Setup
const std::string in = "ÉÈÊ";
// Exercise
const std::string out = StringTools::Upper(in);
// Verify
Assert::AreEqual("ÉÈÊ", out.c_str());
}
// Tests that uppering uppercase umlautes returns the upper umlautes
TEST_METHOD(Umlautes_upper_e)
{
// Setup
const std::string in = "éèê";
// Exercise
const std::string out = StringTools::Upper(in);
// Verify
Assert::AreEqual("ÉÈÊ", out.c_str());
}
// Tests that uppering already uppered umlautes returns itself
TEST_METHOD(Umlautes_already_upper_u)
{
// Setup
const std::string in = "ÜÚÙÛ";
// Exercise
const std::string out = StringTools::Upper(in);
// Verify
Assert::AreEqual("ÜÚÙÛ", out.c_str());
}
// Tests that uppering uppercase umlautes returns the upper umlautes
TEST_METHOD(Umlautes_upper_u)
{
// Setup
const std::string in = "üúùû";
// Exercise
const std::string out = StringTools::Upper(in);
// Verify
Assert::AreEqual("ÜÚÙÛ", out.c_str());
}
// Tests that uppering already uppered umlautes returns itself
TEST_METHOD(Umlautes_already_upper_o)
{
// Setup
const std::string in = "ÖÓÒÔ";
// Exercise
const std::string out = StringTools::Upper(in);
// Verify
Assert::AreEqual("ÖÓÒÔ", out.c_str());
}
// Tests that uppering uppercase umlautes returns the upper umlautes
TEST_METHOD(Umlautes_upper_o)
{
// Setup
const std::string in = "öóòô";
// Exercise
const std::string out = StringTools::Upper(in);
// Verify
Assert::AreEqual("ÖÓÒÔ", out.c_str());
}
// Tests that lowering already lowered umlautes returns itself
TEST_METHOD(Umlautes_already_upper_i)
{
// Setup
const std::string in = "ÍÌÎ";
// Exercise
const std::string out = StringTools::Upper(in);
// Verify
Assert::AreEqual("ÍÌÎ", out.c_str());
}
// Tests that lowering uppercase umlautes returns the lowered umlautes
TEST_METHOD(Umlautes_upper_i)
{
// Setup
const std::string in = "íìî";
// Exercise
const std::string out = StringTools::Upper(in);
// Verify
Assert::AreEqual("ÍÌÎ", out.c_str());
}
// Tests that uppering a string of uppercase, lowercase letters and symbols returns the lowercase version, even with umlauts
TEST_METHOD(Mixed_with_umlautes)
{
// Setup
const std::string in = "Ügh, Àrä Yóü Serîöûs?! DÒN'T DÔ THÄT!!!";
// Exercise
const std::string out = StringTools::Upper(in);
// Verify
Assert::AreEqual("ÜGH, ÀRÄ YÓÜ SERÎÖÛS?! DÒN'T DÔ THÄT!!!", out.c_str());
return;
}
};
// Verify
REQUIRE(out == "");
return;
}
// Tests that uppering a string without any letters returns itself
TEST_CASE(__FILE__"/Symbols", "[UPPER]")
{
// Setup
const std::string in = "66! _-\n*";
// Exercise
const std::string out = StringTools::Upper(in);
// Verify
REQUIRE(out == "66! _-\n*");
return;
}
// Tests that uppering a string of uppercase letters returns itself
TEST_CASE(__FILE__"/AlreadyUppered", "[UPPER]")
{
// Setup
const std::string in = "UGHAREYOUSERIOUS";
// Exercise
const std::string out = StringTools::Upper(in);
// Verify
REQUIRE(out == "UGHAREYOUSERIOUS");
return;
}
// Tests that uppering a string of lowercase letters returns the uppercase version
TEST_CASE(__FILE__"/Lowercase", "[UPPER]")
{
// Setup
const std::string in = "ughareyouserious";
// Exercise
const std::string out = StringTools::Upper(in);
// Verify
REQUIRE(out == "UGHAREYOUSERIOUS");
return;
}
// Tests that uppering a string of uppercase, lowercase letters and symbols returns the uppercase version
TEST_CASE(__FILE__"/Mixed", "[UPPER]")
{
// Setup
const std::string in = "Ugh, Are You Serious?! DON'T do that!!!";
// Exercise
const std::string out = StringTools::Upper(in);
// Verify
REQUIRE(out == "UGH, ARE YOU SERIOUS?! DON'T DO THAT!!!");
return;
}

2
StringTools/Test/main.cpp Normal file
View File

@ -0,0 +1,2 @@
#define CATCH_CONFIG_MAIN
#include "Catch2.h"

21
StringTools/Test/test.cpp Normal file
View File

@ -0,0 +1,21 @@
#define CATCH_CONFIG_MAIN
#include "Catch2.h"
int Add(int a, int b)
{
return a+b;
}
TEST_CASE("Add works with zeroes", "[add]")
{
REQUIRE(Add(0, 0) == 0);
REQUIRE(Add(5, 0) == 5);
REQUIRE(Add(0, 5) == 5);
}
TEST_CASE("Add works with negatives", "[add]")
{
REQUIRE(Add(-5, 0) == -5);
REQUIRE(Add(0, -5) == -5);
REQUIRE(Add(-5, -5) == -10);
}