JIANG/EPANET
1
0
Fork 0
Code Issues Pull Requests Actions 4 Packages Projects Releases Wiki Activity

Refactors the API's demand editing functions

Browse Source
This commit is contained in:
Lew Rossman
2019-05-09 10:26:40 -04:00
parent 52bda22833
commit 365ab00dcb
22 changed files with 449 additions and 1124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
tests/CMakeLists.txt
View File

@@ -23,16 +23,6 @@ add_test(NAME test_net_builder
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/data)
add_executable(test_demand_data test_demand_data.cpp
../src/demand.c
../src/util/list.c)
target_include_directories(test_demand_data PUBLIC ../src/ ../src/util/)
target_link_libraries(test_demand_data ${Boost_LIBRARIES} epanet2)
add_test(NAME test_demand_data
COMMAND ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_demand_data
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/data)
set(toolkit_test_srcs
test_toolkit.cpp
test_project.cpp
@@ -81,6 +71,3 @@ add_test(NAME test_filemanager
add_test(NAME test_output
COMMAND ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_output
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/outfile/data)
add_test(NAME test_list
COMMAND ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_list)

19
tests/test_demand.cpp
View File

@@ -84,31 +84,38 @@ BOOST_AUTO_TEST_CASE(test_categories_reopen, * boost::unit_test::depends_on("tes
BOOST_FIXTURE_TEST_CASE(test_adddemand, FixtureSingleNode)
{
int key, demand_key;
int Dindex, nD;
error = EN_adddemand(ph, node_qhut, 100.0, "PrimaryPattern", "PrimaryDemand", &demand_key);
error = EN_adddemand(ph, node_qhut, 100.0, "PrimaryPattern", "PrimaryDemand");
BOOST_CHECK(error != 0);
error = EN_addpattern(ph, (char *)"PrimaryPattern");
BOOST_REQUIRE(error == 0);
error = EN_adddemand(ph, node_qhut, 100.0, "PrimaryPattern", "PrimaryDemand", &demand_key);
error = EN_adddemand(ph, node_qhut, 100.0, "PrimaryPattern", "PrimaryDemand");
BOOST_CHECK(error == 0);
error = EN_addpattern(ph, (char *)"SecondaryPattern");
BOOST_REQUIRE(error == 0);
error = EN_adddemand(ph, node_qhut, 10.0, "SecondaryPattern", "SecondaryDemand", &key);
error = EN_adddemand(ph, node_qhut, 10.0, "SecondaryPattern", "SecondaryDemand");
BOOST_CHECK(error == 0);
error = EN_addpattern(ph, (char *)"TertiaryPattern");
BOOST_REQUIRE(error == 0);
error = EN_adddemand(ph, node_qhut, 1.0, "TertiaryPattern", "TertiaryDemand", &demand_key);
error = EN_adddemand(ph, node_qhut, 1.0, "TertiaryPattern", "TertiaryDemand");
BOOST_CHECK(error == 0);
error = EN_getdemandindex(ph, node_qhut, "TertiaryDemand", &Dindex);
BOOST_CHECK(error == 0);
error = EN_removedemand(ph, node_qhut, key);
error = EN_deletedemand(ph, node_qhut, Dindex);
BOOST_CHECK(error == 0);
error = EN_getnumdemands(ph, node_qhut, &nD);
BOOST_REQUIRE(error == 0);
BOOST_CHECK(nD == 2);
}

295
tests/test_demand_data.cpp
View File

@@ -1,295 +0,0 @@
/*
******************************************************************************
Project: OWA EPANET
Version: 2.2
Module: /test_demand_data.cpp
Description: tests demand data list node struct
Authors: see AUTHORS
Copyright: see AUTHORS
License: see LICENSE
Last Updated: 04/18/2019
******************************************************************************
*/
#define BOOST_TEST_MODULE demand_data
#include <boost/test/unit_test.hpp>
#include "demand.h"
#include "epanet2_2.h"
#define DATA_PATH_NET1 "./net1.inp"
#define DATA_PATH_TMP "./tmp.inp"
#define DATA_PATH_RPT "./test.rpt"
#define DATA_PATH_OUT "./test.out"
boost::test_tools::predicate_result check_string(std::string test, std::string ref)
{
if (ref.compare(test) == 0)
return true;
else
return false;
}
BOOST_AUTO_TEST_SUITE(test_demand_data)
BOOST_AUTO_TEST_CASE(test_create_destroy_demand_list)
{
list_t *dlist;
dlist = create_demand_list(100.0, 1, "CUB_SCOUT_DAY_CAMP");
BOOST_CHECK(dlist != NULL);
delete_list(dlist);
}
BOOST_AUTO_TEST_CASE (test_create_destroy)
{
void *data = NULL;
data = create_demand_data(100.0, 1, NULL);
BOOST_CHECK(data != NULL);
delete_demand_data(&data);
data = NULL;
data = create_demand_data(100.0, 1, "CUB_SCOUT_BASE_CAMP");
BOOST_CHECK(data != NULL);
delete_demand_data(&data);
}
BOOST_AUTO_TEST_CASE(test_get_size)
{
size_t size = get_demand_data_size();
BOOST_CHECK(size == sizeof(demand_data_t *));
}
struct Fixture {
Fixture() {
_data = NULL;
dlist = NULL;
dlist = create_list(get_demand_data_size(), delete_demand_data);
_data = create_demand_data(100.0, 1, "CUB_SCOUT_BASE_CAMP");
append_list(dlist, &_data);
}
~Fixture() {
delete_list(dlist);
}
demand_data_t *_data;
list_t *dlist;
};
BOOST_FIXTURE_TEST_CASE(test_demand_list, Fixture)
{
list_node_t *lnode = head_list(dlist, false);
BOOST_CHECK(lnode != NULL);
}
BOOST_FIXTURE_TEST_CASE(test_demand_getset, Fixture)
{
list_node_t *lnode = head_list(dlist, false);
double demand;
demand = get_base_demand(lnode);
BOOST_CHECK(demand == 100.0);
set_base_demand(lnode, 200.0);
demand = get_base_demand(lnode);
BOOST_CHECK(demand == 200.0);
}
BOOST_FIXTURE_TEST_CASE(test_pattern_getset, Fixture)
{
list_node_t *lnode = head_list(dlist, false);
int index;
index = get_pattern_index(lnode);
BOOST_CHECK(index == 1);
set_pattern_index(lnode, 2);
index = get_pattern_index(lnode);
BOOST_CHECK(index == 2);
}
BOOST_FIXTURE_TEST_CASE(test_category_getset, Fixture)
{
list_node_t *lnode = head_list(dlist, false);
char *name = NULL;
name = get_category_name(lnode);
BOOST_CHECK(check_string(name, (char *)"CUB_SCOUT_BASE_CAMP"));
free(name);
name = NULL;
set_category_name(lnode, (char *)"CUB_SCOUT_COMMAND");
name = get_category_name(lnode);
BOOST_CHECK(check_string(name, "CUB_SCOUT_COMMAND"));
free(name);
}
BOOST_FIXTURE_TEST_CASE(test_convert_demand, Fixture)
{
list_node_t *lnode = head_list(dlist, false);
BOOST_CHECK(lnode != NULL);
// 100.0 GPM == 6.31 LPS
convert_units(lnode, 15.850);
double demand = get_base_demand(lnode);
BOOST_TEST(demand == 6.31, boost::test_tools::tolerance(0.01));
}
BOOST_AUTO_TEST_CASE(test_initclose)
{
int error;
EN_Project ph = NULL;
EN_createproject(&ph);
error = EN_init(ph, DATA_PATH_RPT, DATA_PATH_OUT, EN_GPM, EN_HW);
BOOST_REQUIRE(error == 0);
error = EN_close(ph);
BOOST_REQUIRE(error == 0);
EN_deleteproject(&ph);
}
#define DATA_PATH_NET1 "./net1.inp"
#define DATA_PATH_TMP "./tmp.inp"
#define DATA_PATH_RPT "./test.rpt"
#define DATA_PATH_OUT "./test.out"
struct FixtureSingleNode {
FixtureSingleNode() {
error = 0;
ph = NULL;
EN_createproject(&ph);
EN_init(ph, DATA_PATH_RPT, DATA_PATH_OUT, EN_GPM, EN_HW);
EN_addnode(ph, (char *)"CUB_SCOUT_QUONSET_HUT", EN_JUNCTION, &node_qhut);
//EN_getnodeindex(ph, (char *)"CUB_SCOUT_QUONSET_HUT", &node_qhut);
}
~FixtureSingleNode() {
EN_close(ph);
EN_deleteproject(&ph);
}
int error, index, node_qhut;
EN_Project ph;
};
BOOST_FIXTURE_TEST_CASE(test_single_node, FixtureSingleNode)
{
int demand_idx, pattern_idx, n;
double demand;
error = EN_getnumdemands(ph, node_qhut, &n);
BOOST_REQUIRE(error == 0);
BOOST_CHECK(n == 0);
demand_idx = 1;
error = EN_getbasedemand(ph, node_qhut, demand_idx, &demand);
BOOST_REQUIRE(error == 253);
error = EN_getdemandpattern(ph, node_qhut, demand_idx, &pattern_idx);
BOOST_REQUIRE(error == 253);
char demname[31];
error = EN_getdemandname(ph, node_qhut, demand_idx, demname);
BOOST_REQUIRE(error == 253);
BOOST_CHECK(check_string(demname, "\0"));
error = EN_setbasedemand(ph, node_qhut, demand_idx, 100.0);
BOOST_REQUIRE(error == 0);
// only one demand category
pattern_idx = 1;
error = EN_setdemandpattern(ph, node_qhut, demand_idx, pattern_idx);
BOOST_REQUIRE(error == 205);
// create pattern
error = EN_addpattern(ph, (char *)"Pat2");
BOOST_REQUIRE(error == 0);
error = EN_getpatternindex(ph, (char *)"Pat2", &pattern_idx);
BOOST_REQUIRE(error == 0);
error = EN_setdemandpattern(ph, node_qhut, demand_idx, pattern_idx);
BOOST_REQUIRE(error == 0);
error = EN_setdemandname(ph, node_qhut, demand_idx, (char *)"CUB_SCOUT_MESS_HALL");
BOOST_REQUIRE(error == 0);
}
BOOST_FIXTURE_TEST_CASE(test_pattern_edits, FixtureSingleNode)
{
int n, node_cpoint, pat2_idx, pat3_idx;
EN_addnode(ph, (char *)"CUB_SCOUT_CHECKPOINT", EN_JUNCTION, &node_cpoint);
//EN_getnodeindex(ph, (char *)"CUB_SCOUT_CHECKPOINT", &node_cpoint);
// Add 2 new patterns
error = EN_addpattern(ph, (char *)"DefPat");
BOOST_REQUIRE(error == 0);
error = EN_addpattern(ph, (char *)"Pat2");
BOOST_REQUIRE(error == 0);
error = EN_getpatternindex(ph, (char *)"Pat2", &pat2_idx);
BOOST_REQUIRE(error == 0);
error = EN_addpattern(ph, (char *)"Pat3");
BOOST_REQUIRE(error == 0);
error = EN_getpatternindex(ph, (char *)"Pat3", &pat3_idx);
BOOST_REQUIRE(error == 0);
double f2[] = { 2.1, 2.2 };
double f3[] = { 3.1, 3.2, 3.3, 3.4 };
error = EN_setpattern(ph, pat2_idx, f2, 2);
BOOST_REQUIRE(error == 0);
error = EN_setpattern(ph, pat3_idx, f3, 4);
BOOST_REQUIRE(error == 0);
// Assign Pat3 to 3rd junction
error = EN_setdemandpattern(ph, node_cpoint, 1, pat3_idx);
BOOST_REQUIRE(error == 0);
// Delete Pat2
error = EN_deletepattern(ph, pat2_idx);
BOOST_REQUIRE(error == 0);
//Check that there are now 2 patterns
error = EN_getcount(ph, EN_PATCOUNT, &n);
BOOST_REQUIRE(error == 0);
BOOST_CHECK(n == 2);
// Check that Pat3 with 4 factors is still assigned to 3rd junction
error = EN_getdemandpattern(ph, node_cpoint, 1, &pat3_idx);
BOOST_REQUIRE(error == 0);
error = EN_getpatternlen(ph, pat3_idx, &n);
BOOST_REQUIRE(error == 0);
BOOST_CHECK(n == 4);
}
BOOST_AUTO_TEST_SUITE_END()

5
tests/util/CMakeLists.txt
View File

@@ -25,8 +25,3 @@ add_executable(test_filemanager ./test_filemanager.cpp
target_include_directories(test_filemanager PUBLIC ../../src/)
target_link_libraries(test_filemanager ${Boost_LIBRARIES})
add_executable(test_list ./test_list.cpp
../../src/util/list.c)
target_include_directories(test_list PUBLIC ../../src/)
target_link_libraries(test_list ${Boost_LIBRARIES})

248
tests/util/test_list.cpp
View File

@@ -1,248 +0,0 @@
/*
******************************************************************************
Project: OWA EPANET
Version: 2.2
Module: util/list.h
Description: Generic list
https://gist.github.com/pseudomuto/6334796#file-sample_app-c
Accessed: April 9, 2019
Authors: David Muto, Modified by Michael E. Tryby
Copyright: see AUTHORS
License: see LICENSE
Last Updated: 04/09/2019
******************************************************************************
*/
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define BOOST_TEST_MODULE list
#include <boost/test/unit_test.hpp>
#include "util/list.h"
boost::test_tools::predicate_result check_string(std::string test, std::string ref)
{
if (ref.compare(test) == 0)
return true;
else
return false;
}
int *get_int_data(list_node_t *lnode) {
return (int *)get_data(lnode);
}
bool iterate_int(list_node_t *lnode)
{
printf("At Key: %d Found value: %d\n", get_key(lnode), *get_int_data(lnode));
return true;
}
BOOST_AUTO_TEST_SUITE(test_list)
BOOST_AUTO_TEST_CASE(test_create_delete) {
list_t *list;
list = create_list(sizeof(int), NULL);
delete_list(list);
}
BOOST_AUTO_TEST_CASE(test_int_list){
int i, numbers = 10;
list_t *list = NULL;
int key[10 + 1];
srand((unsigned int)time(0));
list = create_list(sizeof(int), NULL);
for(i = 1; i <= numbers; i++) {
key[i] = append_list(list, &i);
}
BOOST_CHECK(size_list(list) == 10);
listIterator iterator = (listIterator)iterate_int;
for_each_list(list, iterator);
list_node_t *lnode = search_list(list, key[5]);
BOOST_CHECK(get_key(lnode) == key[5]);
delete_list(list);
}
inline char *get_string_data(list_node_t *lnode)
{
return *(char **)get_data(lnode);
}
bool iterate_string(list_node_t *lnode)
{
printf("Found string value: %s\n", get_string_data(lnode));
return true;
}
void free_string(void *data)
{
free(*(char **)data);
}
struct FixtureStrings{
FixtureStrings() {
list = NULL;
int numNames = 5;
const char *names[] = { "David", "Kevin", "Michael", "Craig", "Jimi" };
list = create_list(sizeof(char *), free_string);
char *name;
for (int i = 0; i < numNames; i++) {
name = strdup(names[i]);
append_list(list, &name);
}
}
~FixtureStrings() {
delete_list(list);
}
list_t *list;
};
BOOST_FIXTURE_TEST_CASE(test_string_list, FixtureStrings) {
BOOST_CHECK(size_list(list) == 5);
listIterator iterator = (listIterator)iterate_string;
for_each_list(list, iterator);
}
BOOST_FIXTURE_TEST_CASE(test_head_list, FixtureStrings) {
BOOST_CHECK(check_string(get_string_data(head_list(list, false)), "David"));
BOOST_CHECK(size_list(list) == 5);
list_node_t *lnode = head_list(list, true);
BOOST_CHECK(check_string(get_string_data(lnode), "David"));
delete_node(list, lnode);
BOOST_CHECK(check_string(get_string_data(head_list(list, false)), "Kevin"));
BOOST_CHECK(size_list(list) == 4);
}
BOOST_FIXTURE_TEST_CASE(test_tail_list, FixtureStrings) {
BOOST_CHECK(check_string(get_string_data(tail_list(list)), "Jimi"));
BOOST_CHECK(size_list(list) == 5);
}
typedef struct test_data_s {
int num;
char *name;
} test_data_t;
test_data_t *create_test_data(int number, const char *name){
test_data_t *data = (test_data_t *)malloc(sizeof(test_data_t));
data->num = number;
if (name)
data->name = strdup(name);
else
data->name = NULL;
return data;
}
void delete_test_data(void *data) {
test_data_t *test_data = *(test_data_t **)data;
if (test_data->name)
free(test_data->name);
free(test_data);
}
inline test_data_t *get_test_data(list_node_t *lnode)
{
return *(test_data_t **)get_data(lnode);
}
bool iterate_test_data(list_node_t *lnode)
{
test_data_t *test_data = get_test_data(lnode);
printf("Found number: %i name: %s\n", test_data->num, test_data->name);
return true;
}
char *get_name(list_node_t *lnode)
{
return get_test_data(lnode)->name;
}
BOOST_AUTO_TEST_CASE(test_struct_list){
int key, head_key, tail_key;
list_t *list = NULL;
list = create_list(sizeof(test_data_t *), delete_test_data);
test_data_t *data = create_test_data(1, "David");
head_key = append_list(list, &data);
data = create_test_data(2, "Kevin");
key = append_list(list, &data);
data = create_test_data(3, "Michael");
append_list(list, &data);
data = create_test_data(4, "Craig");
append_list(list, &data);
data = create_test_data(5, "Jimi");
tail_key = append_list(list, &data);
BOOST_CHECK(size_list(list) == 5);
listIterator iterator = (listIterator)iterate_test_data;
for_each_list(list, iterator);
// locate a list node by a key
printf("Found %s!\n", get_name(search_list(list, key)));
printf("Removing Kevin\n");
remove_node(list, key);
for_each_list(list, iterator);
printf("Removing David\n");
remove_node(list, head_key);
for_each_list(list, iterator);
printf("Removing Jimi\n");
remove_node(list, tail_key);
for_each_list(list, iterator);
list_node_t *lnode = head_list(list, true);
delete_node(list, lnode);
delete_list(list);
}
// TODO: search for an index and return data
BOOST_AUTO_TEST_SUITE_END()