Skip to content

Commit

Permalink
Refactor code in tests related to fd and ucc tests
Browse files Browse the repository at this point in the history
  • Loading branch information
@vs9h
vs9h committed Dec 5, 2023
1 parent bd0ce94 commit b7f8a0a
Show file tree
Hide file tree
Showing 6 changed files with 204 additions and 266 deletions.
76 changes: 10 additions & 66 deletions src/tests/datasets.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -11,13 +11,6 @@ namespace tests {

static auto const test_data_dir = std::filesystem::current_path() / "input_data";

struct Dataset {
std::string name;
size_t hash;
char separator;
bool has_header;
};

/// csv table configuration info to create an input table
struct TableConfig {
std::string_view name;
Expand All @@ -33,65 +26,16 @@ struct TableConfig {
}
};

class LightDatasets {
public:
static inline const std::array<Dataset, 11> datasets_ = {
{{"CIPublicHighway10k.csv", 33398, ',', true},
{"neighbors10k.csv", 43368, ',', true},
{"WDC_astronomical.csv", 22281, ',', true},
{"WDC_age.csv", 19620, ',', true},
{"WDC_appearances.csv", 25827, ',', true},
{"WDC_astrology.csv", 40815, ',', true},
{"WDC_game.csv", 6418, ',', true},
{"WDC_science.csv", 19620, ',', true},
{"WDC_symbols.csv", 28289, ',', true},
{"breast_cancer.csv", 15121, ',', true},
{"WDC_kepler.csv", 63730, ',', true}}};

// DEPRECATED -- just use
// for (auto dataset : LightDatasets::datasets) { ... }
static size_t DatasetQuantity() {
return datasets_.size();
}
static std::string DatasetName(size_t i) {
return datasets_[i].name;
}
static char Separator(size_t i) {
return datasets_[i].separator;
}
static bool HasHeader(size_t i) {
return datasets_[i].has_header;
}
static unsigned int Hash(size_t i) {
return datasets_[i].hash;
}
/// a struct consisting of a table config and the expected hash
struct TableConfigHash {
TableConfig config;
size_t hash;
};

class HeavyDatasets {
public:
static inline const std::array<Dataset, 6> datasets_ = {
{{"adult.csv", 23075, ';', false},
{"CIPublicHighway.csv", 13035, ',', true},
{"EpicMeds.csv", 50218, '|', true},
{"EpicVitals.csv", 2083, '|', true},
{"iowa1kk.csv", 28573, ',', true},
{"LegacyPayors.csv", 43612, '|', true}}};

// DEPRECATED -- just use
// for (auto dataset : HeavyDatasets::datasets) { ... }
static size_t DatasetQuantity() {
return datasets_.size();
}
static std::string DatasetName(size_t i) {
return datasets_[i].name;
}
static char Separator(size_t i) {
return datasets_[i].separator;
}
static bool HasHeader(size_t i) {
return datasets_[i].has_header;
}
static unsigned int Hash(size_t i) {
return datasets_[i].hash;
}
/// a struct consisting of a tables config and the expected hash
struct TablesConfigHash {
std::vector<TableConfig> configs;
size_t hash;
};

} // namespace tests
48 changes: 13 additions & 35 deletions src/tests/test_algorithm.cpp → src/tests/test_fd_algorithm.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,13 +16,15 @@
#include "algorithms/fd/tane/tane.h"
#include "datasets.h"
#include "model/table/relational_schema.h"
#include "testing_utils.h"
#include "test_fd_util.h"

using std::string, std::vector;
using ::testing::ContainerEq, ::testing::Eq;

namespace fs = std::filesystem;

namespace tests {

/* This is a test suite for algorithm verification. It should be possible to run these tests for any
* algorithm that:
* 1. extends FDAlgorithm
Expand Down Expand Up @@ -76,20 +78,20 @@ std::set<std::pair<std::vector<unsigned int>, unsigned int>> FDsToSet(std::list<
TYPED_TEST_SUITE_P(AlgorithmTest);

TYPED_TEST_P(AlgorithmTest, ThrowsOnEmpty) {
auto algorithm = TestFixture::CreateAndConfToLoad(test_data_dir / "TestEmpty.csv", ',', true);
auto algorithm = TestFixture::CreateAndConfToLoad(kTestEmpty);
ASSERT_THROW(algorithm->LoadData(), std::runtime_error);
}

TYPED_TEST_P(AlgorithmTest, ReturnsEmptyOnSingleNonKey) {
auto algorithm = TestFixture::CreateAlgorithmInstance("TestSingleColumn.csv", ',', true);
auto algorithm = TestFixture::CreateAlgorithmInstance(kTestSingleColumn);
algorithm->Execute();
ASSERT_TRUE(algorithm->FdList().empty());
}

TYPED_TEST_P(AlgorithmTest, WorksOnLongDataset) {
std::set<std::pair<std::vector<unsigned int>, unsigned int>> true_fd_collection{{{2}, 1}};

auto algorithm = TestFixture::CreateAlgorithmInstance("TestLong.csv", ',', true);
auto algorithm = TestFixture::CreateAlgorithmInstance(kTestLong);
algorithm->Execute();
ASSERT_TRUE(CheckFdListEquality(true_fd_collection, algorithm->FdList()));
}
Expand All @@ -98,51 +100,25 @@ TYPED_TEST_P(AlgorithmTest, WorksOnWideDataset) {
std::set<std::pair<std::vector<unsigned int>, unsigned int>> true_fd_collection{
{{0}, 2}, {{0}, 4}, {{2}, 0}, {{2}, 4}, {{4}, 0}, {{4}, 2}, {{}, 1}, {{}, 3}};

auto algorithm = TestFixture::CreateAlgorithmInstance("TestWide.csv", ',', true);
auto algorithm = TestFixture::CreateAlgorithmInstance(kTestWide);
algorithm->Execute();
ASSERT_TRUE(CheckFdListEquality(true_fd_collection, algorithm->FdList()));
}

TYPED_TEST_P(AlgorithmTest, LightDatasetsConsistentHash) {
try {
for (auto const& dataset : LightDatasets::datasets_) {
auto algorithm = TestFixture::CreateAlgorithmInstance(dataset.name, dataset.separator,
dataset.has_header);
algorithm->Execute();
std::cout << dataset.name << std::endl;
EXPECT_EQ(algorithm->Fletcher16(), dataset.hash)
<< "FD collection hash changed for " << dataset.name;
}
} catch (std::runtime_error& e) {
std::cout << "Exception raised in test: " << e.what() << std::endl;
FAIL();
}
SUCCEED();
TestFixture::PerformConsistentHashTestOn(TestFixture::light_datasets_);
}

TYPED_TEST_P(AlgorithmTest, HeavyDatasetsConsistentHash) {
try {
for (auto const& dataset : HeavyDatasets::datasets_) {
auto algorithm = TestFixture::CreateAlgorithmInstance(dataset.name, dataset.separator,
dataset.has_header);
algorithm->Execute();
EXPECT_EQ(algorithm->Fletcher16(), dataset.hash)
<< "The new algorithm and Pyro yield different results at " << dataset.name;
}
} catch (std::runtime_error& e) {
std::cout << "Exception raised in test: " << e.what() << std::endl;
FAIL();
}
SUCCEED();
TestFixture::PerformConsistentHashTestOn(TestFixture::heavy_datasets_);
}

TYPED_TEST_P(AlgorithmTest, ConsistentRepeatedExecution) {
auto const path = test_data_dir / "WDC_astronomical.csv";
auto algorithm = TestFixture::CreateAlgorithmInstance(path, ',', true);
auto algorithm = TestFixture::CreateAlgorithmInstance(kWDC_astronomical);
algorithm->Execute();
auto first_res = FDsToSet(algorithm->FdList());
for (int i = 0; i < 3; ++i) {
algos::ConfigureFromMap(*algorithm, TestFixture::GetParamMap(path, ',', true));
algos::ConfigureFromMap(*algorithm, TestFixture::GetParamMap(kWDC_astronomical));
algorithm->Execute();
ASSERT_TRUE(CheckFdListEquality(first_res, algorithm->FdList()));
}
Expand All @@ -155,3 +131,5 @@ REGISTER_TYPED_TEST_SUITE_P(AlgorithmTest, ThrowsOnEmpty, ReturnsEmptyOnSingleNo
using Algorithms = ::testing::Types<algos::Tane, algos::Pyro, algos::FastFDs, algos::DFD,
algos::Depminer, algos::FDep, algos::FUN, algos::hyfd::HyFD>;
INSTANTIATE_TYPED_TEST_SUITE_P(AlgorithmTest, AlgorithmTest, Algorithms);

} // namespace tests
48 changes: 19 additions & 29 deletions src/tests/test_fd_mine.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -14,6 +14,7 @@
#include "config/names.h"
#include "datasets.h"
#include "model/table/relational_schema.h"
#include "test_fd_util.h"

using ::testing::ContainerEq, ::testing::Eq;

Expand All @@ -23,26 +24,21 @@ using std::string, std::vector;

namespace onam = config::names;

StdParamsMap FD_MineGetParamMap(const std::filesystem::path& path, char separator = ',',
bool has_header = true) {
InputTable parser = std::make_unique<CSVParser>(path, separator, has_header);
return {{config::names::kTable, parser}};
StdParamsMap FD_MineGetParamMap(tests::TableConfig const& info) {
return {{config::names::kTable, info.MakeInputTable()}};
}

std::unique_ptr<FDAlgorithm> ConfToLoadFD_Mine(std::string const& path, char separator = ',',
bool has_header = true) {
std::unique_ptr<FDAlgorithm> ConfToLoadFD_Mine(tests::TableConfig const& info) {
std::unique_ptr<FDAlgorithm> algorithm = std::make_unique<Fd_mine>();
algos::ConfigureFromMap(*algorithm, FD_MineGetParamMap(path, separator, has_header));
algos::ConfigureFromMap(*algorithm, FD_MineGetParamMap(info));
return algorithm;
}

std::unique_ptr<FDAlgorithm> CreateFD_MineAlgorithmInstance(std::string const& path,
char separator = ',',
bool has_header = true) {
return algos::CreateAndLoadAlgorithm<Fd_mine>(FD_MineGetParamMap(path, separator, has_header));
std::unique_ptr<FDAlgorithm> CreateFD_MineAlgorithmInstance(tests::TableConfig const& info) {
return algos::CreateAndLoadAlgorithm<Fd_mine>(FD_MineGetParamMap(info));
}

class AlgorithmTest : public LightDatasets, public HeavyDatasets, public ::testing::Test {};
using FDMineAlgorithmTest = tests::AlgorithmTest<Fd_mine>;

std::vector<unsigned int> FD_MineBitsetToIndexVector(boost::dynamic_bitset<> const& bitset) {
std::vector<unsigned int> res;
Expand Down Expand Up @@ -85,24 +81,20 @@ std::set<std::pair<std::vector<unsigned int>, unsigned int>> FD_MineFDsToSet(
}

TEST(AlgorithmSyntheticTest, FD_Mine_ThrowsOnEmpty) {
auto path = test_data_dir / "TestEmpty.csv";
auto algorithm = ConfToLoadFD_Mine(test_data_dir / "TestEmpty.csv", ',', true);
auto algorithm = ConfToLoadFD_Mine(tests::kTestEmpty);
ASSERT_THROW(algorithm->LoadData(), std::runtime_error);
}

TEST(AlgorithmSyntheticTest, FD_Mine_ReturnsEmptyOnSingleNonKey) {
auto path = test_data_dir / "TestSingleColumn.csv";
auto algorithm = CreateFD_MineAlgorithmInstance(path, ',', true);
auto algorithm = CreateFD_MineAlgorithmInstance(tests::kTestSingleColumn);
algorithm->Execute();
ASSERT_TRUE(algorithm->FdList().empty());
}

TEST(AlgorithmSyntheticTest, FD_Mine_WorksOnLongDataset) {
auto path = test_data_dir / "TestLong.csv";

std::set<std::pair<std::vector<unsigned int>, unsigned int>> true_fd_collection{{{2}, 1}};

auto algorithm = CreateFD_MineAlgorithmInstance(path, ',', true);
auto algorithm = CreateFD_MineAlgorithmInstance(tests::kTestLong);
algorithm->Execute();
ASSERT_TRUE(FD_Mine_CheckFDListEquality(true_fd_collection, algorithm->FdList()));
}
Expand Down Expand Up @@ -148,22 +140,20 @@ void MinimizeFDs(std::list<FD>& fd_collection) {
}
}

TEST_F(AlgorithmTest, FD_Mine_ReturnsSameAsPyro) {
TEST_F(FDMineAlgorithmTest, FD_Mine_ReturnsSameAsPyro) {
namespace onam = config::names;

try {
for (Dataset const& dataset : LightDatasets::datasets_) {
for (auto const& [config, hash] : FDMineAlgorithmTest::light_datasets_) {
// TODO: change this hotfix
if (dataset.name == "breast_cancer.csv") {
if (config.name == tests::kbreast_cancer.name) {
continue;
}
auto path = test_data_dir / dataset.name;
auto algorithm =
CreateFD_MineAlgorithmInstance(path, dataset.separator, dataset.has_header);
auto algorithm = CreateFD_MineAlgorithmInstance(config);

StdParamsMap params_map{{onam::kCsvPath, path},
{onam::kSeparator, dataset.separator},
{onam::kHasHeader, dataset.has_header},
StdParamsMap params_map{{onam::kCsvPath, config.GetPath()},
{onam::kSeparator, config.separator},
{onam::kHasHeader, config.has_header},
{onam::kSeed, decltype(pyro::Parameters::seed){0}},
{onam::kError, config::ErrorType{0.0}}};
auto pyro_ptr = algos::CreateAndLoadAlgorithm<algos::Pyro>(params_map);
Expand Down Expand Up @@ -192,7 +182,7 @@ TEST_F(AlgorithmTest, FD_Mine_ReturnsSameAsPyro) {
std::string results_pyro = pyro.FDAlgorithm::GetJsonFDs();

EXPECT_EQ(results_pyro, algorithm_results)
<< "The new algorithm and Pyro yield different results at " << dataset.name;
<< "The new algorithm and Pyro yield different results at " << config.name;
}
} catch (std::runtime_error& e) {
std::cout << "Exception raised in test: " << e.what() << std::endl;
Expand Down
78 changes: 78 additions & 0 deletions src/tests/test_fd_util.h
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,78 @@
#pragma once

#include <filesystem>

#include <gtest/gtest.h>

#include "algorithms/algo_factory.h"
#include "algorithms/fd/fd_algorithm.h"
#include "all_tables_config.h"
#include "config/error/type.h"
#include "config/names.h"
#include "datasets.h"

namespace tests {
template <typename T>
class AlgorithmTest : public ::testing::Test {
protected:
static std::unique_ptr<algos::FDAlgorithm> CreateAndConfToLoad(
tests::TableConfig const& config) {
using config::InputTable, algos::ConfigureFromMap, algos::StdParamsMap;
std::unique_ptr<algos::FDAlgorithm> algorithm = std::make_unique<T>();
ConfigureFromMap(*algorithm,
StdParamsMap{{config::names::kTable, config.MakeInputTable()}});
return algorithm;
}

static algos::StdParamsMap GetParamMap(tests::TableConfig const& config) {
using namespace config::names;
return {
{kTable, config.MakeInputTable()},
{kError, config::ErrorType{0.0}},
{kSeed, decltype(pyro::Parameters::seed){0}},
};
}

static void PerformConsistentHashTestOn(std::vector<TableConfigHash> const& datasets) {
try {
for (auto const& [config, hash] : datasets) {
auto algorithm = CreateAlgorithmInstance(config);
algorithm->Execute();
EXPECT_EQ(algorithm->Fletcher16(), hash)
<< "FD collection hash changed for " << config.name;
}
} catch (std::runtime_error& e) {
std::cout << "Exception raised in test: " << e.what() << std::endl;
FAIL();
}
SUCCEED();
}

public:
static std::unique_ptr<algos::FDAlgorithm> CreateAlgorithmInstance(
tests::TableConfig const& config) {
return algos::CreateAndLoadAlgorithm<T>(GetParamMap(config));
}

inline static std::vector<tests::TableConfigHash> const light_datasets_ = {
{{tests::kCIPublicHighway10k, 33398},
{tests::kneighbors10k, 43368},
{tests::kWDC_astronomical, 22281},
{tests::kWDC_age, 19620},
{tests::kWDC_appearances, 25827},
{tests::kWDC_astrology, 40815},
{tests::kWDC_game, 6418},
{tests::kWDC_science, 19620},
{tests::kWDC_symbols, 28289},
{tests::kbreast_cancer, 15121},
{tests::kWDC_kepler, 63730}}};

inline static std::vector<tests::TableConfigHash> const heavy_datasets_ = {
{{tests::kadult, 23075},
{tests::kCIPublicHighway, 13035},
{tests::kEpicMeds, 50218},
{tests::kEpicVitals, 2083},
{tests::kiowa1kk, 28573},
{tests::kLegacyPayors, 43612}}};
};
} // namespace tests
Loading

0 comments on commit b7f8a0a

Please sign in to comment.