Юнит-тесты: приложение, считающее количество слов с заданной буквой в текстовом файле через тестирование

#include <iostream>
#include <fstream>
#include <map>
 
using namespace std;
 
map<string, long long> split(const string& str, const string& delimiters);
long long substr_count_word(const string& haystack, const string& needle);
 
int main(int argc, char *argv[])
{
    string DIR = "D:\\1.txt";
    ifstream fin(DIR);
 
    string str;
    fin.seekg(0, ios::end);
    size_t size = fin.tellg();
 
    str.reserve(size);
    fin.seekg(0, ios::beg);
 
    str.assign((istreambuf_iterator<char>(fin)),
             istreambuf_iterator<char>());
 
    map<string, long long> test = {
        {"the",43},
        {"and",20},
        {"his",20},
        {"in",14},
        {"", 0}
    };
 
    for(auto it : test) {
        string needle = it.first;
 
        long long expected = it.second;
        long long actual =  substr_count_word(str, needle);
 
        if(expected == actual)
            cout << "needle = " << needle <<
                    ", expected = "  << expected
                 << ", actual = " << actual
                 << "\texpected == actual - TRUE" << endl;
        else
            cout << "needle = " << needle <<
                    ", expected = "  << expected
                 << ", actual = " << actual
                 << "\texpected != actual - FALSE" << endl;
    }
 
 
    return 0;
}
 
map<string, long long> split(const string& str, const string& delimiters) {
    if(str.empty()) return map<string, long long>();
    if(delimiters.empty()) return map<string, long long>();
 
    size_t lastPos = str.find_first_not_of(delimiters, 0);
    size_t pos = str.find_first_of(delimiters, lastPos);
 
    map<string, long long> tokens;
    while (string::npos != pos || string::npos != lastPos) {
        string token = str.substr(lastPos, pos - lastPos);
        tokens[token]++;
        lastPos = str.find_first_not_of(delimiters, pos);
        pos = str.find_first_of(delimiters, lastPos);
    }
 
    return tokens;
}
 
long long substr_count_word(const string& haystack, const string& needle) {
    if(haystack.empty()) return 0;
    if(needle.empty()) return 0;
 
    map<string, long long> words = split(haystack, " -,.;:!?\r\n\"");
    return words[needle];
}

#include <iostream>
#include <string>
 
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
 
namespace RenameMePls
{
    TEST_CLASS(ReaderTest)
    {
    public:
 
        static const std::string kFileWithOneWordPath = "one_word.txt";
        static const std::string kFileWithAlotOfWordsPath = "alot_of_word.txt";
        static const std::string kEmptyFilePath = "empty.txt";
        static const std::string kNoExistingPath = "not/existing.txt";
 
        TEST_METHOD(WhenFileContainsOneWordReadTextWillReturnStringWithThisWord)
        {
            Reader reader;
 
            auto returned_string = reader.ReadText(kFileWithOneWordPath);
 
            Assert::AreSame(kTheOnlyWordThatFileContains, returned_string);
        }
 
 
        TEST_METHOD(WhenFileContainsAlotOfWordsReadTextWillReturnStringWithAllThisWord)
        {
            Reader reader;
 
            auto returned_string = reader.ReadText(kFileWithAlotOfWordsPath);
 
            Assert::AreSame(kStringWithAlotOfWordsFromFile, returned_string);
        }
 
        TEST_METHOD(WhenFileIsEmptyReadTextWillReturnEmptyString)
        {
            Reader reader;
 
            auto returned_string = reader.ReadText(kEmptyFilePath);
 
            Assert::AreSame(kEmptyString, returned_string);
        }
 
        TEST_METHOD(WhenFileIsNotExistsByPathReadTextWillReturnEmptyString)
        {
            Reader reader;
 
            auto returned_string = reader.ReadText(kNoExistingPath);
 
            Assert::AreSame(kEmptyString, returned_string);
        }
 
    };
 
    TEST_CLASS(ACounterTest)
    {
    public:
 
        static const std::string kWordWithLetterA = "word_with_a";
        static const std::string kWordWithLetterB = "word_with_B";
        static const std::string kWordWithoutLetterA = "word_without_letter";
        static const std::string kTwoWordsWithLetterA =
            kWordWithLetterA + " " + kWordWithLetterA;
        static const std::string kThreeWordsOnltyTwoContainingLetterA =
            kTwoWordsWithLetterA + " " + kWordWithoutLetterA;
 
 
        TEST_METHOD(WhenTextContainsOneWordContaingLetterCountWordsWithLetterWillReturnOne)
        {
          Counter counter;
 
          auto number_of_words = conter.CountWordsWithLetter('a', kWordWithLetterA);
 
          Assert::AreSame(1, number_of_words);
        }
 
        TEST_METHOD(WhenTextContainsOneWordContaingLetterInUpperCaseCountWordsWithLetterWillReturnOne)
        {
          Counter counter;
 
          auto number_of_words = conter.CountWordsWithLetter('B', kWordWithLetterInUpperCaseB);
 
          Assert::AreSame(1, number_of_words);
        }
 
 
        TEST_METHOD(WhenTextContainsOneWordWithoutLetterCountWordsWithLetterWillReturnZero)
        {
          Counter counter;
 
          auto number_of_words = conter.CountWordsWithLetter('a', kWordWithoutLetterA);
 
          Assert::AreSame(0, number_of_words);
        }
 
        TEST_METHOD(WhenTextContainsTwoWordsContaingLetterCountWordsWithLetterWillReturnTwo)
        {
          Counter counter;
 
          auto number_of_words = conter.CountWordsWithLetter('a', kTwoWordsWithLetterA);
 
          Assert::AreSame(2, number_of_words);
        }
 
        TEST_METHOD(WhenTextContainsThreeWordsAnOnlyTwoContaingLetterCountWordsWithLetterWillReturnTwo)
        {
          Counter counter;
 
          auto number_of_words = conter.CountWordsWithLetter('a', kThreeWordsOnltyTwoContainingLetterA);
 
          Assert::AreSame(2, number_of_words);
        }
 
        TEST_METHOD(WhenTextContainsThreeWordsAnOnlyTwoContaingLetterCountWordsWithLetterWillReturnTwo)
        {
          Counter counter;
 
          auto number_of_words = conter.CountWordsWithLetter('a', kThreeWordsOnltyTwoContainingLetterA);
 
          Assert::AreSame(2, number_of_words);
        }
 
 
    };
}

#include <iostream>
#include <fstream>
#include <map>
#include <gtest/gtest.h>
 
#include "functions.h"
 
using namespace std;
 
 
TEST(test001, test)
{
    string DIR = "D:\\1.txt";
    ifstream fin(DIR);
 
    string str;
    fin.seekg(0, ios::end);
    size_t size = fin.tellg();
 
    str.reserve(size);
    fin.seekg(0, ios::beg);
 
    str.assign((istreambuf_iterator<char>(fin)),
               istreambuf_iterator<char>());
 
 
    map<string, long long> test = {
        {"the",62},
        {"and",26},
        {"his",22},
        {"in",54},
        {"", 0}
    };
 
    long long expected = 0;
    long long actual =  multi_substr_count("", "");
    ASSERT_EQ(expected, actual);
 
    for(auto it : test) {
        string needle = it.first;
 
        long long expected = it.second;
        long long actual =  multi_substr_count(str, needle);
 
        ASSERT_EQ(expected, actual);
    }
}
 
 
GTEST_API_ int main(int argc, char **argv){
    testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}