hoo2/PDS
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

HW2: First locally working version of the 2 variations

Browse Source
This commit is contained in:
hoo2
2024-12-30 19:12:55 +02:00
parent 4d1d7502aa
commit c5ffec9cca
9 changed files with 403 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files
homework_2/test/tests_Bitonic.cpp
+5 -4
View File
@@ -230,12 +230,13 @@ TEST(TdistBitonic_UT, partner_test3) {
/* ================================== keepSmall ================================== */
/*
* bool keepSmall(mpi_id_t node, mpi_id_t partner, size_t depth);
* Assertion check
* Throw check (Not assert - ASSERT_DEATH)
*/
TEST(TdistBitonic_UT, keepsmall_test1) {
ASSERT_DEATH(keepSmall<SortMode::Bitonic>(0, 0, 0), "");
ASSERT_DEATH(keepSmall<SortMode::Bitonic>(1, 1, 42), "");
ASSERT_DEATH(keepSmall<SortMode::Bitonic>(7, 7, 42), "");
// node and partner must differ or else ...
EXPECT_THROW(keepSmall<SortMode::Bitonic>(0, 0, 0), std::runtime_error);
EXPECT_THROW(keepSmall<SortMode::Bitonic>(1, 1, 42), std::runtime_error);
EXPECT_THROW(keepSmall<SortMode::Bitonic>(7, 7, 42), std::runtime_error);
}
/*
homework_2/test/tests_Bubbletonic.cpp
+29 -4
View File
@@ -95,12 +95,13 @@ TEST(TdistBubbletonic_UT, partner_Bubbletonic_test3) {
/* ================================== keepSmall ================================== */
/*
* bool keepSmall<SortMode::Bubbletonic>(mpi_id_t node, mpi_id_t partner, size_t depth);
* Assertion check
* Throw check (Not assert - ASSERT_DEATH)
*/
TEST(TdistBubbletonic_UT, keepsmall_test1) {
ASSERT_DEATH(keepSmall<SortMode::Bubbletonic>(0, 0, 0), "");
ASSERT_DEATH(keepSmall<SortMode::Bubbletonic>(1, 1, 42), "");
ASSERT_DEATH(keepSmall<SortMode::Bubbletonic>(7, 7, 42), "");
// node and partner must differ or else ...
EXPECT_THROW(keepSmall<SortMode::Bubbletonic>(0, 0, 0), std::runtime_error);
EXPECT_THROW(keepSmall<SortMode::Bubbletonic>(1, 1, 42), std::runtime_error);
EXPECT_THROW(keepSmall<SortMode::Bubbletonic>(7, 7, 42), std::runtime_error);
}
/*
@@ -119,6 +120,30 @@ TEST(TdistBubbletonic_UT, keepsmall_test2) {
EXPECT_EQ(keepSmall<SortMode::Bubbletonic>(4, 9, 42), true);
}
/* ================================== isActive ================================== */
/*
* bool isActive(mpi_id_t node, size_t nodes);
* Throw check
*/
TEST(TdistBubbletonic_UT, isActive_test1) {
EXPECT_THROW(isActive(0, 0), std::runtime_error);
EXPECT_THROW(isActive(0, static_cast<size_t>(std::numeric_limits<mpi_id_t>::max()) + 1), std::runtime_error);
}
/*
* bool isActive(mpi_id_t node, size_t nodes);
* Boundary 3 BVA
*/
TEST(TdistBubbletonic_UT, isActive_test2) {
EXPECT_EQ(isActive(-1, 8), false);
EXPECT_EQ(isActive(0, 8), true);
EXPECT_EQ(isActive(1, 8), true);
EXPECT_EQ(isActive(7, 8), true);
EXPECT_EQ(isActive(8, 8), false);
EXPECT_EQ(isActive(9, 8), false);
}
#if 0
TEST(TdistBubbletonic_UT, distBubbletonic_test1) {
homework_2/test/tests_Common.cpp
+156
View File
@@ -0,0 +1,156 @@
/**
* \file
* \brief PDS HW2 tests
*
* \author
* Christos Choutouridis AEM:8997
* <cchoutou@ece.auth.gr>
*/
#include <gtest/gtest.h>
#include <algorithm> // rand/srand
#include <ctime> // rand/srand
#include "distsort.hpp"
/* ================================== fullSort ================================== */
/*
*
*/
TEST(TdistCommonUT, fullSort_test1) {
std::vector<uint8_t> ts_data = {3, 2, 1, 4, 5, 7, 8, 6};
std::vector<uint8_t> ts_expected = {1, 2, 3, 4, 5, 6, 7, 8};
bool ts_ascending = true;
fullSort(ts_data, ts_ascending);
EXPECT_EQ((ts_data == ts_expected), true);
}
TEST(TdistCommonUT, fullSort_test2) {
std::vector<uint8_t> ts_data = {3, 2, 1, 4, 5, 7, 8, 6};
std::vector<uint8_t> ts_expected = {8, 7, 6, 5, 4, 3, 2, 1};
bool ts_ascending = false;
fullSort(ts_data, ts_ascending);
EXPECT_EQ((ts_data == ts_expected), true);
}
/* ================================== elbowSort ================================== */
TEST(TdistCommonUT, elbowSort_test1) {
ShadowedVec_t<uint8_t> ts_data1(std::vector<uint8_t>{3, 2, 1, 4, 5, 5, 7, 8});
ShadowedVec_t<uint8_t> ts_data2(std::vector<uint8_t>{4, 5, 7, 8, 5, 3, 2, 1});
ShadowedVec_t<uint8_t> ts_data3(std::vector<uint8_t>{1, 2, 3, 4, 5, 5, 7, 8});
ShadowedVec_t<uint8_t> ts_data4(std::vector<uint8_t>{8, 7, 5, 5, 4, 3, 2, 1});
std::vector<uint8_t> ts_expected = {1, 2, 3, 4, 5, 5, 7, 8};
bool ts_ascending = true;
elbowSort(ts_data1, ts_ascending);
elbowSort(ts_data2, ts_ascending);
elbowSort(ts_data3, ts_ascending);
elbowSort(ts_data4, ts_ascending);
EXPECT_EQ((ts_data1 == ts_expected), true);
EXPECT_EQ((ts_data2 == ts_expected), true);
EXPECT_EQ((ts_data3 == ts_expected), true);
EXPECT_EQ((ts_data4 == ts_expected), true);
}
TEST(TdistCommonUT, elbowSort_test2) {
ShadowedVec_t<uint8_t> ts_data1(std::vector<uint8_t>{3, 2, 1, 4, 5, 5, 7, 8});
ShadowedVec_t<uint8_t> ts_data2(std::vector<uint8_t>{4, 5, 7, 8, 5, 3, 2, 1});
ShadowedVec_t<uint8_t> ts_data3(std::vector<uint8_t>{1, 2, 3, 4, 5, 5, 7, 8});
ShadowedVec_t<uint8_t> ts_data4(std::vector<uint8_t>{8, 7, 5, 5, 4, 3, 2, 1});
std::vector<uint8_t> ts_expected = {8, 7, 5, 5, 4, 3, 2, 1};
bool ts_ascending = false;
elbowSort(ts_data1, ts_ascending);
elbowSort(ts_data2, ts_ascending);
elbowSort(ts_data3, ts_ascending);
elbowSort(ts_data4, ts_ascending);
EXPECT_EQ((ts_data1 == ts_expected), true);
EXPECT_EQ((ts_data2 == ts_expected), true);
EXPECT_EQ((ts_data3 == ts_expected), true);
EXPECT_EQ((ts_data4 == ts_expected), true);
}
TEST(TdistCommonUT, elbowSort_test3) {
ShadowedVec_t<uint8_t> ts_data(std::vector<uint8_t>{8, 7, 5, 5, 4, 3, 2, 1});
std::vector<uint8_t> ts_expected_asc = {1, 2, 3, 4, 5, 5, 7, 8};
std::vector<uint8_t> ts_expected_des = {8, 7, 5, 5, 4, 3, 2, 1};
// Check alternation for active-shadow vector inside Buffer and elbow algorithm
elbowSort(ts_data, true);
EXPECT_EQ((ts_data == ts_expected_asc), true);
elbowSort(ts_data, false);
EXPECT_EQ((ts_data == ts_expected_des), true);
elbowSort(ts_data, true);
EXPECT_EQ((ts_data == ts_expected_asc), true);
elbowSort(ts_data, false);
EXPECT_EQ((ts_data == ts_expected_des), true);
}
#if 0
TEST(TdistBubbletonic_UT, distBubbletonic_test1) {
AllData_t ts_Data {
ShadowedVec_t (8), ShadowedVec_t (8)
};
std::srand(unsigned(std::time(nullptr)));
for (auto& v : ts_Data) {
std::generate(v.begin(), v.end(), std::rand);
}
distBubbletonic(2, ts_Data);
auto max = std::numeric_limits<ShadowedVec_t::value_type>::min();
for (auto& v : ts_Data) {
EXPECT_EQ((max <= v[0]), true);
EXPECT_EQ(std::is_sorted(v.begin(), v.end()), true);
max = v.back();
}
}
TEST(TdistBubbletonic_UT, distBubbletonic_test2) {
AllData_t ts_Data {
ShadowedVec_t (8), ShadowedVec_t (8), ShadowedVec_t (8), ShadowedVec_t (8)
};
std::srand(unsigned(std::time(nullptr)));
for (auto& v : ts_Data) {
std::generate(v.begin(), v.end(), std::rand);
}
distBubbletonic(4, ts_Data);
auto max = std::numeric_limits<ShadowedVec_t::value_type>::min();
for (auto& v : ts_Data) {
EXPECT_EQ((max <= v[0]), true);
EXPECT_EQ(std::is_sorted(v.begin(), v.end()), true);
max = v.back();
}
}
TEST(TdistBubbletonic_UT, distBubbletonic_test3) {
AllData_t ts_Data {
ShadowedVec_t (32), ShadowedVec_t (32), ShadowedVec_t (32), ShadowedVec_t (32),
ShadowedVec_t (32), ShadowedVec_t (32), ShadowedVec_t (32), ShadowedVec_t (32)
};
std::srand(unsigned(std::time(nullptr)));
for (auto& v : ts_Data) {
std::generate(v.begin(), v.end(), std::rand);
}
distBubbletonic(8, ts_Data);
auto max = std::numeric_limits<ShadowedVec_t::value_type>::min();
for (auto& v : ts_Data) {
EXPECT_EQ((max <= v[0]), true);
EXPECT_EQ(std::is_sorted(v.begin(), v.end()), true);
max = v.back();
}
}
#endif