Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

FIX REVERT Чернова Наталья. Задача 1. Вариант 24. Подсчет числа слов в строке #751

Closed
wants to merge 17 commits into from
Closed

FIX REVERT Чернова Наталья. Задача 1. Вариант 24. Подсчет числа слов в строке #751

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
17 commits
Select commit Hold shift + click to select a range
e0788a1
Create task
ChernovaNatalya Nov 2, 2024
456ab4a
try1
ChernovaNatalya Nov 2, 2024
c01ded9
try2
ChernovaNatalya Nov 2, 2024
606c7a6
try3
ChernovaNatalya Nov 3, 2024
efb537f
try4
ChernovaNatalya Nov 3, 2024
7b8dd32
fix tests
ChernovaNatalya Nov 6, 2024
3f8fa63
add suggested
ChernovaNatalya Nov 6, 2024
8a6a711
fix errors
ChernovaNatalya Nov 6, 2024
21e5152
fix empty string
ChernovaNatalya Nov 7, 2024
bedc28d
fix clang tidy
ChernovaNatalya Nov 7, 2024
fd36a6b
fix requested changes
ChernovaNatalya Nov 9, 2024
e726a04
try 1
ChernovaNatalya Nov 10, 2024
6fd5ed6
fix revert
ChernovaNatalya Dec 24, 2024
0710f12
fix revert1
ChernovaNatalya Dec 24, 2024
2d57739
Merge pull request #1 from ChernovaNatalya/try
ChernovaNatalya Dec 24, 2024
193e52e
Update ops_mpi.cpp
ChernovaNatalya Dec 24, 2024
6f3dd71
change
ChernovaNatalya Dec 29, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
352 changes: 352 additions & 0 deletions tasks/mpi/chernova_n_word_count/func_tests/main.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,352 @@
#include <gtest/gtest.h>

#include <boost/mpi/communicator.hpp>
#include <boost/mpi/environment.hpp>
#include <vector>

#include "mpi/chernova_n_word_count/include/ops_mpi.hpp"

std::vector<char> generateWords(int k) {
const std::string words[] = {"one", "two", "three"};

std::string result;
int j = words->size();

for (int i = 0; i < k; ++i) {
result += words[rand() % (j)];
if (i < k - 1) {
result += ' ';
}
}

return std::vector<char>(result.begin(), result.end());
}
int k = 50;
std::vector<char> testDataParallel = generateWords(k);

TEST(chernova_n_word_count_mpi, Test_empty_string) {
boost::mpi::communicator world;
std::vector<char> in = {};
std::vector<int> out(1, 0);

std::shared_ptr<ppc::core::TaskData> taskDataParallel = std::make_shared<ppc::core::TaskData>();

if (world.rank() == 0) {
taskDataParallel->inputs.emplace_back(reinterpret_cast<uint8_t *>(const_cast<char *>(in.data())));
taskDataParallel->inputs_count.emplace_back(in.size());
taskDataParallel->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
taskDataParallel->outputs_count.emplace_back(out.size());
}
chernova_n_word_count_mpi::TestMPITaskParallel testTaskParallel(taskDataParallel);
ASSERT_TRUE(testTaskParallel.validation());
testTaskParallel.pre_processing();
testTaskParallel.run();
testTaskParallel.post_processing();
if (world.rank() == 0) {
std::vector<int> referenceWordCount(1, 0);
std::shared_ptr<ppc::core::TaskData> taskDataSequential = std::make_shared<ppc::core::TaskData>();

taskDataSequential->inputs.emplace_back(reinterpret_cast<uint8_t *>(const_cast<char *>(in.data())));
taskDataSequential->inputs_count.emplace_back(in.size());
taskDataSequential->outputs.emplace_back(reinterpret_cast<uint8_t *>(referenceWordCount.data()));
taskDataSequential->outputs_count.emplace_back(referenceWordCount.size());

chernova_n_word_count_mpi::TestMPITaskSequential testTaskSequential(taskDataSequential);
ASSERT_TRUE(testTaskSequential.validation());
testTaskSequential.pre_processing();
testTaskSequential.run();
testTaskSequential.post_processing();

ASSERT_EQ(out[0], referenceWordCount[0]);
}
}

TEST(chernova_n_word_count_mpi, Test_five_words) {
boost::mpi::communicator world;
std::vector<char> in;
std::string testString = "This is a test phrase";
in.resize(testString.size());
std::copy(testString.begin(), testString.end(), in.begin());
std::vector<int> out(1, 0);

std::shared_ptr<ppc::core::TaskData> taskDataParallel = std::make_shared<ppc::core::TaskData>();

if (world.rank() == 0) {
taskDataParallel->inputs.emplace_back(reinterpret_cast<uint8_t *>(const_cast<char *>(in.data())));
taskDataParallel->inputs_count.emplace_back(in.size());
taskDataParallel->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
taskDataParallel->outputs_count.emplace_back(out.size());
}

chernova_n_word_count_mpi::TestMPITaskParallel testTaskParallel(taskDataParallel);
ASSERT_TRUE(testTaskParallel.validation());
testTaskParallel.pre_processing();
testTaskParallel.run();
testTaskParallel.post_processing();

if (world.rank() == 0) {
std::vector<int> referenceWordCount(1, 0);
std::shared_ptr<ppc::core::TaskData> taskDataSequential = std::make_shared<ppc::core::TaskData>();

taskDataSequential->inputs.emplace_back(reinterpret_cast<uint8_t *>(const_cast<char *>(in.data())));
taskDataSequential->inputs_count.emplace_back(in.size());
taskDataSequential->outputs.emplace_back(reinterpret_cast<uint8_t *>(referenceWordCount.data()));
taskDataSequential->outputs_count.emplace_back(referenceWordCount.size());

chernova_n_word_count_mpi::TestMPITaskSequential testTaskSequential(taskDataSequential);
ASSERT_TRUE(testTaskSequential.validation());
testTaskSequential.pre_processing();
testTaskSequential.run();
testTaskSequential.post_processing();

ASSERT_EQ(out[0], referenceWordCount[0]);
}
}

TEST(chernova_n_word_count_mpi, Test_five_words_with_space_and_hyphen) {
boost::mpi::communicator world;
std::vector<char> in;
std::string testString = "This is a - test phrase";
in.resize(testString.size());
std::copy(testString.begin(), testString.end(), in.begin());
std::vector<int> out(1, 0);

std::shared_ptr<ppc::core::TaskData> taskDataParallel = std::make_shared<ppc::core::TaskData>();

if (world.rank() == 0) {
taskDataParallel->inputs.emplace_back(reinterpret_cast<uint8_t *>(const_cast<char *>(in.data())));
taskDataParallel->inputs_count.emplace_back(in.size());
taskDataParallel->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
taskDataParallel->outputs_count.emplace_back(out.size());
}

chernova_n_word_count_mpi::TestMPITaskParallel testTaskParallel(taskDataParallel);
ASSERT_TRUE(testTaskParallel.validation());
testTaskParallel.pre_processing();
testTaskParallel.run();
testTaskParallel.post_processing();

if (world.rank() == 0) {
std::vector<int> referenceWordCount(1, 0);
std::shared_ptr<ppc::core::TaskData> taskDataSequential = std::make_shared<ppc::core::TaskData>();

taskDataSequential->inputs.emplace_back(reinterpret_cast<uint8_t *>(const_cast<char *>(in.data())));
taskDataSequential->inputs_count.emplace_back(in.size());
taskDataSequential->outputs.emplace_back(reinterpret_cast<uint8_t *>(referenceWordCount.data()));
taskDataSequential->outputs_count.emplace_back(referenceWordCount.size());

chernova_n_word_count_mpi::TestMPITaskSequential testTaskSequential(taskDataSequential);
ASSERT_TRUE(testTaskSequential.validation());
testTaskSequential.pre_processing();
testTaskSequential.run();
testTaskSequential.post_processing();

ASSERT_EQ(out[0], referenceWordCount[0]);
}
}

TEST(chernova_n_word_count_mpi, Test_ten_words) {
boost::mpi::communicator world;
std::vector<char> in;
std::string testString = "This is a test phrase, I really love this phrase";
in.resize(testString.size());
std::copy(testString.begin(), testString.end(), in.begin());
std::vector<int> out(1, 0);

std::shared_ptr<ppc::core::TaskData> taskDataParallel = std::make_shared<ppc::core::TaskData>();

if (world.rank() == 0) {
taskDataParallel->inputs.emplace_back(reinterpret_cast<uint8_t *>(const_cast<char *>(in.data())));
taskDataParallel->inputs_count.emplace_back(in.size());
taskDataParallel->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
taskDataParallel->outputs_count.emplace_back(out.size());
}

chernova_n_word_count_mpi::TestMPITaskParallel testTaskParallel(taskDataParallel);
ASSERT_TRUE(testTaskParallel.validation());
testTaskParallel.pre_processing();
testTaskParallel.run();
testTaskParallel.post_processing();

if (world.rank() == 0) {
std::vector<int> referenceWordCount(1, 0);
std::shared_ptr<ppc::core::TaskData> taskDataSequential = std::make_shared<ppc::core::TaskData>();

taskDataSequential->inputs.emplace_back(reinterpret_cast<uint8_t *>(const_cast<char *>(in.data())));
taskDataSequential->inputs_count.emplace_back(in.size());
taskDataSequential->outputs.emplace_back(reinterpret_cast<uint8_t *>(referenceWordCount.data()));
taskDataSequential->outputs_count.emplace_back(referenceWordCount.size());

chernova_n_word_count_mpi::TestMPITaskSequential testTaskSequential(taskDataSequential);
ASSERT_TRUE(testTaskSequential.validation());
testTaskSequential.pre_processing();
testTaskSequential.run();
testTaskSequential.post_processing();

ASSERT_EQ(out[0], referenceWordCount[0]);
}
}
TEST(chernova_n_word_count_mpi, Test_five_words_with_a_lot_of_space) {
boost::mpi::communicator world;
std::vector<char> in;
std::string testString = "This is a test phrase";
in.resize(testString.size());
std::copy(testString.begin(), testString.end(), in.begin());
std::vector<int> out(1, 0);

std::shared_ptr<ppc::core::TaskData> taskDataParallel = std::make_shared<ppc::core::TaskData>();

if (world.rank() == 0) {
taskDataParallel->inputs.emplace_back(reinterpret_cast<uint8_t *>(const_cast<char *>(in.data())));
taskDataParallel->inputs_count.emplace_back(in.size());
taskDataParallel->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
taskDataParallel->outputs_count.emplace_back(out.size());
}

chernova_n_word_count_mpi::TestMPITaskParallel testTaskParallel(taskDataParallel);
ASSERT_TRUE(testTaskParallel.validation());
testTaskParallel.pre_processing();
testTaskParallel.run();
testTaskParallel.post_processing();

if (world.rank() == 0) {
std::vector<int> referenceWordCount(1, 0);
std::shared_ptr<ppc::core::TaskData> taskDataSequential = std::make_shared<ppc::core::TaskData>();

taskDataSequential->inputs.emplace_back(reinterpret_cast<uint8_t *>(const_cast<char *>(in.data())));
taskDataSequential->inputs_count.emplace_back(in.size());
taskDataSequential->outputs.emplace_back(reinterpret_cast<uint8_t *>(referenceWordCount.data()));
taskDataSequential->outputs_count.emplace_back(referenceWordCount.size());

chernova_n_word_count_mpi::TestMPITaskSequential testTaskSequential(taskDataSequential);
ASSERT_TRUE(testTaskSequential.validation());
testTaskSequential.pre_processing();
testTaskSequential.run();
testTaskSequential.post_processing();

ASSERT_EQ(out[0], referenceWordCount[0]);
}
}
TEST(chernova_n_word_count_mpi, Test_twenty_words) {
boost::mpi::communicator world;
std::vector<char> in;
std::string testString =
"This is a test phrase, I really love this phrase. This is a test phrase, I really love this phrase";
in.resize(testString.size());
std::copy(testString.begin(), testString.end(), in.begin());
std::vector<int> out(1, 0);

std::shared_ptr<ppc::core::TaskData> taskDataParallel = std::make_shared<ppc::core::TaskData>();

if (world.rank() == 0) {
taskDataParallel->inputs.emplace_back(reinterpret_cast<uint8_t *>(const_cast<char *>(in.data())));
taskDataParallel->inputs_count.emplace_back(in.size());
taskDataParallel->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
taskDataParallel->outputs_count.emplace_back(out.size());
}

chernova_n_word_count_mpi::TestMPITaskParallel testTaskParallel(taskDataParallel);
ASSERT_TRUE(testTaskParallel.validation());
testTaskParallel.pre_processing();
testTaskParallel.run();
testTaskParallel.post_processing();

if (world.rank() == 0) {
std::vector<int> referenceWordCount(1, 0);
std::shared_ptr<ppc::core::TaskData> taskDataSequential = std::make_shared<ppc::core::TaskData>();

taskDataSequential->inputs.emplace_back(reinterpret_cast<uint8_t *>(const_cast<char *>(in.data())));
taskDataSequential->inputs_count.emplace_back(in.size());
taskDataSequential->outputs.emplace_back(reinterpret_cast<uint8_t *>(referenceWordCount.data()));
taskDataSequential->outputs_count.emplace_back(referenceWordCount.size());

chernova_n_word_count_mpi::TestMPITaskSequential testTaskSequential(taskDataSequential);
ASSERT_TRUE(testTaskSequential.validation());
testTaskSequential.pre_processing();
testTaskSequential.run();
testTaskSequential.post_processing();

ASSERT_EQ(out[0], referenceWordCount[0]);
}
}

TEST(chernova_n_word_count_mpi, Test_five_words_with_space_in_the_end) {
boost::mpi::communicator world;
std::vector<char> in;
std::string testString = "This is a test phrase ";
in.resize(testString.size());
std::copy(testString.begin(), testString.end(), in.begin());
std::vector<int> out(1, 0);

std::shared_ptr<ppc::core::TaskData> taskDataParallel = std::make_shared<ppc::core::TaskData>();

if (world.rank() == 0) {
taskDataParallel->inputs.emplace_back(reinterpret_cast<uint8_t *>(const_cast<char *>(in.data())));
taskDataParallel->inputs_count.emplace_back(in.size());
taskDataParallel->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
taskDataParallel->outputs_count.emplace_back(out.size());
}

chernova_n_word_count_mpi::TestMPITaskParallel testTaskParallel(taskDataParallel);
ASSERT_TRUE(testTaskParallel.validation());
testTaskParallel.pre_processing();
testTaskParallel.run();
testTaskParallel.post_processing();

if (world.rank() == 0) {
std::vector<int> referenceWordCount(1, 0);
std::shared_ptr<ppc::core::TaskData> taskDataSequential = std::make_shared<ppc::core::TaskData>();

taskDataSequential->inputs.emplace_back(reinterpret_cast<uint8_t *>(const_cast<char *>(in.data())));
taskDataSequential->inputs_count.emplace_back(in.size());
taskDataSequential->outputs.emplace_back(reinterpret_cast<uint8_t *>(referenceWordCount.data()));
taskDataSequential->outputs_count.emplace_back(referenceWordCount.size());

chernova_n_word_count_mpi::TestMPITaskSequential testTaskSequential(taskDataSequential);
ASSERT_TRUE(testTaskSequential.validation());
testTaskSequential.pre_processing();
testTaskSequential.run();
testTaskSequential.post_processing();

ASSERT_EQ(out[0], referenceWordCount[0]);
}
}

TEST(Sequential_chernova_n_word_count, Test_random_fifty_words) {
boost::mpi::communicator world;
std::vector<char> in = testDataParallel;
std::vector<int> out(1, 0);

std::shared_ptr<ppc::core::TaskData> taskDataParallel = std::make_shared<ppc::core::TaskData>();

if (world.rank() == 0) {
taskDataParallel->inputs.emplace_back(reinterpret_cast<uint8_t *>(const_cast<char *>(in.data())));
taskDataParallel->inputs_count.emplace_back(in.size());
taskDataParallel->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
taskDataParallel->outputs_count.emplace_back(out.size());
}

chernova_n_word_count_mpi::TestMPITaskParallel testTaskParallel(taskDataParallel);
ASSERT_TRUE(testTaskParallel.validation());
testTaskParallel.pre_processing();
testTaskParallel.run();
testTaskParallel.post_processing();

if (world.rank() == 0) {
std::vector<int> referenceWordCount(1, 0);
std::shared_ptr<ppc::core::TaskData> taskDataSequential = std::make_shared<ppc::core::TaskData>();

taskDataSequential->inputs.emplace_back(reinterpret_cast<uint8_t *>(const_cast<char *>(in.data())));
taskDataSequential->inputs_count.emplace_back(in.size());
taskDataSequential->outputs.emplace_back(reinterpret_cast<uint8_t *>(referenceWordCount.data()));
taskDataSequential->outputs_count.emplace_back(referenceWordCount.size());

chernova_n_word_count_mpi::TestMPITaskSequential testTaskSequential(taskDataSequential);
ASSERT_TRUE(testTaskSequential.validation());
testTaskSequential.pre_processing();
testTaskSequential.run();
testTaskSequential.post_processing();

ASSERT_EQ(out[0], referenceWordCount[0]);
}
}
Loading
Loading