Good Title

tdd_intro/homework/01_leap_year/test.cpp

@@ -13,3 +13,46 @@ If your language provides a method in the standard library that does this look-u
 */
 
 #include <gtest/gtest.h>
+
+bool IsLeap(size_t year)
+{
+    if (year % 400 != 0 && year % 100 == 0)
+    {
+        return false;
+    }
+
+    return year % 4 == 0;
+}
+
+TEST(IsLeap, ReturnFalseForOddYears)
+{
+    ASSERT_FALSE(IsLeap(1901));
+}
+
+TEST(IsLeap, ReturnTrueIfDevisibleBy400)
+{
+    ASSERT_TRUE(IsLeap(1600));
+}
+
+TEST(IsLeap, ReturnTrueIfDevisibleBy4AndNotDevisibleBy100)
+{
+    ASSERT_TRUE(IsLeap(1804));
+}
+
+TEST(IsLeap, ReturnFalseIfDevisibleBy100AndNotDivisibleBy400)
+{
+    ASSERT_FALSE(IsLeap(1900));
+}
+
+TEST(IsLeap, AcceptanceTest)
+{
+    ASSERT_TRUE(IsLeap(4));
+    ASSERT_TRUE(IsLeap(1604));
+    ASSERT_TRUE(IsLeap(400));
+    ASSERT_TRUE(IsLeap(2000));
+
+    ASSERT_FALSE(IsLeap(1));
+    ASSERT_FALSE(IsLeap(1701));
+    ASSERT_FALSE(IsLeap(1700));
+    ASSERT_FALSE(IsLeap(1900));
+}

tdd_intro/homework/02_ternary_numbers/test.cpp

@@ -1,4 +1,5 @@
 #include <gtest/gtest.h>
+#include <cctype>
 
 /*
 Convert a ternary number, represented as a string (e.g. '102012'), to its decimal equivalent using first principles.
@@ -16,3 +17,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.
 */
+
+int ConvertToTernary(const std::string& number)
+{
+    const size_t inputSize = number.size();
+    size_t result = 0;
+
+    for (size_t i = 1; i <= inputSize; ++i)
+    {
+        const char current = number[inputSize - i];
+        if (!isdigit(current))
+        {
+            return 0;
+        }
+
+        std::string curCharStr;
+        curCharStr += current;
+
+        int curNumber = 0;
+        if ((curNumber = std::atoi(curCharStr.c_str())) > 2)
+        {
+            return 0;
+        }
+
+        result += static_cast<size_t>(pow(3, i - 1) * curNumber);
+    }
+
+    return result;
+}
+
+TEST (ConvertToTernary, ReturnsZeroIfPassInvalidParameter)
+{
+    EXPECT_EQ(ConvertToTernary("a"), 0);
+}
+
+TEST (ConvertToTernary, SuccesfullyConvertStringWithSizeEquals1)
+{
+    EXPECT_EQ(ConvertToTernary("1"), 1);
+}
+
+TEST (ConvertToTernary, SuccesfullyConvertStringWithSizeEquals1_2)
+{
+    EXPECT_EQ(ConvertToTernary("2"), 2);
+}
+
+TEST (ConvertToTernary, SuccesfullyConvertStringWithSizeEquals2)
+{
+    EXPECT_EQ(ConvertToTernary("10"), 3);
+}
+
+TEST (ConvertToTernary, ReturnsZeroIfPassInvalidParameter_2)
+{
+    EXPECT_EQ(ConvertToTernary("1a2b"), 0);
+}
+
+TEST (ConvertToTernary, ReturnsZeroIfPassInvalidParameter_3)
+{
+    EXPECT_EQ(ConvertToTernary("53"), 0);
+}
+
+TEST (ConvertToTernary, AcceptanceTests)
+{
+    EXPECT_EQ(ConvertToTernary("202"), 20);
+    EXPECT_EQ(ConvertToTernary("2201"), 73);
+    EXPECT_EQ(ConvertToTernary("12"), 5);
+
+    EXPECT_EQ(ConvertToTernary("abc"), 0);
+    EXPECT_EQ(ConvertToTernary("d1hj"), 0);
+
+    EXPECT_EQ(ConvertToTernary("4356"), 0);
+    EXPECT_EQ(ConvertToTernary("7"), 0);
+
+    EXPECT_EQ(ConvertToTernary("a31"), 0);
+    EXPECT_EQ(ConvertToTernary("zr5"), 0);
+}

tdd_intro/homework/03_bank_ocr/test.cpp

@@ -195,3 +195,207 @@ const Display s_display123456789 = { "    _  _     _  _  _  _  _ ",
                                      "  | _| _||_||_ |_   ||_||_|",
                                      "  ||_  _|  | _||_|  ||_| _|"
 };
+
+/*
+ * test list :
+ * throws if empty file
+ * throws if not each line 27 long
+ * throws if line count mod 3 != 0
+ * throws in case of invalid number form
+ * successful conversation (one id)
+ * successful conversation (two id's)
+ * successful conversation (unlimited size)
+*/
+
+class EmptyFileError : public std::runtime_error
+{
+public:
+    EmptyFileError(const char* what)
+        : std::runtime_error(what)
+    {}
+};
+
+class LenghtError : public std::runtime_error
+{
+public:
+    LenghtError(const char* what)
+        : std::runtime_error(what)
+    {}
+};
+
+class LineCountError : public std::runtime_error
+{
+public:
+    LineCountError(const char* what)
+        : std::runtime_error(what)
+    {}
+};
+
+class NumberFormatError : public std::runtime_error
+{
+public:
+    NumberFormatError(const char* what)
+        : std::runtime_error(what)
+    {}
+};
+
+std::vector<std::string> SplitByLines(const std::string& strToSplit)
+{
+    std::stringstream ss(strToSplit);
+    std::string item;
+    std::vector<std::string> splittedStrings;
+    while (std::getline(ss, item, '\n'))
+    {
+       if (item.size() != 27)
+       {
+           throw LenghtError("OOPS");
+       }
+
+       splittedStrings.push_back(item);
+    }
+    return splittedStrings;
+}
+
+bool operator == (const Digit& lhs, const Digit& rhs)
+{
+    bool equals = true;
+    for (size_t i = 0; i < 3; ++i)
+    {
+        equals = equals && lhs.lines[i] == rhs.lines[i];
+    }
+
+    return equals;
+}
+
+size_t GetDigit(const Digit& digit)
+{
+    if (digit == s_digit0)
+    {
+        return 0;
+    }
+    if (digit == s_digit1)
+    {
+        return 1;
+    }
+    if (digit == s_digit2)
+    {
+        return 2;
+    }
+    if (digit == s_digit3)
+    {
+        return 3;
+    }
+    if (digit == s_digit4)
+    {
+        return 4;
+    }
+    if (digit == s_digit5)
+    {
+        return 5;
+    }
+    if (digit == s_digit6)
+    {
+        return 6;
+    }
+    if (digit == s_digit7)
+    {
+        return 7;
+    }
+    if (digit == s_digit8)
+    {
+        return 8;
+    }
+    if (digit == s_digit9)
+    {
+        return 9;
+    }
+
+    throw NumberFormatError("OOPS");
+}
+std::string GetNumberFromThreeStrings(const std::string& first, const std::string& second, const std::string& third)
+{
+    std::stringstream stream;
+    size_t pos = 0;
+    while (pos < 27)
+    {
+        Digit digit;
+        digit.lines[0] = first.substr(pos, 3);
+        digit.lines[1] = second.substr(pos, 3);
+        digit.lines[2] = third.substr(pos, 3);
+        stream << GetDigit(digit);
+        pos += 3;
+    }
+
+    return stream.str();
+}
+
+std::vector<std::string> SplitByNumbers(const std::vector<std::string>& lines)
+{
+    std::vector<std::string> numbers;
+    for (size_t i = 0; i < lines.size() / 3; ++i)
+    {
+        std::string firstLine = lines[3*i];
+        std::string secondLine = lines[3*i + 1];
+        std::string thirdLine = lines[3*i + 2];
+        numbers.push_back(GetNumberFromThreeStrings(firstLine, secondLine, thirdLine));
+    }
+
+    return numbers;
+}
+
+std::vector<std::string> ParseFile(const std::string& file)
+{
+    if (file.empty())
+    {
+        throw EmptyFileError("empty file");
+    }
+
+    std::vector<std::string> lines = SplitByLines(file);
+
+    if (lines.size() % 3 != 0)
+    {
+        throw LineCountError("line count error");
+    }
+
+    return SplitByNumbers(lines);
+}
+
+TEST(ParseFile, ThrowsIfEmptyFile)
+{
+    ASSERT_THROW(ParseFile(""), EmptyFileError);
+}
+
+TEST(ParseFile, ThrowsIfNotEachLine27Long)
+{
+    ASSERT_THROW(ParseFile("abc"), LenghtError);
+}
+
+TEST(ParseFile, ThrowsIfLineCountMod3NotZero)
+{
+    std::string file(27, '_');
+    file = file + '\n' + file;
+    ASSERT_THROW(ParseFile(file), LineCountError);
+}
+
+TEST(SplitByNumbers, ThrowsInCaseOfInvalidNumberForm)
+{
+    std::string file(27, '_');
+    file = file + '\n' + file + '\n' + file;
+    std::vector<std::string> files {file, file, file};
+    ASSERT_THROW(SplitByNumbers(files), NumberFormatError);
+}
+
+TEST(SplitByNumbers, SuccessfulSplit)
+{
+    std::vector<std::string> lines = {s_display123456789.lines[0], s_display123456789.lines[1], s_display123456789.lines[2]};
+    auto result = SplitByNumbers(lines);
+    ASSERT_EQ(result.size(), 1);
+    ASSERT_EQ(result[0], "123456789");
+}
+
+TEST(ParseFile, SuccessfulParse)
+{
+    std::string file = s_display123456789.lines[0] + "\n" + s_display123456789.lines[1] + "\n" + s_display123456789.lines[2];
+    std::vector<std::string> result = ParseFile(file);
+    ASSERT_EQ(result[0], "123456789");
+}