04 weather client

tdd_intro/demo/01_bob/test.cpp

@@ -10,3 +10,45 @@ He answers 'Whatever.' to anything else.
 #include <gtest/gtest.h>
 #include <string>
 
+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"));
+}

tdd_intro/demo/01_fizz_buzz/test.cpp

@@ -9,3 +9,64 @@
  * a multiple of 15 = FizzBuzz
  * any other number = <nothing>
 */
+
+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));
+}

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 <gtest/gtest.h>
+typedef std::vector<std::string> 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"})));
+}

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"));
+}