diff --git a/tdd_intro/demo/01_bob/test.cpp b/tdd_intro/demo/01_bob/test.cpp index dc9e42f..5840552 100644 --- a/tdd_intro/demo/01_bob/test.cpp +++ b/tdd_intro/demo/01_bob/test.cpp @@ -10,3 +10,45 @@ He answers 'Whatever.' to anything else. #include #include +const std::string g_tellBobAnswer = "Sure"; +const std::string g_yellBobAnswer = "Whoa, chill out!"; +const std::string g_emptyBobAnswer = "Fine. Be that way!"; +const std::string g_defaultBobAnswer = "Whatever."; + +std::string CallBob(const std::string& str) +{ + if (str.empty()) + { + return g_emptyBobAnswer; + } + if (str.back() == '!') + { + return g_yellBobAnswer; + } + else if (str.back() == '?') + { + return g_tellBobAnswer; + } + + return g_defaultBobAnswer; +} + +TEST(bob, AnswerSureOnQuestion) +{ + ASSERT_EQ(g_tellBobAnswer, CallBob("Are you ok?")); +} + +TEST(bob, AnswerChillOnYell) +{ + ASSERT_EQ(g_yellBobAnswer, CallBob("Yell!!!!")); +} + +TEST(bob, AnswerOnEmptyString) +{ + ASSERT_EQ(g_emptyBobAnswer, CallBob("")); +} + +TEST(bob, AnswerOnAnythingElse) +{ + ASSERT_EQ(g_defaultBobAnswer, CallBob("Anything else")); +} diff --git a/tdd_intro/demo/01_fizz_buzz/test.cpp b/tdd_intro/demo/01_fizz_buzz/test.cpp index 582ee51..49fa275 100644 --- a/tdd_intro/demo/01_fizz_buzz/test.cpp +++ b/tdd_intro/demo/01_fizz_buzz/test.cpp @@ -9,3 +9,64 @@ * a multiple of 15 = FizzBuzz * any other number = */ + +const std::string g_fizzString = "Fizz"; +const std::string g_buzzString = "Buzz"; +const std::string g_fizzBuzzString = "FizzBuzz"; + +std::string FizzBuzz(int num) +{ + std::string fizzBuzzStr; + + if (num % 3 == 0) + { + fizzBuzzStr = g_fizzString; + } + + if (num % 5 == 0) + { + fizzBuzzStr += g_buzzString; + } + + return fizzBuzzStr; +} + + +TEST(FizzBuzzTest, Fizz) +{ + EXPECT_EQ(g_fizzString, FizzBuzz(3)); +} + +TEST(FizzBuzzTest, Buzz) +{ + EXPECT_EQ(g_buzzString, FizzBuzz(5)); +} + +TEST(FizzBuzzTest, Fizz6) +{ + EXPECT_EQ(g_fizzString, FizzBuzz(6)); +} + +TEST(FizzBuzzTest, Buzz10) +{ + EXPECT_EQ(g_buzzString, FizzBuzz(10)); +} + +TEST(FizzBuzzTest, FizzBuzz) +{ + EXPECT_EQ(g_fizzBuzzString, FizzBuzz(15)); +} + +TEST(FizzBuzzTest, FizzBuzzEmpty) +{ + EXPECT_EQ("", FizzBuzz(1)); +} + +TEST(FizzBuzzTest, Acceptance) +{ + EXPECT_EQ(g_buzzString, FizzBuzz(35)); + EXPECT_EQ(g_fizzString, FizzBuzz(66)); + EXPECT_EQ(g_fizzBuzzString, FizzBuzz(45)); + EXPECT_EQ("", FizzBuzz(17)); + EXPECT_EQ("", FizzBuzz(-23)); +} diff --git a/tdd_intro/demo/02_anagram/test.cpp b/tdd_intro/demo/02_anagram/test.cpp index 4d65537..1c4d8e6 100644 --- a/tdd_intro/demo/02_anagram/test.cpp +++ b/tdd_intro/demo/02_anagram/test.cpp @@ -6,3 +6,76 @@ Given "listen" and a list of candidates like "enlists" "google" "inlets" "banana _from http://exercism.io/_ */ #include +typedef std::vector strings; + +bool IsAnagramPresent(std::string first, std::string second) +{ + std::sort(first.begin(), first.end()); + std::sort(second.begin(), second.end()); + + return first == second; +} + +strings ReturnAnagrams(std::string target, const strings& variants) +{ + strings anagrams; + for (std::string variant : variants) + { + if (IsAnagramPresent(target, variant)) + { + anagrams.push_back(variant); + } + } + + return anagrams; +} + +TEST (anagrams, emptyString) +{ + EXPECT_TRUE(IsAnagramPresent("", "")); +} + +TEST(anagrams, notEqualWords) +{ + EXPECT_FALSE(IsAnagramPresent("word", "lock")); +} + +TEST(anagrams, anagram) +{ + EXPECT_TRUE(IsAnagramPresent("listen", "inlets")); +} + +TEST(anagrams, returnEmptyString) +{ + EXPECT_EQ(strings(), ReturnAnagrams("", strings())); +} + +TEST(anagrams, singleAnagram) +{ + EXPECT_EQ( strings({"inlets"}), ReturnAnagrams("listen", strings({"inlets"}))); +} + +TEST(anagrams, otherSignleAnagram) +{ + EXPECT_EQ( strings({"letsin"}), ReturnAnagrams("listen", strings({"letsin"}))); +} + +TEST(anagrams, signleNotAnagram) +{ + EXPECT_EQ( strings(), ReturnAnagrams("listen", strings({"letiin"}))); +} + +TEST(anagrams, multipleWordsOnaAnagram) +{ + EXPECT_EQ(strings({"inlets"}), ReturnAnagrams("listen", strings({"inlets", "google"}))); +} + +TEST(anagrams, multipleAnagrams) +{ + EXPECT_EQ(strings({"inlets", "inelts"}), ReturnAnagrams("listen", strings({"inlets", "inelts"}))); +} + +TEST(anagrams, multipleAnagramsNotInOrder) +{ + EXPECT_EQ(strings({"inelts", "inlets"}), ReturnAnagrams("listen", strings({"inlets", "inelts"}))); +} diff --git a/tdd_intro/homework/02_ternary_numbers/test.cpp b/tdd_intro/homework/02_ternary_numbers/test.cpp index 1750302..e75a61a 100644 --- a/tdd_intro/homework/02_ternary_numbers/test.cpp +++ b/tdd_intro/homework/02_ternary_numbers/test.cpp @@ -16,3 +16,77 @@ The last place in a ternary number is the 1's place. The second to last is the 3 If your language provides a method in the standard library to perform the conversion, pretend it doesn't exist and implement it yourself. */ + +/* + * 1) 0 test + * 2) 1 test + * 3) 2 test + * 4) invalid digit test + * 5) Multiple digits tests + * 6) Invalid multiple digits tests + * 7) Acceptence test + */ + +bool TernaryNumber(int number) +{ + return number < 3; +} + +int ConvertTernaryNumbers(const std::string &number) +{ + int sum = 0; + for (int index = 0; index < number.size(); ++index) + { + int numberValue = std::stoi(std::string(1, number[number.size() - 1 - index])); + if (!TernaryNumber(numberValue)) + { + return 0; + } + sum += numberValue * std::pow(3, index); + } + + return sum; +} + +TEST(TernaryNumbers, ZeroTest) +{ + ASSERT_TRUE(TernaryNumber(0)); +} + +TEST(TernaryNumbers, CheckOne) +{ + ASSERT_TRUE(TernaryNumber(1)); +} + +TEST(TernaryNumbers, CheckTwo) +{ + ASSERT_TRUE(TernaryNumber(2)); +} + +TEST(TernaryNumbers, InvalidDigit) +{ + ASSERT_FALSE(TernaryNumber(3)); +} + +TEST(TernaryNumbers, MultipleDigits) +{ + ASSERT_EQ(0, ConvertTernaryNumbers("00")); +} + +TEST(TernaryNumbers, MultipleDigits111) +{ + ASSERT_EQ(13, ConvertTernaryNumbers("111")); +} + +TEST(TernaryNumbers, InvalidMultipleDigits) +{ + ASSERT_EQ(0, ConvertTernaryNumbers("113")); +} + +TEST(TernaryNumbers, Acceptance) +{ + ASSERT_EQ(0, ConvertTernaryNumbers("123")); + ASSERT_EQ(16, ConvertTernaryNumbers("121")); + ASSERT_EQ(439, ConvertTernaryNumbers("121021")); + ASSERT_EQ(597871, ConvertTernaryNumbers("1010101010101")); +} diff --git a/tdd_intro/homework/06_coffee/test.cpp b/tdd_intro/homework/06_coffee/test.cpp index cc1d534..df1aee6 100644 --- a/tdd_intro/homework/06_coffee/test.cpp +++ b/tdd_intro/homework/06_coffee/test.cpp @@ -14,9 +14,27 @@ We have 2 possible sizes of the cup: Implement worked coffee machine using ISourceOfIngredients to controll the process of coffee production. */ +/* + * 1) Americano/little cup test + * 2) Americano/big cup test + * 3) cappuccino/little cup test + * 4) cappuccino/big cup test + * 5) latte/little cup test + * 6) latte/big cup test + * 7) marochino/little cup test + * 8) marochino/big cup test + * 9) marochino ingredients order test + * + * Arch: + * 1) CoffeeMachine class + * 2) enum CoffeeCup + */ + #include #include +using namespace testing; + class ISourceOfIngredients { public: @@ -30,3 +48,183 @@ class ISourceOfIngredients virtual void AddChocolate(int gram) = 0; virtual void AddCream(int gram) = 0; }; + +class MockSourceOfIngridients : public ISourceOfIngredients +{ +public: + MOCK_METHOD1(SetCupSize, void(int)); + MOCK_METHOD2(AddWater, void(int, int)); + MOCK_METHOD1(AddSugar, void(int)); + MOCK_METHOD1(AddCoffee, void(int)); + MOCK_METHOD1(AddMilk, void(int)); + MOCK_METHOD1(AddMilkFoam, void(int)); + MOCK_METHOD1(AddChocolate, void(int)); + MOCK_METHOD1(AddCream, void(int)); +}; + +enum CoffeeCupSize +{ + LittleCup = 100, + BigCup = 140, +}; + +enum CoffeeType +{ + Americano, + Cappuccino, + Latte, + Mocachino, +}; + +class CoffeeMachine +{ +public: + CoffeeMachine(ISourceOfIngredients *source) : m_source(source) + { + } + + void MakeCoffee(CoffeeType type, CoffeeCupSize size) + { + m_source->SetCupSize(size); + + switch (type) + { + case Americano: + m_source->AddWater(size / 2, 60); + m_source->AddCoffee(size / 2); + break; + + case Cappuccino: + m_source->AddMilk(size / 3); + m_source->AddCoffee(size / 3); + m_source->AddMilkFoam(size / 3); + break; + + case Latte: + m_source->AddMilk(size / 4); + m_source->AddCoffee(size / 2); + m_source->AddMilkFoam(size / 4); + break; + + case Mocachino: + m_source->AddChocolate(size / 4); + m_source->AddCoffee(size / 4); + m_source->AddMilkFoam(size / 4); + break; + + default: + break; + } + } + +private: + ISourceOfIngredients *m_source; +}; + +void CheckAmericano(CoffeeCupSize size) +{ + MockSourceOfIngridients mock; + CoffeeMachine machine(&mock); + + EXPECT_CALL(mock, SetCupSize(size)).Times(1); + EXPECT_CALL(mock, AddWater(size / 2, 60)).Times(1); + EXPECT_CALL(mock, AddCoffee(size / 2)).Times(1); + + machine.MakeCoffee(Americano, size); +} + +void CheckCappucino(CoffeeCupSize size) +{ + MockSourceOfIngridients mock; + CoffeeMachine machine(&mock); + + EXPECT_CALL(mock, SetCupSize(size)).Times(1); + EXPECT_CALL(mock, AddMilk(size / 3)).Times(1); + EXPECT_CALL(mock, AddCoffee(size / 3)).Times(1); + EXPECT_CALL(mock, AddMilkFoam(size / 3)).Times(1); + + machine.MakeCoffee(Cappuccino, size); +} + +void CheckLatte(CoffeeCupSize size) +{ + MockSourceOfIngridients mock; + CoffeeMachine machine(&mock); + + EXPECT_CALL(mock, SetCupSize(size)).Times(1); + EXPECT_CALL(mock, AddMilk(size / 4)).Times(1); + EXPECT_CALL(mock, AddCoffee(size / 2)).Times(1); + EXPECT_CALL(mock, AddMilkFoam(size / 4)).Times(1); + + machine.MakeCoffee(Latte, size); +} + +void CheckMocachino(CoffeeCupSize size) +{ + MockSourceOfIngridients mock; + CoffeeMachine machine(&mock); + + EXPECT_CALL(mock, SetCupSize(size)).Times(1); + EXPECT_CALL(mock, AddChocolate(size / 4)).Times(1); + EXPECT_CALL(mock, AddCoffee(size / 4)).Times(1); + EXPECT_CALL(mock, AddMilkFoam(size / 4)).Times(1); + + machine.MakeCoffee(Mocachino, size); +} + +TEST(Coffee, AmericanoLittleCup) +{ + CheckAmericano(LittleCup); +} + +TEST(Coffee, AmericanoBigCup) +{ + CheckAmericano(BigCup); +} + +TEST(Coffee, CappuccinoLittleCup) +{ + CheckCappucino(LittleCup); +} + +TEST(Coffee, CappuccinoBigCup) +{ + CheckCappucino(BigCup); +} + +TEST(Coffee, LatteLittleCup) +{ + CheckLatte(LittleCup); +} + +TEST(Coffee, LatteBigCup) +{ + CheckLatte(BigCup); +} + +TEST(Coffee, MocachinoLittleCup) +{ + CheckMocachino(LittleCup); +} + +TEST(Coffee, MocachinoBigCup) +{ + CheckMocachino(BigCup); +} + +TEST(Coffee, MocachinoLittleCupSequence) +{ + MockSourceOfIngridients mock; + CoffeeMachine machine(&mock); + + { + InSequence s; + + EXPECT_CALL(mock, SetCupSize(LittleCup)).Times(1); + EXPECT_CALL(mock, AddChocolate(LittleCup / 4)).Times(1); + EXPECT_CALL(mock, AddCoffee(LittleCup / 4)).Times(1); + EXPECT_CALL(mock, AddMilkFoam(LittleCup / 4)).Times(1); + } + + machine.MakeCoffee(Mocachino, LittleCup); +} diff --git a/tdd_intro/homework/homework.pro b/tdd_intro/homework/homework.pro index cf6c01b..07506ca 100644 --- a/tdd_intro/homework/homework.pro +++ b/tdd_intro/homework/homework.pro @@ -1,6 +1,7 @@ TEMPLATE = subdirs SUBDIRS += \ + 00_intro \ 01_leap_year \ 02_ternary_numbers \ 03_bank_ocr \