AtHeartEngineer/kami
1
0
Fork 0
mirror of https://github.com/JHUAPL/kami.git synced 2026-01-09 14:58:02 -05:00
Code Issues Packages Projects Releases Wiki Activity

Completed first generation of unit tests on the grids

Browse Source
This commit is contained in:
James P. Howard, II
2022-08-18 16:56:16 -04:00
parent f6967d0ec3
commit 72f0074d81
15 changed files with 2697 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
examples/boltzmann1d/boltzmann1d.cc
View File

@@ -77,7 +77,7 @@ kami::AgentID MoneyAgent1D::step(std::shared_ptr<kami::Model> model) {
return this->get_agent_id();
}
kami::GridCoord1D MoneyAgent1D::move_agent(std::shared_ptr<kami::Model> model) {
std::optional<kami::GridCoord1D> MoneyAgent1D::move_agent(std::shared_ptr<kami::Model> model) {
console->trace("Entering move_agent");
auto agent_id = get_agent_id();
@@ -86,9 +86,12 @@ kami::GridCoord1D MoneyAgent1D::move_agent(std::shared_ptr<kami::Model> model) {
throw (std::domain_error("model is missing domain"));
auto world = std::static_pointer_cast<kami::MultiGrid1D>(domain.value());
auto move_list = world->get_neighborhood(agent_id, false);
auto move_list_opt = world->get_neighborhood(agent_id, false);
if (!move_list_opt)
return std::nullopt;
auto move_list = move_list_opt.value();
std::uniform_int_distribution<int> dist(0, (int) move_list->size() - 1);
auto new_location = move_list->at(dist(*rng));
auto new_location = *std::next(move_list->begin(), dist(*rng));
console->trace("Moving Agent {} to location {}", agent_id, new_location);
world->move_agent(agent_id, new_location);
@@ -112,13 +115,17 @@ std::optional<kami::AgentID> MoneyAgent1D::give_money(std::shared_ptr<kami::Mode
auto population = std::static_pointer_cast<kami::Population>(agents.value());
auto location = world->get_location_by_agent(agent_id);
auto cell_mates = world->get_location_contents(location.value());
auto cell_mates_opt = world->get_location_contents(location.value());
if (!cell_mates_opt)
return std::nullopt;
auto cell_mates = cell_mates_opt.value();
if (cell_mates->size() < 2)
return std::nullopt;
std::uniform_int_distribution<int> dist(0, (int) cell_mates->size() - 1);
kami::AgentID other_agent_id = cell_mates->at(dist(*rng));
auto other_agent_id = *std::next(cell_mates->begin(), dist(*rng));
auto other_agent = std::static_pointer_cast<MoneyAgent1D>(population->get_agent_by_id(other_agent_id).value());
console->trace("Agent {} giving unit of wealth to agent {}", agent_id, other_agent_id);

2
examples/boltzmann1d/boltzmann1d.h
View File

@@ -65,7 +65,7 @@ public:
/**
* Move the agent to a random location on the world
*/
kami::GridCoord1D move_agent(std::shared_ptr<kami::Model> model);
std::optional<kami::GridCoord1D> move_agent(std::shared_ptr<kami::Model> model);
/**
* Give money to a random agent

17
examples/boltzmann2d/boltzmann2d.cc
View File

@@ -77,7 +77,7 @@ kami::AgentID MoneyAgent2D::step(std::shared_ptr<kami::Model> model) {
return this->get_agent_id();
}
kami::GridCoord2D MoneyAgent2D::move_agent(std::shared_ptr<kami::Model> model) {
std::optional<kami::GridCoord2D> MoneyAgent2D::move_agent(std::shared_ptr<kami::Model> model) {
console->trace("Entering move_agent");
auto agent_id = get_agent_id();
@@ -86,9 +86,12 @@ kami::GridCoord2D MoneyAgent2D::move_agent(std::shared_ptr<kami::Model> model) {
throw (std::domain_error("model is missing domain"));
auto world = std::static_pointer_cast<kami::MultiGrid2D>(domain.value());
auto move_list = world->get_neighborhood(agent_id, false, kami::GridNeighborhoodType::Moore);
auto move_list_opt = world->get_neighborhood(agent_id, false, kami::GridNeighborhoodType::VonNeumann);
if (!move_list_opt)
return std::nullopt;
auto move_list = move_list_opt.value();
std::uniform_int_distribution<int> dist(0, (int) move_list->size() - 1);
auto new_location = move_list->at(dist(*rng));
auto new_location = *std::next(move_list->begin(), dist(*rng));
console->trace("Moving Agent {} to location {}", agent_id, new_location);
world->move_agent(agent_id, new_location);
@@ -112,13 +115,17 @@ std::optional<kami::AgentID> MoneyAgent2D::give_money(std::shared_ptr<kami::Mode
auto population = std::static_pointer_cast<kami::Population>(agents.value());
auto location = world->get_location_by_agent(agent_id);
auto cell_mates = world->get_location_contents(location.value());
auto cell_mates_opt = world->get_location_contents(location.value());
if (!cell_mates_opt)
return std::nullopt;
auto cell_mates = cell_mates_opt.value();
if (cell_mates->size() < 2)
return std::nullopt;
std::uniform_int_distribution<int> dist(0, (int) cell_mates->size() - 1);
kami::AgentID other_agent_id = cell_mates->at(dist(*rng));
auto other_agent_id = *std::next(cell_mates->begin(), dist(*rng));
auto other_agent = std::static_pointer_cast<MoneyAgent2D>(population->get_agent_by_id(other_agent_id).value());
console->trace("Agent {} giving unit of wealth to agent {}", agent_id, other_agent_id);

2
examples/boltzmann2d/boltzmann2d.h
View File

@@ -64,7 +64,7 @@ public:
/**
* Move the agent to a random location on the world
*/
kami::GridCoord2D move_agent(std::shared_ptr<kami::Model> model);
std::optional<kami::GridCoord2D> move_agent(std::shared_ptr<kami::Model> model);
/**
* Give money to a random agent

18
include/kami/grid1d.h
View File

@@ -32,8 +32,9 @@
#include <iostream>
#include <map>
#include <memory>
#include <set>
#include <unordered_map>
#include <vector>
#include <unordered_set>
#include <kami/domain.h>
#include <kami/grid.h>
@@ -171,12 +172,13 @@ namespace kami {
*
* @param[in] coord the coordinates of the query.
*
* @return a pointer to a `vector` of `AgentID`s. The pointer is to the
* @return a pointer to a `set` of `AgentID`s. The pointer is to the
* internal copy of the agent list at the location, therefore, any changes
* to that object will update the state of the gird. Further, the pointer
* should not be deleted when no longer used.
*/
[[nodiscard]] std::unique_ptr<std::vector<AgentID>> get_location_contents(const GridCoord1D &coord) const;
[[nodiscard]] std::optional<std::shared_ptr<std::set<AgentID>>>
get_location_contents(const GridCoord1D &coord) const;
/**
* @brief Inquire to whether the grid wraps in the `x` dimension.
@@ -192,10 +194,10 @@ namespace kami {
* @param[in] include_center should the center-point, occupied by the agent,
* be in the list.
*
* @return a vector of `GridCoord1D` that includes all of the coordinates
* @return an `unordered_set` of `GridCoord1D` that includes all of the coordinates
* for all adjacent points.
*/
[[nodiscard]] std::unique_ptr<std::vector<GridCoord1D>>
[[nodiscard]] std::optional<std::shared_ptr<std::unordered_set<GridCoord1D>>>
get_neighborhood(const AgentID agent_id, const bool include_center) const;
/**
@@ -205,10 +207,10 @@ namespace kami {
* @param[in] include_center should the center-point, occupied by the agent,
* be in the list.
*
* @return a vector of `GridCoord1D` that includes all of the coordinates
* @return an `unordered_set` of `GridCoord1D` that includes all of the coordinates
* for all adjacent points.
*/
[[nodiscard]] std::unique_ptr<std::vector<GridCoord1D>>
[[nodiscard]] std::optional<std::shared_ptr<std::unordered_set<GridCoord1D>>>
get_neighborhood(const GridCoord1D &coord, const bool include_center) const;
/**
@@ -220,7 +222,7 @@ namespace kami {
protected:
/**
* @brief A vector containing the `AgentID`s of all agents assigned to this
* @brief An `unordered_set` containing the `AgentID`s of all agents assigned to this
* grid.
*/
std::unique_ptr<std::unordered_multimap<GridCoord1D, AgentID>> _agent_grid;

20
include/kami/grid2d.h
View File

@@ -31,9 +31,10 @@
#include <iostream>
#include <map>
#include <optional>
#include <memory>
#include <set>
#include <unordered_map>
#include <vector>
#include <unordered_set>
#include <kami/domain.h>
#include <kami/grid.h>
@@ -181,12 +182,13 @@ namespace kami {
*
* @param[in] coord the coordinates of the query.
*
* @return a pointer to a `vector` of `AgentID`s. The pointer is to the
* @return a pointer to a `set` of `AgentID`s. The pointer is to the
* internal copy of the agent list at the location, therefore, any changes
* to that object will update the state of the gird. Further, the pointer
* should not be deleted when no longer used.
*/
[[nodiscard]] std::unique_ptr<std::vector<AgentID>> get_location_contents(const GridCoord2D &coord) const;
[[nodiscard]] std::optional<std::shared_ptr<std::set<AgentID>>>
get_location_contents(const GridCoord2D &coord) const;
/**
* @brief Inquire to whether the grid wraps in the `x` dimension.
@@ -210,12 +212,12 @@ namespace kami {
* @param[in] include_center should the center-point, occupied by the agent,
* be in the list.
*
* @return a vector of `GridCoord1D` that includes all of the coordinates
* @return a set of `GridCoord1D` that includes all of the coordinates
* for all adjacent points.
*
* @see `NeighborhoodType`
*/
[[nodiscard]] std::unique_ptr<std::vector<GridCoord2D>>
[[nodiscard]] std::optional<std::shared_ptr<std::unordered_set<GridCoord2D>>>
get_neighborhood(AgentID agent_id, bool include_center, GridNeighborhoodType neighborhood_type) const;
/**
@@ -226,12 +228,12 @@ namespace kami {
* @param[in] include_center should the center-point, occupied by the agent,
* be in the list.
*
* @return a vector of `GridCoord1D` that includes all of the coordinates
* @return a set of `GridCoord2D` that includes all of the coordinates
* for all adjacent points.
*
* @see `NeighborhoodType`
*/
[[nodiscard]] std::unique_ptr<std::vector<GridCoord2D>>
[[nodiscard]] std::optional<std::shared_ptr<std::unordered_set<GridCoord2D>>>
get_neighborhood(const GridCoord2D &coord, bool include_center, GridNeighborhoodType neighborhood_type) const;
/**
@@ -250,7 +252,7 @@ namespace kami {
protected:
/**
* @brief A vector containing the `AgentID`s of all agents assigned to this
* @brief A map containing the `AgentID`s of all agents assigned to this
* grid.
*/
std::unique_ptr<std::unordered_multimap<GridCoord2D, AgentID>> _agent_grid;

32
src/libkami/grid1d.cc
View File

@@ -30,9 +30,10 @@
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
namespace kami {
@@ -109,51 +110,54 @@ namespace kami {
return add_agent(agent_id, coord);
}
std::unique_ptr<std::vector<GridCoord1D>>
std::optional<std::shared_ptr<std::unordered_set<GridCoord1D>>>
Grid1D::get_neighborhood(const AgentID agent_id, const bool include_center) const {
auto coord = get_location_by_agent(agent_id);
if (!coord)
return std::nullopt;
return std::move(get_neighborhood(coord.value(), include_center));
}
std::unique_ptr<std::vector<GridCoord1D>>
std::optional<std::shared_ptr<std::unordered_set<GridCoord1D>>>
Grid1D::get_neighborhood(const GridCoord1D &coord, const bool include_center) const {
auto neighborhood = std::make_unique<std::vector<GridCoord1D>>();
auto neighborhood = std::make_shared<std::unordered_set<GridCoord1D>>();
auto x = coord.get_x_location();
// We assume our starting position is valid
if (include_center)
neighborhood->push_back(coord);
neighborhood->insert(coord);
// E, W
{
auto new_location = coord_wrap(GridCoord1D(x + 1));
if (is_location_valid(new_location))
neighborhood->push_back(coord_wrap(new_location));
neighborhood->insert(coord_wrap(new_location));
}
{
auto new_location = coord_wrap(GridCoord1D(x - 1));
if (is_location_valid(new_location))
neighborhood->push_back(coord_wrap(new_location));
neighborhood->insert(coord_wrap(new_location));
}
return std::move(neighborhood);
}
std::unique_ptr<std::vector<AgentID>> Grid1D::get_location_contents(const GridCoord1D &coord) const {
auto agent_ids = std::make_unique<std::vector<AgentID>>();
std::optional<std::shared_ptr<std::set<AgentID>>> Grid1D::get_location_contents(const GridCoord1D &coord) const {
auto agent_ids = std::make_shared<std::set<AgentID>>();
if (!is_location_valid(coord))
return std::move(agent_ids);
return std::nullopt;
if (is_location_empty(coord))
return std::move(agent_ids);
return agent_ids;
auto agent_range = _agent_grid->equal_range(coord);
if (agent_range.first == agent_range.second)
return std::move(agent_ids);
return agent_ids;
for (auto i = agent_range.first; i != agent_range.second; i++)
agent_ids->push_back(i->second);
return std::move(agent_ids);
agent_ids->insert(i->second);
return agent_ids;
}
bool Grid1D::get_wrap_x() const { return _wrap_x; }

41
src/libkami/grid2d.cc
View File

@@ -118,45 +118,47 @@ namespace kami {
return add_agent(agent_id, coord);
}
std::unique_ptr<std::vector<GridCoord2D>>
std::optional<std::shared_ptr<std::unordered_set<GridCoord2D>>>
Grid2D::get_neighborhood(const AgentID agent_id, const bool include_center,
const GridNeighborhoodType neighborhood_type) const {
auto coord = get_location_by_agent(agent_id);
if (!coord)
return std::nullopt;
return std::move(get_neighborhood(coord.value(), include_center, neighborhood_type));
}
std::unique_ptr<std::vector<GridCoord2D>>
std::optional<std::shared_ptr<std::unordered_set<GridCoord2D>>>
Grid2D::get_neighborhood(const GridCoord2D &coord, const bool include_center,
const GridNeighborhoodType neighborhood_type) const {
auto neighborhood = std::make_unique<std::vector<GridCoord2D>>();
auto neighborhood = std::make_unique<std::unordered_set<GridCoord2D>>();
auto x = coord.get_x_location();
auto y = coord.get_y_location();
// We assume our starting position is valid
if (include_center)
neighborhood->push_back(coord);
neighborhood->insert(coord);
// N, E, S, W
{
auto new_location = coord_wrap(GridCoord2D(x, y - 1));
if (is_location_valid(new_location))
neighborhood->push_back(coord_wrap(new_location));
neighborhood->insert(coord_wrap(new_location));
}
{
auto new_location = coord_wrap(GridCoord2D(x, y + 1));
if (is_location_valid(new_location))
neighborhood->push_back(coord_wrap(new_location));
neighborhood->insert(coord_wrap(new_location));
}
{
auto new_location = coord_wrap(GridCoord2D(x + 1, y));
if (is_location_valid(new_location))
neighborhood->push_back(coord_wrap(new_location));
neighborhood->insert(coord_wrap(new_location));
}
{
auto new_location = coord_wrap(GridCoord2D(x - 1, y));
if (is_location_valid(new_location))
neighborhood->push_back(coord_wrap(new_location));
neighborhood->insert(coord_wrap(new_location));
}
if (neighborhood_type == GridNeighborhoodType::Moore) {
@@ -164,42 +166,43 @@ namespace kami {
{
auto new_location = coord_wrap(GridCoord2D(x + 1, y - 1));
if (is_location_valid(new_location))
neighborhood->push_back(coord_wrap(new_location));
neighborhood->insert(coord_wrap(new_location));
}
{
auto new_location = coord_wrap(GridCoord2D(x + 1, y + 1));
if (is_location_valid(new_location))
neighborhood->push_back(coord_wrap(new_location));
neighborhood->insert(coord_wrap(new_location));
}
{
auto new_location = coord_wrap(GridCoord2D(x - 1, y + 1));
if (is_location_valid(new_location))
neighborhood->push_back(coord_wrap(new_location));
neighborhood->insert(coord_wrap(new_location));
}
{
auto new_location = coord_wrap(GridCoord2D(x - 1, y - 1));
if (is_location_valid(new_location))
neighborhood->push_back(coord_wrap(new_location));
neighborhood->insert(coord_wrap(new_location));
}
}
return std::move(neighborhood);
}
std::unique_ptr<std::vector<AgentID>> Grid2D::get_location_contents(const GridCoord2D &coord) const {
auto agent_ids = std::make_unique<std::vector<AgentID>>();
std::optional<std::shared_ptr<std::set<AgentID>>> Grid2D::get_location_contents(const GridCoord2D &coord) const {
auto agent_ids = std::make_shared<std::set<AgentID>>();
if (!is_location_valid(coord))
return std::move(agent_ids);
return std::nullopt;
if (is_location_empty(coord))
return std::move(agent_ids);
return agent_ids;
auto agent_range = _agent_grid->equal_range(coord);
if (agent_range.first == agent_range.second)
return std::move(agent_ids);
return agent_ids;
for (auto i = agent_range.first; i != agent_range.second; i++)
agent_ids->push_back(i->second);
return std::move(agent_ids);
agent_ids->insert(i->second);
return agent_ids;
}
bool Grid2D::get_wrap_x() const { return _wrap_x; }

40
test/CMakeLists.txt
View File

@@ -21,6 +21,22 @@ create_test(
PUBLIC_COMPILE_FEATURES ${COVERAGE_FLAGS}
)
create_test(
NAME unit-kami-gridcoord1d
SOURCES unit-kami-gridcoord1d.cc
PUBLIC_LINKED_TARGETS gmock gtest kami::libkami Threads::Threads
COMMAND unit-kami-gridcoord1d
PUBLIC_COMPILE_FEATURES ${COVERAGE_FLAGS}
)
create_test(
NAME unit-kami-gridcoord2d
SOURCES unit-kami-gridcoord2d.cc
PUBLIC_LINKED_TARGETS gmock gtest kami::libkami Threads::Threads
COMMAND unit-kami-gridcoord2d
PUBLIC_COMPILE_FEATURES ${COVERAGE_FLAGS}
)
create_test(
NAME unit-kami-model
SOURCES unit-kami-model.cc
@@ -37,6 +53,30 @@ create_test(
PUBLIC_COMPILE_FEATURES ${COVERAGE_FLAGS}
)
create_test(
NAME unit-kami-multigrid2d
SOURCES unit-kami-multigrid2d.cc
PUBLIC_LINKED_TARGETS gmock gtest kami::libkami Threads::Threads
COMMAND unit-kami-multigrid2d
PUBLIC_COMPILE_FEATURES ${COVERAGE_FLAGS}
)
create_test(
NAME unit-kami-sologrid1d
SOURCES unit-kami-sologrid1d.cc
PUBLIC_LINKED_TARGETS gmock gtest kami::libkami Threads::Threads
COMMAND unit-kami-sologrid1d
PUBLIC_COMPILE_FEATURES ${COVERAGE_FLAGS}
)
create_test(
NAME unit-kami-sologrid2d
SOURCES unit-kami-sologrid2d.cc
PUBLIC_LINKED_TARGETS gmock gtest kami::libkami Threads::Threads
COMMAND unit-kami-sologrid2d
PUBLIC_COMPILE_FEATURES ${COVERAGE_FLAGS}
)
create_test(
NAME unit-kami-stagedagent
SOURCES unit-kami-stagedagent.cc

105
test/unit-kami-gridcoord1d.cc Normal file
View File

@@ -0,0 +1,105 @@
/*-
* Copyright (c) 2022 The Johns Hopkins University Applied Physics
* Laboratory LLC
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation files
* (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <kami/grid1d.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
TEST(GridCoord1D, DefaultConstructor) {
const kami::GridCoord1D gridcoord1d_foo(0);
const kami::GridCoord1D gridcoord1d_bar(1);
const kami::GridCoord1D gridcoord1d_baz(-1);
const kami::GridCoord1D gridcoord1d_qux(0);
EXPECT_EQ(gridcoord1d_foo, gridcoord1d_foo);
EXPECT_EQ(gridcoord1d_foo, gridcoord1d_qux);
EXPECT_NE(gridcoord1d_foo, gridcoord1d_bar);
EXPECT_NE(gridcoord1d_foo, gridcoord1d_baz);
EXPECT_NE(gridcoord1d_bar, gridcoord1d_baz);
}
TEST(GridCoord1D, to_string) {
const kami::GridCoord1D gridcoord1d_foo(0);
const kami::GridCoord1D gridcoord1d_bar(1);
const kami::GridCoord1D gridcoord1d_baz(-1);
EXPECT_THAT(gridcoord1d_foo.to_string(), "(0)");
EXPECT_THAT(gridcoord1d_bar.to_string(), "(1)");
EXPECT_THAT(gridcoord1d_baz.to_string(), "(-1)");
}
TEST(GridCoord1D, Equality) {
const kami::GridCoord1D gridcoord1d_foo(0);
const kami::GridCoord1D gridcoord1d_bar(1);
const kami::GridCoord1D gridcoord1d_baz(-1);
const kami::GridCoord1D gridcoord1d_qux(0);
EXPECT_TRUE(gridcoord1d_foo == gridcoord1d_foo);
EXPECT_TRUE(gridcoord1d_foo == gridcoord1d_qux);
EXPECT_FALSE(gridcoord1d_foo == gridcoord1d_bar);
EXPECT_FALSE(gridcoord1d_foo == gridcoord1d_baz);
EXPECT_FALSE(gridcoord1d_bar == gridcoord1d_baz);
}
TEST(GridCoord1D, Inequality) {
const kami::GridCoord1D gridcoord1d_foo(0);
const kami::GridCoord1D gridcoord1d_bar(1);
const kami::GridCoord1D gridcoord1d_baz(-1);
const kami::GridCoord1D gridcoord1d_qux(0);
EXPECT_FALSE(gridcoord1d_foo != gridcoord1d_foo);
EXPECT_FALSE(gridcoord1d_foo != gridcoord1d_qux);
EXPECT_TRUE(gridcoord1d_foo != gridcoord1d_bar);
EXPECT_TRUE(gridcoord1d_foo != gridcoord1d_baz);
EXPECT_TRUE(gridcoord1d_bar != gridcoord1d_baz);
}
TEST(GridCoord1D, get_x_location) {
const kami::GridCoord1D gridcoord1d_foo(0);
const kami::GridCoord1D gridcoord1d_bar(1);
const kami::GridCoord1D gridcoord1d_baz(-1);
const kami::GridCoord1D gridcoord1d_qux(0);
EXPECT_TRUE(gridcoord1d_foo.get_x_location() == 0);
EXPECT_TRUE(gridcoord1d_bar.get_x_location() == 1);
EXPECT_TRUE(gridcoord1d_baz.get_x_location() == -1);
EXPECT_TRUE(gridcoord1d_foo.get_x_location() == gridcoord1d_foo.get_x_location());
EXPECT_TRUE(gridcoord1d_foo.get_x_location() == gridcoord1d_qux.get_x_location());
EXPECT_FALSE(gridcoord1d_foo.get_x_location() == gridcoord1d_bar.get_x_location());
EXPECT_FALSE(gridcoord1d_foo.get_x_location() == gridcoord1d_baz.get_x_location());
EXPECT_FALSE(gridcoord1d_bar.get_x_location() == gridcoord1d_baz.get_x_location());
}
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

147
test/unit-kami-gridcoord2d.cc Normal file
View File

@@ -0,0 +1,147 @@
/*-
* Copyright (c) 2022 The Johns Hopkins University Applied Physics
* Laboratory LLC
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation files
* (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <kami/grid2d.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
TEST(GridCoord2D, DefaultConstructor) {
const kami::GridCoord2D gridcoord2d_foo(0, 0);
const kami::GridCoord2D gridcoord2d_bar(1, 1);
const kami::GridCoord2D gridcoord2d_baz(-1, -1);
const kami::GridCoord2D gridcoord2d_qux(0, 1);
const kami::GridCoord2D gridcoord2d_qu2(1, 0);
EXPECT_EQ(gridcoord2d_foo, gridcoord2d_foo);
EXPECT_NE(gridcoord2d_foo, gridcoord2d_bar);
EXPECT_NE(gridcoord2d_foo, gridcoord2d_baz);
EXPECT_NE(gridcoord2d_bar, gridcoord2d_baz);
EXPECT_NE(gridcoord2d_foo, gridcoord2d_qux);
EXPECT_NE(gridcoord2d_foo, gridcoord2d_qu2);
}
TEST(GridCoord2D, to_string) {
const kami::GridCoord2D gridcoord2d_foo(0, 0);
const kami::GridCoord2D gridcoord2d_bar(1, 1);
const kami::GridCoord2D gridcoord2d_baz(-1, -1);
const kami::GridCoord2D gridcoord2d_qux(0, 1);
const kami::GridCoord2D gridcoord2d_qu2(1, 0);
EXPECT_THAT(gridcoord2d_foo.to_string(), "(0, 0)");
EXPECT_THAT(gridcoord2d_bar.to_string(), "(1, 1)");
EXPECT_THAT(gridcoord2d_baz.to_string(), "(-1, -1)");
EXPECT_THAT(gridcoord2d_qux.to_string(), "(0, 1)");
EXPECT_THAT(gridcoord2d_qu2.to_string(), "(1, 0)");
}
TEST(GridCoord2D, Equality) {
const kami::GridCoord2D gridcoord2d_foo(0, 0);
const kami::GridCoord2D gridcoord2d_bar(1, 1);
const kami::GridCoord2D gridcoord2d_baz(-1, -1);
const kami::GridCoord2D gridcoord2d_qux(0, 1);
const kami::GridCoord2D gridcoord2d_qu2(1, 0);
EXPECT_TRUE(gridcoord2d_foo == gridcoord2d_foo);
EXPECT_FALSE(gridcoord2d_foo == gridcoord2d_bar);
EXPECT_FALSE(gridcoord2d_foo == gridcoord2d_baz);
EXPECT_FALSE(gridcoord2d_bar == gridcoord2d_baz);
EXPECT_FALSE(gridcoord2d_foo == gridcoord2d_qux);
EXPECT_FALSE(gridcoord2d_qux == gridcoord2d_qu2);
EXPECT_FALSE(gridcoord2d_qux == gridcoord2d_qu2);
}
TEST(GridCoord2D, Inequality) {
const kami::GridCoord2D gridcoord2d_foo(0, 0);
const kami::GridCoord2D gridcoord2d_bar(1, 1);
const kami::GridCoord2D gridcoord2d_baz(-1, -1);
const kami::GridCoord2D gridcoord2d_qux(0, 1);
const kami::GridCoord2D gridcoord2d_qu2(1, 0);
EXPECT_FALSE(gridcoord2d_foo != gridcoord2d_foo);
EXPECT_TRUE(gridcoord2d_foo != gridcoord2d_qux);
EXPECT_TRUE(gridcoord2d_foo != gridcoord2d_bar);
EXPECT_TRUE(gridcoord2d_foo != gridcoord2d_baz);
EXPECT_TRUE(gridcoord2d_bar != gridcoord2d_baz);
EXPECT_TRUE(gridcoord2d_qux != gridcoord2d_qu2);
}
TEST(GridCoord2D, get_x_location) {
const kami::GridCoord2D gridcoord2d_foo(0, 0);
const kami::GridCoord2D gridcoord2d_bar(1, 1);
const kami::GridCoord2D gridcoord2d_baz(-1, -1);
const kami::GridCoord2D gridcoord2d_qux(0, 1);
const kami::GridCoord2D gridcoord2d_qu2(1, 0);
EXPECT_TRUE(gridcoord2d_foo.get_x_location() == 0);
EXPECT_TRUE(gridcoord2d_bar.get_x_location() == 1);
EXPECT_TRUE(gridcoord2d_baz.get_x_location() == -1);
EXPECT_FALSE(gridcoord2d_qux.get_x_location() == -1);
EXPECT_FALSE(gridcoord2d_qu2.get_x_location() == -1);
EXPECT_TRUE(gridcoord2d_foo.get_x_location() == gridcoord2d_foo.get_x_location());
EXPECT_TRUE(gridcoord2d_foo.get_x_location() == gridcoord2d_qux.get_x_location());
EXPECT_TRUE(gridcoord2d_bar.get_x_location() == gridcoord2d_qu2.get_x_location());
EXPECT_FALSE(gridcoord2d_foo.get_x_location() == gridcoord2d_bar.get_x_location());
EXPECT_FALSE(gridcoord2d_foo.get_x_location() == gridcoord2d_baz.get_x_location());
EXPECT_FALSE(gridcoord2d_bar.get_x_location() == gridcoord2d_baz.get_x_location());
EXPECT_FALSE(gridcoord2d_foo.get_x_location() == gridcoord2d_baz.get_x_location());
EXPECT_FALSE(gridcoord2d_qux.get_x_location() == gridcoord2d_qu2.get_x_location());
}
TEST(GridCoord2D, get_y_location) {
const kami::GridCoord2D gridcoord2d_foo(0, 0);
const kami::GridCoord2D gridcoord2d_bar(1, 1);
const kami::GridCoord2D gridcoord2d_baz(-1, -1);
const kami::GridCoord2D gridcoord2d_qux(0, 1);
const kami::GridCoord2D gridcoord2d_qu2(1, 0);
EXPECT_TRUE(gridcoord2d_foo.get_y_location() == 0);
EXPECT_TRUE(gridcoord2d_bar.get_y_location() == 1);
EXPECT_TRUE(gridcoord2d_baz.get_y_location() == -1);
EXPECT_FALSE(gridcoord2d_qux.get_y_location() == -1);
EXPECT_FALSE(gridcoord2d_qu2.get_y_location() == -1);
EXPECT_TRUE(gridcoord2d_foo.get_y_location() == gridcoord2d_foo.get_y_location());
EXPECT_TRUE(gridcoord2d_bar.get_y_location() == gridcoord2d_qux.get_y_location());
EXPECT_FALSE(gridcoord2d_foo.get_y_location() == gridcoord2d_bar.get_y_location());
EXPECT_FALSE(gridcoord2d_foo.get_y_location() == gridcoord2d_baz.get_y_location());
EXPECT_FALSE(gridcoord2d_bar.get_y_location() == gridcoord2d_baz.get_y_location());
EXPECT_FALSE(gridcoord2d_foo.get_y_location() == gridcoord2d_baz.get_y_location());
EXPECT_FALSE(gridcoord2d_qux.get_y_location() == gridcoord2d_qu2.get_y_location());
EXPECT_FALSE(gridcoord2d_bar.get_y_location() == gridcoord2d_qu2.get_y_location());
}
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

407
test/unit-kami-multigrid1d.cc
View File

@@ -23,25 +23,32 @@
* SOFTWARE.
*/
#include <algorithm>
#include <iterator>
#include <set>
#include <unordered_set>
#include <kami/agent.h>
#include <kami/multigrid1d.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
using namespace kami;
TEST(MultiGrid1D, DefaultConstructor) {
// There is really no way this can go wrong, but
// we add this check anyway in case of future
// changes.
EXPECT_NO_THROW(
kami::MultiGrid1D multigrid1d_foo(10, true);
MultiGrid1D multigrid1d_foo(10, true);
);
}
TEST(MultiGrid1D, add_agent) {
kami::MultiGrid1D multigrid1d_foo(10, true);
const kami::AgentID agent_id_foo, agent_id_bar;
const kami::GridCoord1D coord2(2), coord3(3);
MultiGrid1D multigrid1d_foo(10, true);
const AgentID agent_id_foo, agent_id_bar;
const GridCoord1D coord2(2), coord3(3);
{
auto agent_id_baz = multigrid1d_foo.add_agent(agent_id_foo, coord2);
@@ -60,6 +67,398 @@ TEST(MultiGrid1D, add_agent) {
}
}
TEST(MultiGrid1D, delete_agent) {
const AgentID agent_id_foo, agent_id_bar;
const GridCoord1D coord2(2), coord3(3);
{
MultiGrid1D multigrid1d_foo(10, true);
static_cast<void>(multigrid1d_foo.add_agent(agent_id_foo, coord2));
auto agent_id_baz = multigrid1d_foo.delete_agent(agent_id_foo);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
MultiGrid1D multigrid1d_foo(10, true);
static_cast<void>(multigrid1d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(multigrid1d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = multigrid1d_foo.delete_agent(agent_id_foo);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
MultiGrid1D multigrid1d_foo(10, true);
static_cast<void>(multigrid1d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(multigrid1d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = multigrid1d_foo.delete_agent(agent_id_bar);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_bar);
}
{
MultiGrid1D multigrid1d_foo(10, true);
static_cast<void>(multigrid1d_foo.add_agent(agent_id_foo, coord2));
auto agent_id_baz = multigrid1d_foo.delete_agent(agent_id_foo, coord2);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
MultiGrid1D multigrid1d_foo(10, true);
static_cast<void>(multigrid1d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(multigrid1d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = multigrid1d_foo.delete_agent(agent_id_foo, coord2);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
MultiGrid1D multigrid1d_foo(10, true);
static_cast<void>(multigrid1d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(multigrid1d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = multigrid1d_foo.delete_agent(agent_id_bar, coord2);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_bar);
}
{
MultiGrid1D multigrid1d_foo(10, true);
static_cast<void>(multigrid1d_foo.add_agent(agent_id_foo, coord2));
auto agent_id_baz = multigrid1d_foo.delete_agent(agent_id_foo, coord3);
EXPECT_FALSE(agent_id_baz);
}
{
MultiGrid1D multigrid1d_foo(10, true);
static_cast<void>(multigrid1d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(multigrid1d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = multigrid1d_foo.delete_agent(agent_id_foo, coord3);
EXPECT_FALSE(agent_id_baz);
}
{
MultiGrid1D multigrid1d_foo(10, true);
static_cast<void>(multigrid1d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(multigrid1d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = multigrid1d_foo.delete_agent(agent_id_bar, coord3);
EXPECT_FALSE(agent_id_baz);
}
}
TEST(MultiGrid1D, is_location_valid) {
MultiGrid1D multigrid1d_foo(10, true);
const AgentID agent_id_foo, agent_id_bar;
const GridCoord1D coordm1(-1), coord0(0), coord2(2), coord3(3), coord10(10), coord100(100);
{
EXPECT_TRUE(multigrid1d_foo.is_location_valid(coord0));
EXPECT_TRUE(multigrid1d_foo.is_location_valid(coord2));
EXPECT_TRUE(multigrid1d_foo.is_location_valid(coord2));
EXPECT_FALSE(multigrid1d_foo.is_location_valid(coordm1));
EXPECT_FALSE(multigrid1d_foo.is_location_valid(coord10));
EXPECT_FALSE(multigrid1d_foo.is_location_valid(coord100));
}
}
TEST(MultiGrid1D, is_location_empty) {
const AgentID agent_id_foo, agent_id_bar;
const GridCoord1D coord2(2), coord3(3);
{
MultiGrid1D multigrid1d_foo(10, true);
EXPECT_TRUE(multigrid1d_foo.is_location_empty(coord2));
EXPECT_TRUE(multigrid1d_foo.is_location_empty(coord3));
}
{
MultiGrid1D multigrid1d_foo(10, true);
static_cast<void>(multigrid1d_foo.add_agent(agent_id_foo, coord2));
EXPECT_FALSE(multigrid1d_foo.is_location_empty(coord2));
EXPECT_TRUE(multigrid1d_foo.is_location_empty(coord3));
}
{
MultiGrid1D multigrid1d_foo(10, true);
static_cast<void>(multigrid1d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(multigrid1d_foo.add_agent(agent_id_bar, coord2));
EXPECT_FALSE(multigrid1d_foo.is_location_empty(coord2));
EXPECT_TRUE(multigrid1d_foo.is_location_empty(coord3));
}
}
TEST(MultiGrid1D, move_agent) {
const AgentID agent_id_foo, agent_id_bar;
const GridCoord1D coord2(2), coord3(3), coord7(7), coord10(10);
{
MultiGrid1D multigrid1d_foo(10, true);
static_cast<void>(multigrid1d_foo.add_agent(agent_id_foo, coord2));
auto agent_id_baz = multigrid1d_foo.move_agent(agent_id_foo, coord7);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
MultiGrid1D multigrid1d_foo(10, true);
static_cast<void>(multigrid1d_foo.add_agent(agent_id_foo, coord2));
auto agent_id_baz = multigrid1d_foo.move_agent(agent_id_foo, coord10);
EXPECT_FALSE(agent_id_baz);
}
{
MultiGrid1D multigrid1d_foo(10, true);
static_cast<void>(multigrid1d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(multigrid1d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = multigrid1d_foo.move_agent(agent_id_foo, coord2);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
MultiGrid1D multigrid1d_foo(10, true);
static_cast<void>(multigrid1d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(multigrid1d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = multigrid1d_foo.move_agent(agent_id_foo, coord7);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
}
TEST(MultiGrid1D, get_neighborhood) {
const AgentID agent_id_foo, agent_id_bar;
const GridCoord1D coord0(0), coord1(1), coord2(2), coord3(3), coord9(9);
{
MultiGrid1D multigrid1d_foo(10, true);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord1, coord9});
auto rval = multigrid1d_foo.get_neighborhood(coord0, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid1D multigrid1d_foo(10, true);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord1, coord2});
auto rval = multigrid1d_foo.get_neighborhood(coord1, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid1D multigrid1d_foo(10, false);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord1});
auto rval = multigrid1d_foo.get_neighborhood(coord0, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid1D multigrid1d_foo(10, false);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord1, coord2});
auto rval = multigrid1d_foo.get_neighborhood(coord1, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid1D multigrid1d_foo(10, true);
auto tval = std::unordered_set<GridCoord1D>({coord1, coord9});
auto rval = multigrid1d_foo.get_neighborhood(coord0, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid1D multigrid1d_foo(10, true);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord2});
auto rval = multigrid1d_foo.get_neighborhood(coord1, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid1D multigrid1d_foo(10, false);
auto tval = std::unordered_set<GridCoord1D>({coord1});
auto rval = multigrid1d_foo.get_neighborhood(coord0, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid1D multigrid1d_foo(10, false);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord2});
auto rval = multigrid1d_foo.get_neighborhood(coord1, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid1D multigrid1d_foo(10, true);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord1, coord9});
auto rval = multigrid1d_foo.get_neighborhood(agent_id_foo, true);
EXPECT_FALSE(rval);
}
{
MultiGrid1D multigrid1d_foo(10, true);
multigrid1d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord1, coord9});
auto rval = multigrid1d_foo.get_neighborhood(agent_id_foo, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid1D multigrid1d_foo(10, true);
multigrid1d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord1, coord2});
auto rval = multigrid1d_foo.get_neighborhood(agent_id_foo, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid1D multigrid1d_foo(10, false);
multigrid1d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord1});
auto rval = multigrid1d_foo.get_neighborhood(agent_id_foo, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid1D multigrid1d_foo(10, false);
multigrid1d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord1, coord2});
auto rval = multigrid1d_foo.get_neighborhood(agent_id_foo, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid1D multigrid1d_foo(10, true);
multigrid1d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord1D>({coord1, coord9});
auto rval = multigrid1d_foo.get_neighborhood(agent_id_foo, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid1D multigrid1d_foo(10, true);
multigrid1d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord2});
auto rval = multigrid1d_foo.get_neighborhood(agent_id_foo, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid1D multigrid1d_foo(10, false);
multigrid1d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord1D>({coord1});
auto rval = multigrid1d_foo.get_neighborhood(agent_id_foo, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid1D multigrid1d_foo(10, false);
multigrid1d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord2});
auto rval = multigrid1d_foo.get_neighborhood(agent_id_foo, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
}
TEST(MultiGrid1D, get_location_by_agent) {
const AgentID agent_id_foo, agent_id_bar;
const GridCoord1D coord2(2), coord3(3);
{
MultiGrid1D multigrid1d_foo(10, true);
EXPECT_FALSE(multigrid1d_foo.get_location_by_agent(agent_id_foo));
EXPECT_FALSE(multigrid1d_foo.get_location_by_agent(agent_id_bar));
}
{
MultiGrid1D multigrid1d_foo(10, true);
static_cast<void>(multigrid1d_foo.add_agent(agent_id_foo, coord2));
auto local = multigrid1d_foo.get_location_by_agent(agent_id_foo);
EXPECT_TRUE(local);
EXPECT_EQ(local, coord2);
EXPECT_FALSE(multigrid1d_foo.get_location_by_agent(agent_id_bar));
}
}
TEST(MultiGrid1D, get_location_contents) {
const AgentID agent_id_foo, agent_id_bar, agent_id_baz;
const GridCoord1D coord0(0), coord1(1), coord9(9), coord10(10);
{
MultiGrid1D multigrid1d_foo(10, true);
auto agent_list_foo = multigrid1d_foo.get_location_contents(coord10);
EXPECT_FALSE(agent_list_foo);
}
{
MultiGrid1D multigrid1d_foo(10, true);
auto agent_list_foo = multigrid1d_foo.get_location_contents(coord1);
EXPECT_TRUE(agent_list_foo);
EXPECT_TRUE(agent_list_foo.value()->empty());
}
{
MultiGrid1D multigrid1d_foo(10, true);
static_cast<void>(multigrid1d_foo.add_agent(agent_id_foo, coord1));
static_cast<void>(multigrid1d_foo.add_agent(agent_id_bar, coord1));
static_cast<void>(multigrid1d_foo.add_agent(agent_id_baz, coord1));
auto tval = std::set<AgentID>({agent_id_foo, agent_id_bar, agent_id_baz});
auto rval = multigrid1d_foo.get_location_contents(coord1);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid1D multigrid1d_foo(10, true);
static_cast<void>(multigrid1d_foo.add_agent(agent_id_foo, coord1));
static_cast<void>(multigrid1d_foo.add_agent(agent_id_bar, coord1));
static_cast<void>(multigrid1d_foo.add_agent(agent_id_baz, coord9));
auto tval = std::set<AgentID>({agent_id_foo, agent_id_bar});
auto rval = multigrid1d_foo.get_location_contents(coord1);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
}
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);

727
test/unit-kami-multigrid2d.cc Normal file
View File

@@ -0,0 +1,727 @@
/*-
* Copyright (c) 2022 The Johns Hopkins University Applied Physics
* Laboratory LLC
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation files
* (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <algorithm>
#include <iterator>
#include <set>
#include <unordered_set>
#include <kami/agent.h>
#include <kami/multigrid2d.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
using namespace kami;
TEST(MultiGrid2D, DefaultConstructor) {
// There is really no way this can go wrong, but
// we add this check anyway in case of future
// changes.
EXPECT_NO_THROW(
MultiGrid2D multigrid2d_foo(10, 10, true, true);
);
}
TEST(MultiGrid2D, add_agent) {
MultiGrid2D multigrid2d_foo(10, 10, true, true);
const AgentID agent_id_foo, agent_id_bar;
const GridCoord2D coord2(2, 5), coord3(3, 7);
{
auto agent_id_baz = multigrid2d_foo.add_agent(agent_id_foo, coord2);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
auto agent_id_baz = multigrid2d_foo.add_agent(agent_id_bar, coord2);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_bar);
}
{
auto agent_id_baz = multigrid2d_foo.add_agent(agent_id_bar, coord3);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_bar);
}
}
TEST(MultiGrid2D, delete_agent) {
const AgentID agent_id_foo, agent_id_bar;
const GridCoord2D coord2(2, 5), coord3(3, 7);
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
static_cast<void>(multigrid2d_foo.add_agent(agent_id_foo, coord2));
auto agent_id_baz = multigrid2d_foo.delete_agent(agent_id_foo);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
static_cast<void>(multigrid2d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(multigrid2d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = multigrid2d_foo.delete_agent(agent_id_foo);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
static_cast<void>(multigrid2d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(multigrid2d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = multigrid2d_foo.delete_agent(agent_id_bar);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_bar);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
static_cast<void>(multigrid2d_foo.add_agent(agent_id_foo, coord2));
auto agent_id_baz = multigrid2d_foo.delete_agent(agent_id_foo, coord2);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
static_cast<void>(multigrid2d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(multigrid2d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = multigrid2d_foo.delete_agent(agent_id_foo, coord2);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
static_cast<void>(multigrid2d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(multigrid2d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = multigrid2d_foo.delete_agent(agent_id_bar, coord2);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_bar);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
static_cast<void>(multigrid2d_foo.add_agent(agent_id_foo, coord2));
auto agent_id_baz = multigrid2d_foo.delete_agent(agent_id_foo, coord3);
EXPECT_FALSE(agent_id_baz);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
static_cast<void>(multigrid2d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(multigrid2d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = multigrid2d_foo.delete_agent(agent_id_foo, coord3);
EXPECT_FALSE(agent_id_baz);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
static_cast<void>(multigrid2d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(multigrid2d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = multigrid2d_foo.delete_agent(agent_id_bar, coord3);
EXPECT_FALSE(agent_id_baz);
}
}
TEST(MultiGrid2D, is_location_valid) {
MultiGrid2D multigrid2d_foo(10, 10, true, true);
const AgentID agent_id_foo, agent_id_bar;
const GridCoord2D coordm1(-1, -1), coord0(0, 0), coord2(2, 5), coord3(3, 7), coord10(10, 5), coord100(100, 100);
{
EXPECT_TRUE(multigrid2d_foo.is_location_valid(coord0));
EXPECT_TRUE(multigrid2d_foo.is_location_valid(coord2));
EXPECT_TRUE(multigrid2d_foo.is_location_valid(coord2));
EXPECT_FALSE(multigrid2d_foo.is_location_valid(coordm1));
EXPECT_FALSE(multigrid2d_foo.is_location_valid(coord10));
EXPECT_FALSE(multigrid2d_foo.is_location_valid(coord100));
}
}
TEST(MultiGrid2D, is_location_empty) {
const AgentID agent_id_foo, agent_id_bar;
const GridCoord2D coord2(2, 5), coord3(3, 7);
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
EXPECT_TRUE(multigrid2d_foo.is_location_empty(coord2));
EXPECT_TRUE(multigrid2d_foo.is_location_empty(coord3));
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
static_cast<void>(multigrid2d_foo.add_agent(agent_id_foo, coord2));
EXPECT_FALSE(multigrid2d_foo.is_location_empty(coord2));
EXPECT_TRUE(multigrid2d_foo.is_location_empty(coord3));
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
static_cast<void>(multigrid2d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(multigrid2d_foo.add_agent(agent_id_bar, coord2));
EXPECT_FALSE(multigrid2d_foo.is_location_empty(coord2));
EXPECT_TRUE(multigrid2d_foo.is_location_empty(coord3));
}
}
TEST(MultiGrid2D, move_agent) {
const AgentID agent_id_foo, agent_id_bar;
const GridCoord2D coord2(2, 5), coord3(3, 7), coord7(7, 2), coord10(10, 5);
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
static_cast<void>(multigrid2d_foo.add_agent(agent_id_foo, coord2));
auto agent_id_baz = multigrid2d_foo.move_agent(agent_id_foo, coord7);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
static_cast<void>(multigrid2d_foo.add_agent(agent_id_foo, coord2));
auto agent_id_baz = multigrid2d_foo.move_agent(agent_id_foo, coord10);
EXPECT_FALSE(agent_id_baz);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
static_cast<void>(multigrid2d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(multigrid2d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = multigrid2d_foo.move_agent(agent_id_foo, coord2);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
static_cast<void>(multigrid2d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(multigrid2d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = multigrid2d_foo.move_agent(agent_id_foo, coord7);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
}
TEST(MultiGrid2D, get_neighborhood_VonNeumann) {
const AgentID agent_id_foo, agent_id_bar;
const GridCoord2D coord0(0, 0), coord1(1, 1), coord2(2, 5), coord3(3, 7), coord9(9, 4);
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
auto tval = std::unordered_set<GridCoord2D>({{0, 1},
{0, 1},
{9, 0},
{0, 9},
{1, 0},
{0, 0}});
auto rval = multigrid2d_foo.get_neighborhood(coord0, true, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
auto tval = std::unordered_set<GridCoord2D>({{1, 2},
{2, 1},
{1, 0},
{0, 1},
{1, 1}});
auto rval = multigrid2d_foo.get_neighborhood(coord1, true, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
auto tval = std::unordered_set<GridCoord2D>({{0, 1},
{1, 0},
{0, 0}});
auto rval = multigrid2d_foo.get_neighborhood(coord0, true, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
auto tval = std::unordered_set<GridCoord2D>({{1, 2},
{2, 1},
{1, 0},
{0, 1},
{1, 1}});
auto rval = multigrid2d_foo.get_neighborhood(coord1, true, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
auto tval = std::unordered_set<GridCoord2D>({{1, 0},
{0, 1},
{9, 0},
{0, 9}});
auto rval = multigrid2d_foo.get_neighborhood(coord0, false, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
auto tval = std::unordered_set<GridCoord2D>({{1, 0},
{0, 1},
{9, 0},
{0, 9}});
auto rval = multigrid2d_foo.get_neighborhood(coord0, false, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
auto tval = std::unordered_set<GridCoord2D>({{1, 0},
{0, 1}});
auto rval = multigrid2d_foo.get_neighborhood(coord0, false, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
auto tval = std::unordered_set<GridCoord2D>({{1, 0},
{0, 1}});
auto rval = multigrid2d_foo.get_neighborhood(coord0, false, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
auto rval = multigrid2d_foo.get_neighborhood(agent_id_foo, true, GridNeighborhoodType::VonNeumann);
EXPECT_FALSE(rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
multigrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord2D>({{0, 1},
{9, 0},
{0, 9},
{1, 0},
{0, 0}});
auto rval = multigrid2d_foo.get_neighborhood(agent_id_foo, true, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
multigrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord2D>({{1, 2},
{2, 1},
{1, 0},
{0, 1},
{1, 1}});
auto rval = multigrid2d_foo.get_neighborhood(agent_id_foo, true, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
multigrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord2D>({{0, 1},
{1, 0},
{0, 0}});
auto rval = multigrid2d_foo.get_neighborhood(agent_id_foo, true, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
multigrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord2D>({{1, 2},
{2, 1},
{1, 0},
{0, 1},
{1, 1}});
auto rval = multigrid2d_foo.get_neighborhood(agent_id_foo, true, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
multigrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord2D>({{1, 0},
{0, 1},
{9, 0},
{0, 9}});
auto rval = multigrid2d_foo.get_neighborhood(agent_id_foo, false, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
multigrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord2D>({{0, 1},
{1, 2},
{2, 1},
{1, 0}});
auto rval = multigrid2d_foo.get_neighborhood(agent_id_foo, false, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
multigrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord2D>({{1, 0},
{0, 1}});
auto rval = multigrid2d_foo.get_neighborhood(agent_id_foo, false, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
multigrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord2D>({{0, 1},
{1, 2},
{2, 1},
{1, 0}});
auto rval = multigrid2d_foo.get_neighborhood(agent_id_foo, false, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
}
TEST(MultiGrid2D, get_neighborhood_Moore) {
const AgentID agent_id_foo, agent_id_bar;
const GridCoord2D coord0(0, 0), coord1(1, 1), coord2(2, 5), coord3(3, 7), coord9(9, 4);
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
auto tval = std::unordered_set<GridCoord2D>({{9, 9},
{9, 1},
{1, 1},
{0, 1},
{9, 0},
{1, 9},
{0, 9},
{1, 0},
{0, 0}});
auto rval = multigrid2d_foo.get_neighborhood(coord0, true, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
auto tval = std::unordered_set<GridCoord2D>({{2, 2},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0},
{2, 0},
{0, 1},
{1, 1}});
auto rval = multigrid2d_foo.get_neighborhood(coord1, true, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
auto tval = std::unordered_set<GridCoord2D>({{1, 1},
{0, 1},
{1, 0},
{0, 0}});
auto rval = multigrid2d_foo.get_neighborhood(coord0, true, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
auto tval = std::unordered_set<GridCoord2D>({{2, 2},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0},
{2, 0},
{0, 1},
{1, 1}});
auto rval = multigrid2d_foo.get_neighborhood(coord1, true, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
auto tval = std::unordered_set<GridCoord2D>({{9, 9},
{9, 1},
{1, 0},
{1, 1},
{0, 1},
{0, 9},
{1, 9},
{9, 0}});
auto rval = multigrid2d_foo.get_neighborhood(coord0, false, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
auto tval = std::unordered_set<GridCoord2D>({{9, 9},
{9, 1},
{1, 0},
{1, 1},
{0, 1},
{0, 9},
{1, 9},
{9, 0}});
auto rval = multigrid2d_foo.get_neighborhood(coord0, false, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
auto tval = std::unordered_set<GridCoord2D>({{1, 0},
{1, 1},
{0, 1}});
auto rval = multigrid2d_foo.get_neighborhood(coord0, false, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
auto tval = std::unordered_set<GridCoord2D>({{1, 0},
{1, 1},
{0, 1}});
auto rval = multigrid2d_foo.get_neighborhood(coord0, false, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
auto rval = multigrid2d_foo.get_neighborhood(agent_id_foo, true, GridNeighborhoodType::Moore);
EXPECT_FALSE(rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
multigrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord2D>({{9, 9},
{9, 1},
{1, 1},
{0, 1},
{9, 0},
{1, 9},
{0, 9},
{1, 0},
{0, 0}});
auto rval = multigrid2d_foo.get_neighborhood(agent_id_foo, true, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
multigrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord2D>({{2, 2},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0},
{2, 0},
{0, 1},
{1, 1}});
auto rval = multigrid2d_foo.get_neighborhood(agent_id_foo, true, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
multigrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord2D>({{1, 1},
{0, 1},
{1, 0},
{0, 0}});
auto rval = multigrid2d_foo.get_neighborhood(agent_id_foo, true, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
multigrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord2D>({{2, 2},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0},
{2, 0},
{0, 1},
{1, 1}});
auto rval = multigrid2d_foo.get_neighborhood(agent_id_foo, true, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
multigrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord2D>({{9, 9},
{9, 1},
{1, 0},
{1, 1},
{0, 1},
{0, 9},
{1, 9},
{9, 0}});
auto rval = multigrid2d_foo.get_neighborhood(agent_id_foo, false, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
multigrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord2D>({{2, 2},
{2, 0},
{0, 1},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0}});
auto rval = multigrid2d_foo.get_neighborhood(agent_id_foo, false, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
multigrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord2D>({{1, 0},
{1, 1},
{0, 1}});
auto rval = multigrid2d_foo.get_neighborhood(agent_id_foo, false, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
multigrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord2D>({{2, 2},
{2, 0},
{0, 1},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0}});
auto rval = multigrid2d_foo.get_neighborhood(agent_id_foo, false, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
}
TEST(MultiGrid2D, get_location_by_agent) {
const AgentID agent_id_foo, agent_id_bar;
const GridCoord2D coord2(2, 5), coord3(3, 7);
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
EXPECT_FALSE(multigrid2d_foo.get_location_by_agent(agent_id_foo));
EXPECT_FALSE(multigrid2d_foo.get_location_by_agent(agent_id_bar));
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
static_cast<void>(multigrid2d_foo.add_agent(agent_id_foo, coord2));
auto local = multigrid2d_foo.get_location_by_agent(agent_id_foo);
EXPECT_TRUE(local);
EXPECT_EQ(local, coord2);
EXPECT_FALSE(multigrid2d_foo.get_location_by_agent(agent_id_bar));
}
}
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

464
test/unit-kami-sologrid1d.cc Normal file
View File

@@ -0,0 +1,464 @@
/*-
* Copyright (c) 2022 The Johns Hopkins University Applied Physics
* Laboratory LLC
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation files
* (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <algorithm>
#include <iterator>
#include <set>
#include <unordered_set>
#include <kami/agent.h>
#include <kami/sologrid1d.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
using namespace kami;
TEST(SoloGrid1D, DefaultConstructor) {
// There is really no way this can go wrong, but
// we add this check anyway in case of future
// changes.
EXPECT_NO_THROW(
SoloGrid1D sologrid1d_foo(10, true);
);
}
TEST(SoloGrid1D, add_agent) {
SoloGrid1D sologrid1d_foo(10, true);
const AgentID agent_id_foo, agent_id_bar;
const GridCoord1D coord2(2), coord3(3);
{
auto agent_id_baz = sologrid1d_foo.add_agent(agent_id_foo, coord2);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
auto agent_id_baz = sologrid1d_foo.add_agent(agent_id_bar, coord2);
EXPECT_FALSE(agent_id_baz);
}
{
auto agent_id_baz = sologrid1d_foo.add_agent(agent_id_bar, coord3);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_bar);
}
}
TEST(SoloGrid1D, delete_agent) {
const AgentID agent_id_foo, agent_id_bar;
const GridCoord1D coord2(2), coord3(3);
{
SoloGrid1D sologrid1d_foo(10, true);
static_cast<void>(sologrid1d_foo.add_agent(agent_id_foo, coord2));
auto agent_id_baz = sologrid1d_foo.delete_agent(agent_id_foo);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
SoloGrid1D sologrid1d_foo(10, true);
static_cast<void>(sologrid1d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(sologrid1d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = sologrid1d_foo.delete_agent(agent_id_foo);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
SoloGrid1D sologrid1d_foo(10, true);
static_cast<void>(sologrid1d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(sologrid1d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = sologrid1d_foo.delete_agent(agent_id_bar);
EXPECT_FALSE(agent_id_baz);
}
{
SoloGrid1D sologrid1d_foo(10, true);
static_cast<void>(sologrid1d_foo.add_agent(agent_id_foo, coord2));
auto agent_id_baz = sologrid1d_foo.delete_agent(agent_id_foo, coord2);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
SoloGrid1D sologrid1d_foo(10, true);
static_cast<void>(sologrid1d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(sologrid1d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = sologrid1d_foo.delete_agent(agent_id_foo, coord2);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
SoloGrid1D sologrid1d_foo(10, true);
static_cast<void>(sologrid1d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(sologrid1d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = sologrid1d_foo.delete_agent(agent_id_bar, coord2);
EXPECT_FALSE(agent_id_baz);
}
{
SoloGrid1D sologrid1d_foo(10, true);
static_cast<void>(sologrid1d_foo.add_agent(agent_id_foo, coord2));
auto agent_id_baz = sologrid1d_foo.delete_agent(agent_id_foo, coord3);
EXPECT_FALSE(agent_id_baz);
}
{
SoloGrid1D sologrid1d_foo(10, true);
static_cast<void>(sologrid1d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(sologrid1d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = sologrid1d_foo.delete_agent(agent_id_foo, coord3);
EXPECT_FALSE(agent_id_baz);
}
{
SoloGrid1D sologrid1d_foo(10, true);
static_cast<void>(sologrid1d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(sologrid1d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = sologrid1d_foo.delete_agent(agent_id_bar, coord3);
EXPECT_FALSE(agent_id_baz);
}
}
TEST(SoloGrid1D, is_location_valid) {
SoloGrid1D sologrid1d_foo(10, true);
const AgentID agent_id_foo, agent_id_bar;
const GridCoord1D coordm1(-1), coord0(0), coord2(2), coord3(3), coord10(10), coord100(100);
{
EXPECT_TRUE(sologrid1d_foo.is_location_valid(coord0));
EXPECT_TRUE(sologrid1d_foo.is_location_valid(coord2));
EXPECT_TRUE(sologrid1d_foo.is_location_valid(coord2));
EXPECT_FALSE(sologrid1d_foo.is_location_valid(coordm1));
EXPECT_FALSE(sologrid1d_foo.is_location_valid(coord10));
EXPECT_FALSE(sologrid1d_foo.is_location_valid(coord100));
}
}
TEST(SoloGrid1D, is_location_empty) {
const AgentID agent_id_foo, agent_id_bar;
const GridCoord1D coord2(2), coord3(3);
{
SoloGrid1D sologrid1d_foo(10, true);
EXPECT_TRUE(sologrid1d_foo.is_location_empty(coord2));
EXPECT_TRUE(sologrid1d_foo.is_location_empty(coord3));
}
{
SoloGrid1D sologrid1d_foo(10, true);
static_cast<void>(sologrid1d_foo.add_agent(agent_id_foo, coord2));
EXPECT_FALSE(sologrid1d_foo.is_location_empty(coord2));
EXPECT_TRUE(sologrid1d_foo.is_location_empty(coord3));
}
{
SoloGrid1D sologrid1d_foo(10, true);
static_cast<void>(sologrid1d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(sologrid1d_foo.add_agent(agent_id_bar, coord2));
EXPECT_FALSE(sologrid1d_foo.is_location_empty(coord2));
EXPECT_TRUE(sologrid1d_foo.is_location_empty(coord3));
}
}
TEST(SoloGrid1D, move_agent) {
const AgentID agent_id_foo, agent_id_bar;
const GridCoord1D coord2(2), coord3(3), coord7(7), coord10(10);
{
SoloGrid1D sologrid1d_foo(10, true);
static_cast<void>(sologrid1d_foo.add_agent(agent_id_foo, coord2));
auto agent_id_baz = sologrid1d_foo.move_agent(agent_id_foo, coord7);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
SoloGrid1D sologrid1d_foo(10, true);
static_cast<void>(sologrid1d_foo.add_agent(agent_id_foo, coord2));
auto agent_id_baz = sologrid1d_foo.move_agent(agent_id_foo, coord10);
EXPECT_FALSE(agent_id_baz);
}
{
SoloGrid1D sologrid1d_foo(10, true);
static_cast<void>(sologrid1d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(sologrid1d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = sologrid1d_foo.move_agent(agent_id_foo, coord2);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
SoloGrid1D sologrid1d_foo(10, true);
static_cast<void>(sologrid1d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(sologrid1d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = sologrid1d_foo.move_agent(agent_id_foo, coord7);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
}
TEST(SoloGrid1D, get_neighborhood) {
const AgentID agent_id_foo, agent_id_bar;
const GridCoord1D coord0(0), coord1(1), coord2(2), coord3(3), coord9(9);
{
SoloGrid1D sologrid1d_foo(10, true);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord1, coord9});
auto rval = sologrid1d_foo.get_neighborhood(coord0, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid1D sologrid1d_foo(10, true);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord1, coord2});
auto rval = sologrid1d_foo.get_neighborhood(coord1, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid1D sologrid1d_foo(10, false);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord1});
auto rval = sologrid1d_foo.get_neighborhood(coord0, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid1D sologrid1d_foo(10, false);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord1, coord2});
auto rval = sologrid1d_foo.get_neighborhood(coord1, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid1D sologrid1d_foo(10, true);
auto tval = std::unordered_set<GridCoord1D>({coord1, coord9});
auto rval = sologrid1d_foo.get_neighborhood(coord0, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid1D sologrid1d_foo(10, true);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord2});
auto rval = sologrid1d_foo.get_neighborhood(coord1, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid1D sologrid1d_foo(10, false);
auto tval = std::unordered_set<GridCoord1D>({coord1});
auto rval = sologrid1d_foo.get_neighborhood(coord0, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid1D sologrid1d_foo(10, false);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord2});
auto rval = sologrid1d_foo.get_neighborhood(coord1, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid1D sologrid1d_foo(10, true);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord1, coord9});
auto rval = sologrid1d_foo.get_neighborhood(agent_id_foo, true);
EXPECT_FALSE(rval);
}
{
SoloGrid1D sologrid1d_foo(10, true);
sologrid1d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord1, coord9});
auto rval = sologrid1d_foo.get_neighborhood(agent_id_foo, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid1D sologrid1d_foo(10, true);
sologrid1d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord1, coord2});
auto rval = sologrid1d_foo.get_neighborhood(agent_id_foo, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid1D sologrid1d_foo(10, false);
sologrid1d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord1});
auto rval = sologrid1d_foo.get_neighborhood(agent_id_foo, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid1D sologrid1d_foo(10, false);
sologrid1d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord1, coord2});
auto rval = sologrid1d_foo.get_neighborhood(agent_id_foo, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid1D sologrid1d_foo(10, true);
sologrid1d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord1D>({coord1, coord9});
auto rval = sologrid1d_foo.get_neighborhood(agent_id_foo, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid1D sologrid1d_foo(10, true);
sologrid1d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord2});
auto rval = sologrid1d_foo.get_neighborhood(agent_id_foo, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid1D sologrid1d_foo(10, false);
sologrid1d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord1D>({coord1});
auto rval = sologrid1d_foo.get_neighborhood(agent_id_foo, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid1D sologrid1d_foo(10, false);
sologrid1d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord1D>({coord0, coord2});
auto rval = sologrid1d_foo.get_neighborhood(agent_id_foo, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
}
TEST(SoloGrid1D, get_location_by_agent) {
const AgentID agent_id_foo, agent_id_bar;
const GridCoord1D coord2(2), coord3(3);
{
SoloGrid1D sologrid1d_foo(10, true);
EXPECT_FALSE(sologrid1d_foo.get_location_by_agent(agent_id_foo));
EXPECT_FALSE(sologrid1d_foo.get_location_by_agent(agent_id_bar));
}
{
SoloGrid1D sologrid1d_foo(10, true);
static_cast<void>(sologrid1d_foo.add_agent(agent_id_foo, coord2));
auto local = sologrid1d_foo.get_location_by_agent(agent_id_foo);
EXPECT_TRUE(local);
EXPECT_EQ(local, coord2);
EXPECT_FALSE(sologrid1d_foo.get_location_by_agent(agent_id_bar));
}
}
TEST(SoloGrid1D, get_location_contents) {
const AgentID agent_id_foo, agent_id_bar, agent_id_baz;
const GridCoord1D coord0(0), coord1(1), coord9(9), coord10(10);
{
SoloGrid1D sologrid1d_foo(10, true);
auto agent_list_foo = sologrid1d_foo.get_location_contents(coord10);
EXPECT_FALSE(agent_list_foo);
}
{
SoloGrid1D sologrid1d_foo(10, true);
auto agent_list_foo = sologrid1d_foo.get_location_contents(coord1);
EXPECT_TRUE(agent_list_foo);
EXPECT_TRUE(agent_list_foo.value()->empty());
}
{
SoloGrid1D sologrid1d_foo(10, true);
static_cast<void>(sologrid1d_foo.add_agent(agent_id_foo, coord1));
static_cast<void>(sologrid1d_foo.add_agent(agent_id_bar, coord1));
static_cast<void>(sologrid1d_foo.add_agent(agent_id_baz, coord1));
auto tval = std::set<AgentID>({agent_id_foo});
auto rval = sologrid1d_foo.get_location_contents(coord1);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid1D sologrid1d_foo(10, true);
static_cast<void>(sologrid1d_foo.add_agent(agent_id_foo, coord1));
static_cast<void>(sologrid1d_foo.add_agent(agent_id_bar, coord1));
static_cast<void>(sologrid1d_foo.add_agent(agent_id_baz, coord9));
auto tval = std::set<AgentID>({agent_id_foo});
auto rval = sologrid1d_foo.get_location_contents(coord1);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
}
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

724
test/unit-kami-sologrid2d.cc Normal file
View File

@@ -0,0 +1,724 @@
/*-
* Copyright (c) 2022 The Johns Hopkins University Applied Physics
* Laboratory LLC
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation files
* (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <algorithm>
#include <iterator>
#include <set>
#include <unordered_set>
#include <kami/agent.h>
#include <kami/sologrid2d.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
using namespace kami;
TEST(SoloGrid2D, DefaultConstructor) {
// There is really no way this can go wrong, but
// we add this check anyway in case of future
// changes.
EXPECT_NO_THROW(
SoloGrid2D sologrid2d_foo(10, 10, true, true);
);
}
TEST(SoloGrid2D, add_agent) {
SoloGrid2D sologrid2d_foo(10, 10, true, true);
const AgentID agent_id_foo, agent_id_bar;
const GridCoord2D coord2(2, 5), coord3(3, 7);
{
auto agent_id_baz = sologrid2d_foo.add_agent(agent_id_foo, coord2);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
auto agent_id_baz = sologrid2d_foo.add_agent(agent_id_bar, coord2);
EXPECT_FALSE(agent_id_baz);
}
{
auto agent_id_baz = sologrid2d_foo.add_agent(agent_id_bar, coord3);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_bar);
}
}
TEST(SoloGrid2D, delete_agent) {
const AgentID agent_id_foo, agent_id_bar;
const GridCoord2D coord2(2, 5), coord3(3, 7);
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
static_cast<void>(sologrid2d_foo.add_agent(agent_id_foo, coord2));
auto agent_id_baz = sologrid2d_foo.delete_agent(agent_id_foo);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
static_cast<void>(sologrid2d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(sologrid2d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = sologrid2d_foo.delete_agent(agent_id_foo);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
static_cast<void>(sologrid2d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(sologrid2d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = sologrid2d_foo.delete_agent(agent_id_bar);
EXPECT_FALSE(agent_id_baz);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
static_cast<void>(sologrid2d_foo.add_agent(agent_id_foo, coord2));
auto agent_id_baz = sologrid2d_foo.delete_agent(agent_id_foo, coord2);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
static_cast<void>(sologrid2d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(sologrid2d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = sologrid2d_foo.delete_agent(agent_id_foo, coord2);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
static_cast<void>(sologrid2d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(sologrid2d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = sologrid2d_foo.delete_agent(agent_id_bar, coord2);
EXPECT_FALSE(agent_id_baz);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
static_cast<void>(sologrid2d_foo.add_agent(agent_id_foo, coord2));
auto agent_id_baz = sologrid2d_foo.delete_agent(agent_id_foo, coord3);
EXPECT_FALSE(agent_id_baz);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
static_cast<void>(sologrid2d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(sologrid2d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = sologrid2d_foo.delete_agent(agent_id_foo, coord3);
EXPECT_FALSE(agent_id_baz);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
static_cast<void>(sologrid2d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(sologrid2d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = sologrid2d_foo.delete_agent(agent_id_bar, coord3);
EXPECT_FALSE(agent_id_baz);
}
}
TEST(SoloGrid2D, is_location_valid) {
SoloGrid2D sologrid2d_foo(10, 10, true, true);
const AgentID agent_id_foo, agent_id_bar;
const GridCoord2D coordm1(-1, -1), coord0(0, 0), coord2(2, 5), coord3(3, 7), coord10(10, 5), coord100(100, 100);
{
EXPECT_TRUE(sologrid2d_foo.is_location_valid(coord0));
EXPECT_TRUE(sologrid2d_foo.is_location_valid(coord2));
EXPECT_TRUE(sologrid2d_foo.is_location_valid(coord2));
EXPECT_FALSE(sologrid2d_foo.is_location_valid(coordm1));
EXPECT_FALSE(sologrid2d_foo.is_location_valid(coord10));
EXPECT_FALSE(sologrid2d_foo.is_location_valid(coord100));
}
}
TEST(SoloGrid2D, is_location_empty) {
const AgentID agent_id_foo, agent_id_bar;
const GridCoord2D coord2(2, 5), coord3(3, 7);
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
EXPECT_TRUE(sologrid2d_foo.is_location_empty(coord2));
EXPECT_TRUE(sologrid2d_foo.is_location_empty(coord3));
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
static_cast<void>(sologrid2d_foo.add_agent(agent_id_foo, coord2));
EXPECT_FALSE(sologrid2d_foo.is_location_empty(coord2));
EXPECT_TRUE(sologrid2d_foo.is_location_empty(coord3));
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
static_cast<void>(sologrid2d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(sologrid2d_foo.add_agent(agent_id_bar, coord2));
EXPECT_FALSE(sologrid2d_foo.is_location_empty(coord2));
EXPECT_TRUE(sologrid2d_foo.is_location_empty(coord3));
}
}
TEST(SoloGrid2D, move_agent) {
const AgentID agent_id_foo, agent_id_bar;
const GridCoord2D coord2(2, 5), coord3(3, 7), coord7(7, 2), coord10(10, 5);
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
static_cast<void>(sologrid2d_foo.add_agent(agent_id_foo, coord2));
auto agent_id_baz = sologrid2d_foo.move_agent(agent_id_foo, coord7);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
static_cast<void>(sologrid2d_foo.add_agent(agent_id_foo, coord2));
auto agent_id_baz = sologrid2d_foo.move_agent(agent_id_foo, coord10);
EXPECT_FALSE(agent_id_baz);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
static_cast<void>(sologrid2d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(sologrid2d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = sologrid2d_foo.move_agent(agent_id_foo, coord2);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
static_cast<void>(sologrid2d_foo.add_agent(agent_id_foo, coord2));
static_cast<void>(sologrid2d_foo.add_agent(agent_id_bar, coord2));
auto agent_id_baz = sologrid2d_foo.move_agent(agent_id_foo, coord7);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
}
}
TEST(SoloGrid2D, get_neighborhood_VonNeumann) {
const AgentID agent_id_foo, agent_id_bar;
const GridCoord2D coord0(0, 0), coord1(1, 1), coord2(2, 5), coord3(3, 7), coord9(9, 4);
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
auto tval = std::unordered_set<GridCoord2D>({{0, 1},
{0, 1},
{9, 0},
{0, 9},
{1, 0},
{0, 0}});
auto rval = sologrid2d_foo.get_neighborhood(coord0, true, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
auto tval = std::unordered_set<GridCoord2D>({{1, 2},
{2, 1},
{1, 0},
{0, 1},
{1, 1}});
auto rval = sologrid2d_foo.get_neighborhood(coord1, true, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
auto tval = std::unordered_set<GridCoord2D>({{0, 1},
{1, 0},
{0, 0}});
auto rval = sologrid2d_foo.get_neighborhood(coord0, true, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
auto tval = std::unordered_set<GridCoord2D>({{1, 2},
{2, 1},
{1, 0},
{0, 1},
{1, 1}});
auto rval = sologrid2d_foo.get_neighborhood(coord1, true, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
auto tval = std::unordered_set<GridCoord2D>({{1, 0},
{0, 1},
{9, 0},
{0, 9}});
auto rval = sologrid2d_foo.get_neighborhood(coord0, false, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
auto tval = std::unordered_set<GridCoord2D>({{1, 0},
{0, 1},
{9, 0},
{0, 9}});
auto rval = sologrid2d_foo.get_neighborhood(coord0, false, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
auto tval = std::unordered_set<GridCoord2D>({{1, 0},
{0, 1}});
auto rval = sologrid2d_foo.get_neighborhood(coord0, false, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
auto tval = std::unordered_set<GridCoord2D>({{1, 0},
{0, 1}});
auto rval = sologrid2d_foo.get_neighborhood(coord0, false, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
auto rval = sologrid2d_foo.get_neighborhood(agent_id_foo, true, GridNeighborhoodType::VonNeumann);
EXPECT_FALSE(rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
sologrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord2D>({{0, 1},
{9, 0},
{0, 9},
{1, 0},
{0, 0}});
auto rval = sologrid2d_foo.get_neighborhood(agent_id_foo, true, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
sologrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord2D>({{1, 2},
{2, 1},
{1, 0},
{0, 1},
{1, 1}});
auto rval = sologrid2d_foo.get_neighborhood(agent_id_foo, true, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
sologrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord2D>({{0, 1},
{1, 0},
{0, 0}});
auto rval = sologrid2d_foo.get_neighborhood(agent_id_foo, true, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
sologrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord2D>({{1, 2},
{2, 1},
{1, 0},
{0, 1},
{1, 1}});
auto rval = sologrid2d_foo.get_neighborhood(agent_id_foo, true, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
sologrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord2D>({{1, 0},
{0, 1},
{9, 0},
{0, 9}});
auto rval = sologrid2d_foo.get_neighborhood(agent_id_foo, false, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
sologrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord2D>({{0, 1},
{1, 2},
{2, 1},
{1, 0}});
auto rval = sologrid2d_foo.get_neighborhood(agent_id_foo, false, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
sologrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord2D>({{1, 0},
{0, 1}});
auto rval = sologrid2d_foo.get_neighborhood(agent_id_foo, false, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
sologrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord2D>({{0, 1},
{1, 2},
{2, 1},
{1, 0}});
auto rval = sologrid2d_foo.get_neighborhood(agent_id_foo, false, GridNeighborhoodType::VonNeumann);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
}
TEST(SoloGrid2D, get_neighborhood_Moore) {
const AgentID agent_id_foo, agent_id_bar;
const GridCoord2D coord0(0, 0), coord1(1, 1), coord2(2, 5), coord3(3, 7), coord9(9, 4);
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
auto tval = std::unordered_set<GridCoord2D>({{9, 9},
{9, 1},
{1, 1},
{0, 1},
{9, 0},
{1, 9},
{0, 9},
{1, 0},
{0, 0}});
auto rval = sologrid2d_foo.get_neighborhood(coord0, true, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
auto tval = std::unordered_set<GridCoord2D>({{2, 2},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0},
{2, 0},
{0, 1},
{1, 1}});
auto rval = sologrid2d_foo.get_neighborhood(coord1, true, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
auto tval = std::unordered_set<GridCoord2D>({{1, 1},
{0, 1},
{1, 0},
{0, 0}});
auto rval = sologrid2d_foo.get_neighborhood(coord0, true, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
auto tval = std::unordered_set<GridCoord2D>({{2, 2},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0},
{2, 0},
{0, 1},
{1, 1}});
auto rval = sologrid2d_foo.get_neighborhood(coord1, true, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
auto tval = std::unordered_set<GridCoord2D>({{9, 9},
{9, 1},
{1, 0},
{1, 1},
{0, 1},
{0, 9},
{1, 9},
{9, 0}});
auto rval = sologrid2d_foo.get_neighborhood(coord0, false, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
auto tval = std::unordered_set<GridCoord2D>({{9, 9},
{9, 1},
{1, 0},
{1, 1},
{0, 1},
{0, 9},
{1, 9},
{9, 0}});
auto rval = sologrid2d_foo.get_neighborhood(coord0, false, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
auto tval = std::unordered_set<GridCoord2D>({{1, 0},
{1, 1},
{0, 1}});
auto rval = sologrid2d_foo.get_neighborhood(coord0, false, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
auto tval = std::unordered_set<GridCoord2D>({{1, 0},
{1, 1},
{0, 1}});
auto rval = sologrid2d_foo.get_neighborhood(coord0, false, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
auto rval = sologrid2d_foo.get_neighborhood(agent_id_foo, true, GridNeighborhoodType::Moore);
EXPECT_FALSE(rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
sologrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord2D>({{9, 9},
{9, 1},
{1, 1},
{0, 1},
{9, 0},
{1, 9},
{0, 9},
{1, 0},
{0, 0}});
auto rval = sologrid2d_foo.get_neighborhood(agent_id_foo, true, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
sologrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord2D>({{2, 2},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0},
{2, 0},
{0, 1},
{1, 1}});
auto rval = sologrid2d_foo.get_neighborhood(agent_id_foo, true, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
sologrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord2D>({{1, 1},
{0, 1},
{1, 0},
{0, 0}});
auto rval = sologrid2d_foo.get_neighborhood(agent_id_foo, true, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
sologrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord2D>({{2, 2},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0},
{2, 0},
{0, 1},
{1, 1}});
auto rval = sologrid2d_foo.get_neighborhood(agent_id_foo, true, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
sologrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord2D>({{9, 9},
{9, 1},
{1, 0},
{1, 1},
{0, 1},
{0, 9},
{1, 9},
{9, 0}});
auto rval = sologrid2d_foo.get_neighborhood(agent_id_foo, false, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
sologrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord2D>({{2, 2},
{2, 0},
{0, 1},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0}});
auto rval = sologrid2d_foo.get_neighborhood(agent_id_foo, false, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
sologrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = std::unordered_set<GridCoord2D>({{1, 0},
{1, 1},
{0, 1}});
auto rval = sologrid2d_foo.get_neighborhood(agent_id_foo, false, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
sologrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = std::unordered_set<GridCoord2D>({{2, 2},
{2, 0},
{0, 1},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0}});
auto rval = sologrid2d_foo.get_neighborhood(agent_id_foo, false, GridNeighborhoodType::Moore);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
}
}
TEST(SoloGrid2D, get_location_by_agent) {
const AgentID agent_id_foo, agent_id_bar;
const GridCoord2D coord2(2, 5), coord3(3, 7);
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
EXPECT_FALSE(sologrid2d_foo.get_location_by_agent(agent_id_foo));
EXPECT_FALSE(sologrid2d_foo.get_location_by_agent(agent_id_bar));
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
static_cast<void>(sologrid2d_foo.add_agent(agent_id_foo, coord2));
auto local = sologrid2d_foo.get_location_by_agent(agent_id_foo);
EXPECT_TRUE(local);
EXPECT_EQ(local, coord2);
EXPECT_FALSE(sologrid2d_foo.get_location_by_agent(agent_id_bar));
}
}
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}