AtHeartEngineer/kami
1
0
Fork 0
mirror of https://github.com/JHUAPL/kami.git synced 2026-01-07 22:13:51 -05:00
Code Issues Packages Projects Releases Wiki Activity

Move to exception-based error handling

Browse Source
This commit is contained in:
James P. Howard, II
2022-09-09 22:10:19 -04:00
parent 2aeef72f19
commit 9eb47c8656
43 changed files with 962 additions and 1012 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
docs/changelog.rst
View File

@@ -1,6 +1,7 @@
Changelog
=========
- :feature:`0` Moved to exception-based error handling
- :feature:`0` Added Bank Reserves model to demonstrate reporting
- :feature:`0` Added data collecting and reporting modules
- :feature:`0` Added some useful constants, for use as random seeds

8
examples/bankreserves/bankreserves.h
View File

@@ -71,7 +71,7 @@ public:
*/
explicit BankAgent(int reserve_percent) : _reserve_percent(reserve_percent) {};
inline std::optional<std::unique_ptr<nlohmann::json>> collect() override {
inline std::unique_ptr<nlohmann::json> collect() override {
auto ret = std::make_unique<nlohmann::json>();
(*ret)["reserves"] = _reserves;
@@ -107,7 +107,7 @@ public:
explicit PersonAgent(int wallet, std::shared_ptr<BankAgent> &bank) :
_wallet(wallet), _bank(bank) {};
inline std::optional<std::unique_ptr<nlohmann::json>> collect() override {
inline std::unique_ptr<nlohmann::json> collect() override {
auto ret = std::make_unique<nlohmann::json>();
(*ret)["savings"] = _savings;
@@ -164,8 +164,8 @@ public:
explicit BankReservesModel(unsigned int agent_count, unsigned int x_size, unsigned int y_size,
unsigned int initial_seed, unsigned int max_initial_wealth);
inline std::optional<std::unique_ptr<nlohmann::json>> collect() override {
return std::nullopt;
inline std::unique_ptr<nlohmann::json> collect() override {
return nullptr;
}
};

18
examples/bankreserves/person.cc
View File

@@ -52,10 +52,9 @@ std::optional<kami::GridCoord2D> PersonAgent::move_agent(std::shared_ptr<kami::R
auto agent_id = get_agent_id();
auto domain = model->get_domain();
auto world = std::static_pointer_cast<kami::MultiGrid2D>(domain.value());
auto world = std::static_pointer_cast<kami::MultiGrid2D>(domain);
auto move_list_opt = world->get_neighborhood(agent_id, false, kami::GridNeighborhoodType::Moore);
auto move_list = move_list_opt.value();
auto move_list = world->get_neighborhood(agent_id, false, kami::GridNeighborhoodType::Moore);
std::uniform_int_distribution<int> dist(0, (int) move_list->size() - 1);
auto new_location = *std::next(move_list->begin(), dist(*rng));
@@ -72,14 +71,11 @@ std::optional<kami::AgentID> PersonAgent::do_business(std::shared_ptr<kami::Repo
if (!(_savings > 0 | _wallet > 0 | _bank->_available_to_loan > 0))
return agent_id;
auto domain = model->get_domain();
auto world = std::static_pointer_cast<kami::MultiGrid2D>(domain.value());
auto agents = model->get_population();
auto population = std::static_pointer_cast<kami::Population>(agents.value());
auto world = std::static_pointer_cast<kami::MultiGrid2D>(model->get_domain());
auto population = model->get_population();
auto location = world->get_location_by_agent(agent_id);
auto cell_mates_opt = world->get_location_contents(location.value());
auto cell_mates_opt = world->get_location_contents(location);
if (!cell_mates_opt)
return std::nullopt;
@@ -87,7 +83,7 @@ std::optional<kami::AgentID> PersonAgent::do_business(std::shared_ptr<kami::Repo
// Note, here we reverse the logic from that used in the Mesa
// implementation. We prefer the guard clause to the nested
// if statements. See Fowler.
auto cell_mates = cell_mates_opt.value();
auto cell_mates = cell_mates_opt;
if (cell_mates->size() < 2)
return std::nullopt;
@@ -106,7 +102,7 @@ std::optional<kami::AgentID> PersonAgent::do_business(std::shared_ptr<kami::Repo
// really, this is just more elegant.
auto trade_amount = (int) std::round(coin_flip(*rng)) * 3 + 2;
auto customer = std::static_pointer_cast<PersonAgent>(population->get_agent_by_id(customer_id).value());
auto customer = std::static_pointer_cast<PersonAgent>(population->get_agent_by_id(customer_id));
console->debug("Agent {} trading amount {} with agent {}", agent_id, trade_amount, customer_id);
customer->_wallet += trade_amount;
_wallet -= trade_amount;

14
examples/boltzmann1d/boltzmann1d.cc
View File

@@ -82,12 +82,12 @@ std::optional<kami::GridCoord1D> MoneyAgent1D::move_agent(std::shared_ptr<kami::
auto domain = model->get_domain();
if (!domain)
throw (std::domain_error("model is missing domain"));
auto world = std::static_pointer_cast<kami::MultiGrid1D>(domain.value());
auto world = std::static_pointer_cast<kami::MultiGrid1D>(domain);
auto move_list_opt = world->get_neighborhood(agent_id, false);
if (!move_list_opt)
return std::nullopt;
auto move_list = move_list_opt.value();
auto move_list = move_list_opt;
std::uniform_int_distribution<int> dist(0, (int) move_list->size() - 1);
auto new_location = *std::next(move_list->begin(), dist(*rng));
@@ -105,26 +105,26 @@ std::optional<kami::AgentID> MoneyAgent1D::give_money(std::shared_ptr<kami::Mode
auto domain = model->get_domain();
if (!domain)
throw (std::domain_error("model is missing domain"));
auto world = std::static_pointer_cast<kami::MultiGrid1D>(domain.value());
auto world = std::static_pointer_cast<kami::MultiGrid1D>(domain);
auto agents = model->get_population();
if (!agents)
throw (std::domain_error("model is missing population"));
auto population = std::static_pointer_cast<kami::Population>(agents.value());
auto population = std::static_pointer_cast<kami::Population>(agents);
auto location = world->get_location_by_agent(agent_id);
auto cell_mates_opt = world->get_location_contents(location.value());
auto cell_mates_opt = world->get_location_contents(location);
if (!cell_mates_opt)
return std::nullopt;
auto cell_mates = cell_mates_opt.value();
auto cell_mates = cell_mates_opt;
if (cell_mates->size() < 2)
return std::nullopt;
std::uniform_int_distribution<int> dist(0, (int) cell_mates->size() - 1);
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());
auto other_agent = std::static_pointer_cast<MoneyAgent1D>(population->get_agent_by_id(other_agent_id));
console->trace("Agent {} giving unit of wealth to agent {}", agent_id, other_agent_id);
other_agent->_agent_wealth += 1;

14
examples/boltzmann2d/boltzmann2d.cc
View File

@@ -82,12 +82,12 @@ std::optional<kami::GridCoord2D> MoneyAgent2D::move_agent(const std::shared_ptr<
auto domain = model->get_domain();
if (!domain)
throw (std::domain_error("model is missing domain"));
auto world = std::static_pointer_cast<kami::MultiGrid2D>(domain.value());
auto world = std::static_pointer_cast<kami::MultiGrid2D>(domain);
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();
auto move_list = move_list_opt;
std::uniform_int_distribution<int> dist(0, (int) move_list->size() - 1);
auto new_location = *std::next(move_list->begin(), dist(*rng));
@@ -105,26 +105,26 @@ std::optional<kami::AgentID> MoneyAgent2D::give_money(const std::shared_ptr<kami
auto domain = model->get_domain();
if (!domain)
throw (std::domain_error("model is missing domain"));
auto world = std::static_pointer_cast<kami::MultiGrid2D>(domain.value());
auto world = std::static_pointer_cast<kami::MultiGrid2D>(domain);
auto agents = model->get_population();
if (!agents)
throw (std::domain_error("model is missing population"));
auto population = std::static_pointer_cast<kami::Population>(agents.value());
auto population = std::static_pointer_cast<kami::Population>(agents);
auto location = world->get_location_by_agent(agent_id);
auto cell_mates_opt = world->get_location_contents(location.value());
auto cell_mates_opt = world->get_location_contents(location);
if (!cell_mates_opt)
return std::nullopt;
auto cell_mates = cell_mates_opt.value();
auto cell_mates = cell_mates_opt;
if (cell_mates->size() < 2)
return std::nullopt;
std::uniform_int_distribution<int> dist(0, (int) cell_mates->size() - 1);
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());
auto other_agent = std::static_pointer_cast<MoneyAgent2D>(population->get_agent_by_id(other_agent_id));
console->trace("Agent {} giving unit of wealth to agent {}", agent_id, other_agent_id);
other_agent->_agent_wealth += 1;

44
include/kami/exception.h Normal file
View File

@@ -0,0 +1,44 @@
//
// Created by James Howard on 9/9/22.
//
#ifndef KAMI_EXCEPTION_H
//! @cond SuppressGuard
#define KAMI_EXCEPTION_H
#include <stdexcept>
#include <string>
namespace kami::exception {
class AgentNotFound : public std::logic_error {
public:
explicit AgentNotFound(const char *s) : std::logic_error(s) {};
explicit AgentNotFound(const std::string &s) : std::logic_error(s) {};
};
class InvalidOption : public std::invalid_argument {
public:
explicit InvalidOption(const char *s) : std::invalid_argument(s) {};
explicit InvalidOption(const std::string &s) : std::invalid_argument(s) {};
};
class LocationUnavailable : public std::domain_error {
public:
explicit LocationUnavailable(const char *s) : std::domain_error(s) {};
explicit LocationUnavailable(const std::string &s) : std::domain_error(s) {};
};
class ResourceNotAvailable : public std::logic_error {
public:
explicit ResourceNotAvailable(const char *s) : std::logic_error(s) {};
explicit ResourceNotAvailable(const std::string &s) : std::logic_error(s) {};
};
}
#endif //KAMI_EXCEPTION_H

17
include/kami/grid1d.h
View File

@@ -38,6 +38,7 @@
#include <vector>
#include <kami/domain.h>
#include <kami/exception.h>
#include <kami/grid.h>
#include <kami/kami.h>
@@ -157,7 +158,7 @@ namespace kami {
* @returns false if the agent is not placed at the specified
* location, otherwise, true.
*/
virtual std::optional<AgentID> add_agent(AgentID agent_id, const GridCoord1D &coord) = 0;
virtual AgentID add_agent(AgentID agent_id, const GridCoord1D &coord) = 0;
/**
* @brief Remove agent from the grid.
@@ -166,7 +167,7 @@ namespace kami {
*
* @returns the `AgentID` of the `Agent` deleted
*/
std::optional<AgentID> delete_agent(AgentID agent_id);
AgentID delete_agent(AgentID agent_id);
/**
* @brief Remove agent from the grid at the specified location
@@ -176,7 +177,7 @@ namespace kami {
*
* @returns the `AgentID` of the `Agent` deleted
*/
std::optional<AgentID> delete_agent(AgentID agent_id, const GridCoord1D &coord);
AgentID delete_agent(AgentID agent_id, const GridCoord1D &coord);
/**
* @brief Move an agent to the specified location.
@@ -184,7 +185,7 @@ namespace kami {
* @param[in] agent_id the `AgentID` of the agent to move.
* @param[in] coord the coordinates of the agent.
*/
std::optional<AgentID> move_agent(AgentID agent_id, const GridCoord1D &coord);
AgentID move_agent(AgentID agent_id, const GridCoord1D &coord);
/**
* @brief Inquire if the specified location is empty.
@@ -212,7 +213,7 @@ namespace kami {
*
* @return the location of the specified `Agent`
*/
[[nodiscard]] std::optional<GridCoord1D> get_location_by_agent(const AgentID &agent_id) const;
[[nodiscard]] GridCoord1D get_location_by_agent(const AgentID &agent_id) const;
/**
* @brief Get the contents of the specified location.
@@ -224,7 +225,7 @@ namespace kami {
* to that object will update the state of the gird. Further, the pointer
* should not be deleted when no longer used.
*/
[[nodiscard]] std::optional<std::shared_ptr<std::set<AgentID>>>
[[nodiscard]] std::shared_ptr<std::set<AgentID>>
get_location_contents(const GridCoord1D &coord) const;
/**
@@ -244,7 +245,7 @@ namespace kami {
* @return an `unordered_set` of `GridCoord1D` that includes all of the coordinates
* for all adjacent points.
*/
[[nodiscard]] std::optional<std::shared_ptr<std::unordered_set<GridCoord1D>>>
[[nodiscard]] std::shared_ptr<std::unordered_set<GridCoord1D>>
get_neighborhood(AgentID agent_id, bool include_center) const;
/**
@@ -257,7 +258,7 @@ namespace kami {
* @return an `unordered_set` of `GridCoord1D` that includes all of the coordinates
* for all adjacent points.
*/
[[nodiscard]] std::optional<std::shared_ptr<std::unordered_set<GridCoord1D>>>
[[nodiscard]] std::shared_ptr<std::unordered_set<GridCoord1D>>
get_neighborhood(const GridCoord1D &coord, bool include_center) const;
/**

16
include/kami/grid2d.h
View File

@@ -213,7 +213,7 @@ namespace kami {
* @returns false if the agent is not placed at the specified
* location, otherwise, true.
*/
virtual std::optional<AgentID> add_agent(AgentID agent_id, const GridCoord2D &coord) = 0;
virtual AgentID add_agent(AgentID agent_id, const GridCoord2D &coord) = 0;
/**
* @brief Remove agent from the grid.
@@ -222,7 +222,7 @@ namespace kami {
*
* @returns false if the agent is not removed, otherwise, true.
*/
std::optional<AgentID> delete_agent(AgentID agent_id);
AgentID delete_agent(AgentID agent_id);
/**
* @brief Remove agent from the grid at the specified location
@@ -232,7 +232,7 @@ namespace kami {
*
* @returns false if the agent is not removed, otherwise, true.
*/
std::optional<AgentID> delete_agent(AgentID agent_id, const GridCoord2D &coord);
AgentID delete_agent(AgentID agent_id, const GridCoord2D &coord);
/**
* @brief Move an agent to the specified location.
@@ -240,7 +240,7 @@ namespace kami {
* @param[in] agent_id the `AgentID` of the agent to move.
* @param[in] coord the coordinates of the agent.
*/
std::optional<AgentID> move_agent(AgentID agent_id, const GridCoord2D &coord);
AgentID move_agent(AgentID agent_id, const GridCoord2D &coord);
/**
* @brief Inquire if the specified location is empty.
@@ -268,7 +268,7 @@ namespace kami {
*
* @return the location of the specified `Agent`
*/
std::optional<GridCoord2D> get_location_by_agent(const AgentID &agent_id) const;
GridCoord2D get_location_by_agent(const AgentID &agent_id) const;
/**
* @brief Get the contents of the specified location.
@@ -280,7 +280,7 @@ namespace kami {
* to that object will update the state of the gird. Further, the pointer
* should not be deleted when no longer used.
*/
[[nodiscard]] std::optional<std::shared_ptr<std::set<AgentID>>>
[[nodiscard]] std::shared_ptr<std::set<AgentID>>
get_location_contents(const GridCoord2D &coord) const;
/**
@@ -310,7 +310,7 @@ namespace kami {
*
* @see `NeighborhoodType`
*/
std::optional<std::shared_ptr<std::unordered_set<GridCoord2D>>>
std::shared_ptr<std::unordered_set<GridCoord2D>>
get_neighborhood(AgentID agent_id, bool include_center, GridNeighborhoodType neighborhood_type) const;
/**
@@ -326,7 +326,7 @@ namespace kami {
*
* @see `NeighborhoodType`
*/
[[nodiscard]] std::optional<std::shared_ptr<std::unordered_set<GridCoord2D>>>
[[nodiscard]] std::shared_ptr<std::unordered_set<GridCoord2D>>
get_neighborhood(const GridCoord2D &coord, bool include_center, GridNeighborhoodType neighborhood_type) const;
/**

7
include/kami/model.h
View File

@@ -30,7 +30,6 @@
//! @endcond
#include <memory>
#include <optional>
#include <kami/domain.h>
#include <kami/kami.h>
@@ -50,7 +49,7 @@ namespace kami {
*
* @returns a shared pointer to the `Domain`
*/
std::optional<std::shared_ptr<Domain>> get_domain();
std::shared_ptr<Domain> get_domain();
/**
* @brief Add a `Domain` to this scheduler
@@ -67,7 +66,7 @@ namespace kami {
*
* @returns a shared pointer to the `Population`
*/
std::optional<std::shared_ptr<Population>> get_population();
std::shared_ptr<Population> get_population();
/**
* @brief Add a `Model` to this scheduler
@@ -84,7 +83,7 @@ namespace kami {
*
* @returns a shared pointer to the `Scheduler`
*/
std::optional<std::shared_ptr<Scheduler>> get_scheduler();
std::shared_ptr<Scheduler> get_scheduler();
/**
* @brief Add a `Model` to this scheduler

2
include/kami/multigrid1d.h
View File

@@ -64,7 +64,7 @@ namespace kami {
* @returns false if the agent is not placed at the specified
* location, otherwise, true
*/
std::optional<AgentID> add_agent(AgentID agent_id, const GridCoord1D &coord) override;
AgentID add_agent(AgentID agent_id, const GridCoord1D &coord) override;
};
} // namespace kami

5
include/kami/multigrid2d.h
View File

@@ -65,10 +65,9 @@ namespace kami {
* @param[in] agent_id the `AgentID` of the agent to add.
* @param[in] coord the coordinates of the agent.
*
* @returns false if the agent is not placed at the specified
* location, otherwise, true
* @returns the `AgentID` of the agent added
*/
std::optional<AgentID> add_agent(AgentID agent_id, const GridCoord2D &coord) override;
AgentID add_agent(AgentID agent_id, const GridCoord2D &coord) override;
};
} // namespace kami

6
include/kami/population.h
View File

@@ -49,7 +49,7 @@ namespace kami {
*
* @return a reference to the desired `Agent` or nothing is not found
*/
[[nodiscard]] std::optional<std::shared_ptr<Agent>> get_agent_by_id(AgentID agent_id) const;
[[nodiscard]] std::shared_ptr<Agent> get_agent_by_id(AgentID agent_id) const;
/**
* @brief Add an Agent to the Population.
@@ -58,7 +58,7 @@ namespace kami {
*
* @returns the ID of the agent added
*/
AgentID add_agent(const std::shared_ptr<Agent>& agent);
AgentID add_agent(const std::shared_ptr<Agent> &agent) noexcept;
/**
* @brief Remove an Agent from the Population.
@@ -67,7 +67,7 @@ namespace kami {
*
* @returns a shared pointer to the Agent deleted
*/
std::optional<std::shared_ptr<Agent>> delete_agent(AgentID agent_id);
std::shared_ptr<Agent> delete_agent(AgentID agent_id);
/**
* @brief Returns the agent list.

2
include/kami/position.h
View File

@@ -36,11 +36,13 @@
#include <kami/hexgrid.h>
namespace kami {
typedef std::variant<
GridCoord1D,
GridCoord2D,
HexCoord
> Position;
}
#endif //KAMI_POSITION_H

5
include/kami/random.h
View File

@@ -30,7 +30,6 @@
//! @endcond
#include <memory>
#include <optional>
#include <random>
#include <vector>
@@ -73,10 +72,10 @@ namespace kami {
*
* @returns returns vector of agents successfully stepped
*/
std::optional<std::unique_ptr<std::vector<AgentID>>>
std::unique_ptr<std::vector<AgentID>>
step(std::shared_ptr<Model> model, std::unique_ptr<std::vector<AgentID>> agent_list) override;
std::optional<std::unique_ptr<std::vector<AgentID>>>
std::unique_ptr<std::vector<AgentID>>
step(std::shared_ptr<ReporterModel> model, std::unique_ptr<std::vector<AgentID>> agent_list) override;
/**

4
include/kami/reporter.h
View File

@@ -63,7 +63,7 @@ namespace kami {
* its data as a [nlohmann::json](https://json.nlohmann.me/)
* JSON object. See `Reporter` for additional details.
*/
virtual std::optional<std::unique_ptr<nlohmann::json>> collect() = 0;
virtual std::unique_ptr<nlohmann::json> collect() = 0;
/**
* @brief Execute a time-step for the agent
@@ -106,7 +106,7 @@ namespace kami {
* This is not expected to return agent data collection,
* as the agents' information is collected separately.
*/
virtual std::optional<std::unique_ptr<nlohmann::json>> collect() = 0;
virtual std::unique_ptr<nlohmann::json> collect() = 0;
/**
* @brief Get the step id of the model

9
include/kami/scheduler.h
View File

@@ -30,7 +30,6 @@
//! @endcond
#include <memory>
#include <optional>
#include <vector>
#include <kami/agent.h>
@@ -59,9 +58,9 @@ namespace kami {
*
* @returns returns vector of agents successfully stepped
*/
virtual std::optional<std::unique_ptr<std::vector<AgentID>>> step(std::shared_ptr<Model> model) = 0;
virtual std::unique_ptr<std::vector<AgentID>> step(std::shared_ptr<Model> model) = 0;
virtual std::optional<std::unique_ptr<std::vector<AgentID>>> step(std::shared_ptr<ReporterModel> model) = 0;
virtual std::unique_ptr<std::vector<AgentID>> step(std::shared_ptr<ReporterModel> model) = 0;
/**
* @brief Execute a single time step.
@@ -76,10 +75,10 @@ namespace kami {
*
* @returns returns vector of agents successfully stepped
*/
virtual std::optional<std::unique_ptr<std::vector<AgentID>>>
virtual std::unique_ptr<std::vector<AgentID>>
step(std::shared_ptr<Model> model, std::unique_ptr<std::vector<AgentID>> agent_list) = 0;
virtual std::optional<std::unique_ptr<std::vector<AgentID>>>
virtual std::unique_ptr<std::vector<AgentID>>
step(std::shared_ptr<ReporterModel> model, std::unique_ptr<std::vector<AgentID>> agent_list) = 0;
protected:

9
include/kami/sequential.h
View File

@@ -30,7 +30,6 @@
//! @endcond
#include <memory>
#include <optional>
#include <vector>
#include <kami/agent.h>
@@ -62,9 +61,9 @@ namespace kami {
*
* @returns returns vector of agents successfully stepped
*/
std::optional<std::unique_ptr<std::vector<AgentID>>> step(std::shared_ptr<Model> model) override;
std::unique_ptr<std::vector<AgentID>> step(std::shared_ptr<Model> model) override;
std::optional<std::unique_ptr<std::vector<AgentID>>> step(std::shared_ptr<ReporterModel> model) override;
std::unique_ptr<std::vector<AgentID>> step(std::shared_ptr<ReporterModel> model) override;
/**
* @brief Execute a single time step.
@@ -79,10 +78,10 @@ namespace kami {
*
* @returns returns vector of agents successfully stepped
*/
std::optional<std::unique_ptr<std::vector<AgentID>>>
std::unique_ptr<std::vector<AgentID>>
step(std::shared_ptr<Model> model, std::unique_ptr<std::vector<AgentID>> agent_list) override;
std::optional<std::unique_ptr<std::vector<AgentID>>>
std::unique_ptr<std::vector<AgentID>>
step(std::shared_ptr<ReporterModel> model, std::unique_ptr<std::vector<AgentID>> agent_list) override;
};

2
include/kami/sologrid1d.h
View File

@@ -63,7 +63,7 @@ namespace kami {
* @returns false if the agent is not placed at the specified
* location, otherwise, true
*/
std::optional<AgentID> add_agent(AgentID agent_id, const GridCoord1D &coord) override;
AgentID add_agent(AgentID agent_id, const GridCoord1D &coord) override;
};
} // namespace kami

2
include/kami/sologrid2d.h
View File

@@ -65,7 +65,7 @@ namespace kami {
* @returns false if the agent is not placed at the specified
* location, otherwise, true
*/
std::optional<AgentID> add_agent(AgentID agent_id, const GridCoord2D &coord) override;
AgentID add_agent(AgentID agent_id, const GridCoord2D &coord) override;
};

14
include/kami/staged.h
View File

@@ -30,7 +30,6 @@
//! @endcond
#include <memory>
#include <optional>
#include <vector>
#include <kami/agent.h>
@@ -62,10 +61,10 @@ namespace kami {
*
* @returns returns vector of agents successfully stepped
*/
std::optional<std::unique_ptr<std::vector<AgentID>>>
std::unique_ptr<std::vector<AgentID>>
step(std::shared_ptr<Model> model, std::unique_ptr<std::vector<AgentID>> agent_list) override;
std::optional<std::unique_ptr<std::vector<AgentID>>>
std::unique_ptr<std::vector<AgentID>>
step(std::shared_ptr<ReporterModel> model, std::unique_ptr<std::vector<AgentID>> agent_list) override;
private:
@@ -81,9 +80,9 @@ namespace kami {
*
* @returns returns vector of agents successfully advanced
*/
std::optional<std::unique_ptr<std::vector<AgentID>>> advance(std::shared_ptr<Model> model);
std::unique_ptr<std::vector<AgentID>> advance(std::shared_ptr<Model> model);
std::optional<std::unique_ptr<std::vector<AgentID>>> advance(std::shared_ptr<ReporterModel> model);
std::unique_ptr<std::vector<AgentID>> advance(std::shared_ptr<ReporterModel> model);
/**
* @brief Advance a single time step.
@@ -98,11 +97,8 @@ namespace kami {
*
* @returns returns vector of agents successfully advanced
*/
std::optional<std::unique_ptr<std::vector<AgentID>>>
std::unique_ptr<std::vector<AgentID>>
advance(std::shared_ptr<Model> model, std::unique_ptr<std::vector<AgentID>> agent_list);
std::optional<std::unique_ptr<std::vector<AgentID>>>
advance(std::shared_ptr<ReporterModel> model, std::unique_ptr<std::vector<AgentID>> agent_list);
};
} // namespace kami

1
src/libkami/CMakeLists.txt
View File

@@ -31,6 +31,7 @@ create_library(
staged.cc
PUBLIC_INCLUDE_PATHS "$<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/include>" "$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/generated_headers>"
PRIVATE_LINKED_TARGETS ${COVERAGE_TARGET}
PUBLIC_LINKED_TARGETS fmt
EXPORT_FILE_PATH "${CMAKE_CURRENT_BINARY_DIR}/generated_headers/kami/KAMI_EXPORT.h"
)

51
src/libkami/grid1d.cc
View File

@@ -25,14 +25,16 @@
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <fmt/format.h>
#include <kami/agent.h>
#include <kami/domain.h>
#include <kami/exception.h>
#include <kami/grid1d.h>
namespace kami {
@@ -89,27 +91,19 @@ namespace kami {
_agent_index = std::make_unique<std::map<AgentID, GridCoord1D>>();
}
std::optional<AgentID> Grid1D::delete_agent(AgentID agent_id) {
auto coord = get_location_by_agent(agent_id);
if (!coord)
return std::nullopt;
return delete_agent(agent_id, coord.value());
AgentID Grid1D::delete_agent(AgentID agent_id) {
return delete_agent(agent_id, get_location_by_agent(agent_id));
}
std::optional<AgentID> Grid1D::delete_agent(AgentID agent_id, const GridCoord1D &coord) {
auto agent_location = _agent_grid->find(coord);
if (agent_location == _agent_grid->end())
return std::nullopt;
for (auto test_agent_id = agent_location; test_agent_id != _agent_grid->end(); test_agent_id++)
AgentID Grid1D::delete_agent(AgentID agent_id, const GridCoord1D &coord) {
for (auto test_agent_id = _agent_grid->find(coord); test_agent_id != _agent_grid->end(); test_agent_id++)
if (test_agent_id->second == agent_id) {
_agent_grid->erase(test_agent_id);
_agent_index->erase(agent_id);
return agent_id;
}
return std::nullopt;
throw exception::AgentNotFound("");
}
bool Grid1D::is_location_valid(const GridCoord1D &coord) const {
@@ -123,27 +117,16 @@ namespace kami {
return grid_location.first == grid_location.second;
}
std::optional<AgentID> Grid1D::move_agent(const AgentID agent_id, const GridCoord1D &coord) {
auto coord_current = get_location_by_agent(agent_id);
if (!coord_current)
return std::nullopt;
if (!delete_agent(agent_id, coord_current.value()))
return std::nullopt;
return add_agent(agent_id, coord);
AgentID Grid1D::move_agent(const AgentID agent_id, const GridCoord1D &coord) {
return add_agent(delete_agent(agent_id, get_location_by_agent(agent_id)), coord);
}
std::optional<std::shared_ptr<std::unordered_set<GridCoord1D>>>
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));
return std::move(get_neighborhood(get_location_by_agent(agent_id), include_center));
}
std::optional<std::shared_ptr<std::unordered_set<GridCoord1D>>>
std::shared_ptr<std::unordered_set<GridCoord1D>>
Grid1D::get_neighborhood(const GridCoord1D &coord, const bool include_center) const {
auto neighborhood = std::make_shared<std::unordered_set<GridCoord1D>>();
@@ -161,11 +144,11 @@ namespace kami {
return std::move(neighborhood);
}
std::optional<std::shared_ptr<std::set<AgentID>>> Grid1D::get_location_contents(const GridCoord1D &coord) const {
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::nullopt;
throw exception::LocationUnavailable(fmt::format("Coordinates {} are invalid", coord.to_string()));
if (is_location_empty(coord))
return agent_ids;
@@ -182,10 +165,10 @@ namespace kami {
unsigned int Grid1D::get_maximum_x() const { return _maximum_x; }
std::optional<GridCoord1D> Grid1D::get_location_by_agent(const AgentID &agent_id) const {
GridCoord1D Grid1D::get_location_by_agent(const AgentID &agent_id) const {
auto coord = _agent_index->find(agent_id);
if (coord == _agent_index->end())
return std::nullopt;
throw exception::AgentNotFound(fmt::format("Agent {} not found on grid", agent_id.to_string()));
return coord->second;
}

57
src/libkami/grid2d.cc
View File

@@ -30,8 +30,11 @@
#include <utility>
#include <vector>
#include <fmt/format.h>
#include <kami/agent.h>
#include <kami/domain.h>
#include <kami/exception.h>
#include <kami/grid2d.h>
namespace kami {
@@ -121,27 +124,19 @@ namespace kami {
_agent_index = std::make_unique<std::map<AgentID, GridCoord2D>>();
}
std::optional<AgentID> Grid2D::delete_agent(AgentID agent_id) {
auto coord = get_location_by_agent(agent_id);
if (!coord)
return std::nullopt;
return delete_agent(agent_id, coord.value());
AgentID Grid2D::delete_agent(AgentID agent_id) {
return delete_agent(agent_id, get_location_by_agent(agent_id));
}
std::optional<AgentID> Grid2D::delete_agent(AgentID agent_id, const GridCoord2D &coord) {
auto agent_location = _agent_grid->find(coord);
if (agent_location == _agent_grid->end())
return std::nullopt;
for (auto test_agent_id = agent_location; test_agent_id != _agent_grid->end(); test_agent_id++)
AgentID Grid2D::delete_agent(AgentID agent_id, const GridCoord2D &coord) {
for (auto test_agent_id = _agent_grid->find(coord); test_agent_id != _agent_grid->end(); test_agent_id++)
if (test_agent_id->second == agent_id) {
_agent_grid->erase(test_agent_id);
_agent_index->erase(agent_id);
return agent_id;
}
return std::nullopt;
throw exception::AgentNotFound("");
}
bool Grid2D::is_location_valid(const GridCoord2D &coord) const {
@@ -157,28 +152,17 @@ namespace kami {
return grid_location.first == grid_location.second;
}
std::optional<AgentID> Grid2D::move_agent(const AgentID agent_id, const GridCoord2D &coord) {
auto coord_current = get_location_by_agent(agent_id);
if (!coord_current)
return std::nullopt;
if (!delete_agent(agent_id, coord_current.value()))
return std::nullopt;
return add_agent(agent_id, coord);
AgentID Grid2D::move_agent(const AgentID agent_id, const GridCoord2D &coord) {
return add_agent(delete_agent(agent_id, get_location_by_agent(agent_id)), coord);
}
std::optional<std::shared_ptr<std::unordered_set<GridCoord2D>>>
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));
return std::move(get_neighborhood(get_location_by_agent(agent_id), include_center, neighborhood_type));
}
std::optional<std::shared_ptr<std::unordered_set<GridCoord2D>>>
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::unordered_set<GridCoord2D>>();
@@ -192,10 +176,11 @@ namespace kami {
directions = directions_moore;
break;
default:
return std::nullopt;
throw exception::InvalidOption(
fmt::format("Invalid neighborhood type {} given", (unsigned int) neighborhood_type));
}
// We assume our starting position is valid
if (include_center)
if (include_center and is_location_valid(coord))
neighborhood->insert(coord);
for (auto &direction: directions) {
@@ -208,11 +193,11 @@ namespace kami {
return std::move(neighborhood);
}
std::optional<std::shared_ptr<std::set<AgentID>>> Grid2D::get_location_contents(const GridCoord2D &coord) const {
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::nullopt;
throw exception::LocationUnavailable(fmt::format("Coordinates {} are invalid", coord.to_string()));
if (is_location_empty(coord))
return agent_ids;
@@ -233,10 +218,10 @@ namespace kami {
unsigned int Grid2D::get_maximum_y() const { return _maximum_y; }
std::optional<GridCoord2D> Grid2D::get_location_by_agent(const AgentID &agent_id) const {
GridCoord2D Grid2D::get_location_by_agent(const AgentID &agent_id) const {
auto coord = _agent_index->find(agent_id);
if (coord == _agent_index->end())
return std::nullopt;
throw exception::AgentNotFound(fmt::format("Agent {} not found on grid", agent_id.to_string()));
return coord->second;
}

23
src/libkami/model.cc
View File

@@ -26,15 +26,16 @@
#include <memory>
#include <utility>
#include <kami/exception.h>
#include <kami/model.h>
#include <kami/scheduler.h>
namespace kami {
std::optional<std::shared_ptr<Domain>> Model::get_domain() {
if(_domain == nullptr)
return std::nullopt;
return(_domain);
std::shared_ptr<Domain> Model::get_domain() {
if (_domain == nullptr)
throw exception::ResourceNotAvailable("Domain not found in model");
return _domain;
}
std::shared_ptr<Domain> Model::set_domain(std::shared_ptr<Domain> domain) {
@@ -42,10 +43,10 @@ namespace kami {
return _domain;
}
std::optional<std::shared_ptr<Population>> Model::get_population() {
if(_pop == nullptr)
return std::nullopt;
return(_pop);
std::shared_ptr<Population> Model::get_population() {
if (_pop == nullptr)
throw exception::ResourceNotAvailable("Population not found in model");
return _pop;
}
std::shared_ptr<Population> Model::set_population(std::shared_ptr<Population> population) {
@@ -53,10 +54,10 @@ namespace kami {
return _pop;
}
std::optional<std::shared_ptr<Scheduler>> Model::get_scheduler() {
std::shared_ptr<Scheduler> Model::get_scheduler() {
if (_sched == nullptr)
return std::nullopt;
return (_sched);
throw exception::ResourceNotAvailable("Scheduler not found in model");
return _sched;
}
std::shared_ptr<Scheduler> Model::set_scheduler(std::shared_ptr<Scheduler> scheduler) {

7
src/libkami/multigrid1d.cc
View File

@@ -23,8 +23,11 @@
* SOFTWARE.
*/
#include <fmt/format.h>
#include <kami/agent.h>
#include <kami/domain.h>
#include <kami/exception.h>
#include <kami/grid1d.h>
#include <kami/multigrid1d.h>
@@ -33,9 +36,9 @@ namespace kami {
MultiGrid1D::MultiGrid1D(unsigned int maximum_x, bool wrap_x)
: Grid1D(maximum_x, wrap_x) {}
std::optional<AgentID> MultiGrid1D::add_agent(const AgentID agent_id, const GridCoord1D &coord) {
AgentID MultiGrid1D::add_agent(const AgentID agent_id, const GridCoord1D &coord) {
if (!is_location_valid(coord))
return std::nullopt;
throw exception::LocationUnavailable(fmt::format("Coordinates {} are invalid", coord.to_string()));
_agent_index->insert(std::pair<AgentID, GridCoord1D>(agent_id, coord));
_agent_grid->insert(std::pair<GridCoord1D, AgentID>(coord, agent_id));

7
src/libkami/multigrid2d.cc
View File

@@ -23,8 +23,11 @@
* SOFTWARE.
*/
#include <fmt/format.h>
#include <kami/agent.h>
#include <kami/domain.h>
#include <kami/exception.h>
#include <kami/grid2d.h>
#include <kami/multigrid2d.h>
@@ -33,9 +36,9 @@ namespace kami {
MultiGrid2D::MultiGrid2D(unsigned int maximum_x, unsigned int maximum_y, bool wrap_x, bool wrap_y)
: Grid2D(maximum_x, maximum_y, wrap_x, wrap_y) {}
std::optional<AgentID> MultiGrid2D::add_agent(const AgentID agent_id, const GridCoord2D &coord) {
AgentID MultiGrid2D::add_agent(const AgentID agent_id, const GridCoord2D &coord) {
if (!is_location_valid(coord))
return std::nullopt;
throw exception::LocationUnavailable(fmt::format("Coordinates {} are invalid", coord.to_string()));
_agent_index->insert(std::pair<AgentID, GridCoord2D>(agent_id, coord));
_agent_grid->insert(std::pair<GridCoord2D, AgentID>(coord, agent_id));

22
src/libkami/population.cc
View File

@@ -24,37 +24,39 @@
*/
#include <algorithm>
#include <optional>
#include <utility>
#include <vector>
#include <kami/agent.h>
#include <kami/exception.h>
#include <kami/population.h>
namespace kami {
AgentID Population::add_agent(const std::shared_ptr<Agent>& agent) {
AgentID Population::add_agent(const std::shared_ptr<Agent> &agent) noexcept {
auto agent_id = agent->get_agent_id();
_agent_map.insert(std::pair<AgentID, std::shared_ptr<Agent>>(agent_id, agent));
return(agent->get_agent_id());
return agent->get_agent_id();
}
std::optional<std::shared_ptr<Agent>> Population::delete_agent(const AgentID agent_id) {
std::shared_ptr<Agent> Population::delete_agent(const AgentID agent_id) {
auto agent_it = _agent_map.find(agent_id);
if(agent_it == _agent_map.end())
return std::nullopt;
if (agent_it == _agent_map.end())
throw exception::ResourceNotAvailable("Agent not found in population");
auto agent = agent_it->second;
_agent_map.erase(agent_it);
return std::make_optional(agent);
return std::move(agent);
}
std::optional<std::shared_ptr<Agent>> Population::get_agent_by_id(const AgentID agent_id) const {
std::shared_ptr<Agent> Population::get_agent_by_id(const AgentID agent_id) const {
auto agent_it = _agent_map.find(agent_id);
if(agent_it != _agent_map.end()) return(agent_it->second);
return std::nullopt;
if (agent_it == _agent_map.end())
throw exception::ResourceNotAvailable("Agent not found in population");
return agent_it->second;
}
std::unique_ptr<std::vector<AgentID>> Population::get_agent_list() const {

9
src/libkami/random.cc
View File

@@ -30,6 +30,7 @@
#include <utility>
#include <vector>
#include <kami/exception.h>
#include <kami/model.h>
#include <kami/random.h>
#include <kami/sequential.h>
@@ -40,19 +41,19 @@ namespace kami {
this->_rng = std::move(rng);
}
std::optional<std::unique_ptr<std::vector<AgentID>>>
std::unique_ptr<std::vector<AgentID>>
RandomScheduler::step(std::shared_ptr<Model> model, std::unique_ptr<std::vector<AgentID>> agent_list) {
if (_rng == nullptr)
return std::nullopt;
throw exception::ResourceNotAvailable("No random number generator available");
shuffle(agent_list->begin(), agent_list->end(), *_rng);
return std::move(this->SequentialScheduler::step(model, std::move(agent_list)));
}
std::optional<std::unique_ptr<std::vector<AgentID>>>
std::unique_ptr<std::vector<AgentID>>
RandomScheduler::step(std::shared_ptr<ReporterModel> model, std::unique_ptr<std::vector<AgentID>> agent_list) {
if (_rng == nullptr)
return std::nullopt;
throw exception::ResourceNotAvailable("No random number generator available");
shuffle(agent_list->begin(), agent_list->end(), *_rng);
return std::move(this->SequentialScheduler::step(model, std::move(agent_list)));

19
src/libkami/reporter.cc
View File

@@ -72,7 +72,7 @@ namespace kami {
std::unique_ptr<nlohmann::json>
Reporter::collect(const std::shared_ptr<ReporterModel> &model) {
auto pop = model->get_population();
return collect(model, pop.value());
return collect(model, pop);
}
std::unique_ptr<nlohmann::json>
@@ -88,17 +88,14 @@ namespace kami {
for (auto &agent_id: *agent_list) {
auto agent_data = nlohmann::json();
auto agent_opt = model->get_population().value()->get_agent_by_id(agent_id);
auto agent = std::static_pointer_cast<ReporterAgent>(model->get_population()->get_agent_by_id(agent_id));
agent_data["agent_id"] = agent_id.to_string();
if (!agent_opt) {
agent_data["data"] = {}; // Record JSON null
} else {
auto agent = std::static_pointer_cast<ReporterAgent>(agent_opt.value());
auto agent_collection = agent->collect();
if (agent_collection)
agent_data["data"] = *agent_collection.value();
}
auto agent_collection = agent->collect();
if (agent_collection)
agent_data["data"] = *agent_collection;
collection_array.push_back(agent_data);
}
auto model_data = model->collect();
@@ -107,7 +104,7 @@ namespace kami {
(*collection)["step_id"] = model->get_step_id();
if (model_data)
(*collection)["model_data"] = *model_data.value();
(*collection)["model_data"] = *model_data;
(*collection)["agent_data"] = *agent_collection;
_report_data->push_back(*collection);

48
src/libkami/sequential.cc
View File

@@ -24,7 +24,6 @@
*/
#include <memory>
#include <optional>
#include <vector>
#include <kami/agent.h>
@@ -33,66 +32,43 @@
namespace kami {
std::optional<std::unique_ptr<std::vector<AgentID>>> SequentialScheduler::step(std::shared_ptr<Model> model) {
std::unique_ptr<std::vector<AgentID>> SequentialScheduler::step(std::shared_ptr<Model> model) {
auto population = model->get_population();
if (!population)
return std::nullopt;
return std::move(this->step(model, population.value()->get_agent_list()));
return std::move(this->step(model, population->get_agent_list()));
}
std::optional<std::unique_ptr<std::vector<AgentID>>>
SequentialScheduler::step(std::shared_ptr<ReporterModel> model) {
std::unique_ptr<std::vector<AgentID>> SequentialScheduler::step(std::shared_ptr<ReporterModel> model) {
auto population = model->get_population();
if (!population)
return std::nullopt;
return std::move(this->step(model, population.value()->get_agent_list()));
return std::move(this->step(model, population->get_agent_list()));
}
std::optional<std::unique_ptr<std::vector<AgentID>>>
std::unique_ptr<std::vector<AgentID>>
SequentialScheduler::step(std::shared_ptr<Model> model, std::unique_ptr<std::vector<AgentID>> agent_list) {
auto return_agent_list = std::make_unique<std::vector<AgentID>>();
auto population = model->get_population();
if (!population)
return std::nullopt;
Scheduler::_step_counter++;
for (auto &agent_id: *agent_list) {
auto agent_opt = population.value()->get_agent_by_id(agent_id);
auto agent = population->get_agent_by_id(agent_id);
if (agent_opt) {
auto agent = agent_opt.value();
agent->step(model);
return_agent_list->push_back(agent_id);
}
agent->step(model);
return_agent_list->push_back(agent_id);
}
return std::move(return_agent_list);
}
std::optional<std::unique_ptr<std::vector<AgentID>>>
std::unique_ptr<std::vector<AgentID>>
SequentialScheduler::step(std::shared_ptr<ReporterModel> model, std::unique_ptr<std::vector<AgentID>> agent_list) {
auto return_agent_list = std::make_unique<std::vector<AgentID>>();
auto population = model->get_population();
if (!population)
return std::nullopt;
Scheduler::_step_counter++;
for (auto &agent_id: *agent_list) {
auto agent_opt = population.value()->get_agent_by_id(agent_id);
auto agent = population->get_agent_by_id(agent_id);
if (agent_opt) {
auto agent = std::dynamic_pointer_cast<ReporterAgent>(agent_opt.value());
agent->step(model);
return_agent_list->push_back(agent_id);
}
agent->step(model);
return_agent_list->push_back(agent_id);
}
return std::move(return_agent_list);

9
src/libkami/sologrid1d.cc
View File

@@ -23,7 +23,10 @@
* SOFTWARE.
*/
#include <fmt/format.h>
#include <kami/agent.h>
#include <kami/exception.h>
#include <kami/sologrid1d.h>
namespace kami {
@@ -31,11 +34,11 @@ namespace kami {
SoloGrid1D::SoloGrid1D(unsigned int maximum_x, bool wrap_x)
: Grid1D(maximum_x, wrap_x) {}
std::optional<AgentID> SoloGrid1D::add_agent(const AgentID agent_id, const GridCoord1D &coord) {
AgentID SoloGrid1D::add_agent(const AgentID agent_id, const GridCoord1D &coord) {
if (!is_location_valid(coord))
return std::nullopt;
throw exception::LocationUnavailable(fmt::format("Coordinates {} are invalid", coord.to_string()));
if (!is_location_empty(coord))
return std::nullopt;
throw exception::LocationUnavailable(fmt::format("Coordinates {} already occupied", coord.to_string()));
_agent_index->insert(std::pair<AgentID, GridCoord1D>(agent_id, coord));
_agent_grid->insert(std::pair<GridCoord1D, AgentID>(coord, agent_id));

15
src/libkami/sologrid2d.cc
View File

@@ -23,21 +23,24 @@
* SOFTWARE.
*/
#include <kami/agent.h>
#include <kami/sologrid2d.h>
#include <vector>
#include <fmt/format.h>
#include <kami/agent.h>
#include <kami/exception.h>
#include <kami/sologrid2d.h>
namespace kami {
SoloGrid2D::SoloGrid2D(unsigned int maximum_x, unsigned int maximum_y, bool wrap_x, bool wrap_y)
: Grid2D(maximum_x, maximum_y, wrap_x, wrap_y) {}
std::optional<AgentID> SoloGrid2D::add_agent(const AgentID agent_id, const GridCoord2D &coord) {
AgentID SoloGrid2D::add_agent(const AgentID agent_id, const GridCoord2D &coord) {
if (!is_location_valid(coord))
return std::nullopt;
throw exception::LocationUnavailable(fmt::format("Coordinates {} are invalid", coord.to_string()));
if (!is_location_empty(coord))
return std::nullopt;
throw exception::LocationUnavailable(fmt::format("Coordinates {} already occupied", coord.to_string()));
_agent_index->insert(std::pair<AgentID, GridCoord2D>(agent_id, coord));
_agent_grid->insert(std::pair<GridCoord2D, AgentID>(coord, agent_id));

66
src/libkami/staged.cc
View File

@@ -35,80 +35,38 @@
namespace kami {
std::optional<std::unique_ptr<std::vector<AgentID>>>
std::unique_ptr<std::vector<AgentID>>
StagedScheduler::step(std::shared_ptr<Model> model, std::unique_ptr<std::vector<AgentID>> agent_list) {
auto stepped_agent_list = this->SequentialScheduler::step(model, std::move(agent_list));
if (!stepped_agent_list)
return std::nullopt;
return std::move(this->advance(model, std::move(stepped_agent_list.value())));
return std::move(this->advance(model, std::move(stepped_agent_list)));
}
std::optional<std::unique_ptr<std::vector<AgentID>>>
std::unique_ptr<std::vector<AgentID>>
StagedScheduler::step(std::shared_ptr<ReporterModel> model, std::unique_ptr<std::vector<AgentID>> agent_list) {
auto stepped_agent_list = this->SequentialScheduler::step(model, std::move(agent_list));
if (!stepped_agent_list)
return std::nullopt;
return std::move(this->advance(model, std::move(stepped_agent_list.value())));
return std::move(this->advance(model, std::move(stepped_agent_list)));
}
std::optional<std::unique_ptr<std::vector<AgentID>>> StagedScheduler::advance(std::shared_ptr<Model> model) {
std::unique_ptr<std::vector<AgentID>> StagedScheduler::advance(std::shared_ptr<Model> model) {
auto population = model->get_population();
if (!population)
return std::nullopt;
return std::move(this->advance(model, population.value()->get_agent_list()));
return std::move(this->advance(model, population->get_agent_list()));
}
std::optional<std::unique_ptr<std::vector<AgentID>>>
StagedScheduler::advance(std::shared_ptr<ReporterModel> model) {
std::unique_ptr<std::vector<AgentID>> StagedScheduler::advance(std::shared_ptr<ReporterModel> model) {
auto population = model->get_population();
if (!population)
return std::nullopt;
return std::move(this->advance(model, population.value()->get_agent_list()));
return std::move(this->advance(model, population->get_agent_list()));
}
std::optional<std::unique_ptr<std::vector<AgentID>>>
std::unique_ptr<std::vector<AgentID>>
StagedScheduler::advance(std::shared_ptr<Model> model, std::unique_ptr<std::vector<AgentID>> agent_list) {
auto return_agent_list = std::make_unique<std::vector<AgentID>>();
auto population = model->get_population();
if (!population)
return std::nullopt;
for (auto &agent_id: *agent_list) {
auto agent_opt = population.value()->get_agent_by_id(agent_id);
auto agent = std::static_pointer_cast<StagedAgent>(population->get_agent_by_id(agent_id));
if (agent_opt) {
auto agent = std::static_pointer_cast<StagedAgent>(agent_opt.value());
agent->advance(model);
return_agent_list->push_back(agent_id);
}
}
return std::move(return_agent_list);
}
std::optional<std::unique_ptr<std::vector<AgentID>>>
StagedScheduler::advance(std::shared_ptr<ReporterModel> model, std::unique_ptr<std::vector<AgentID>> agent_list) {
auto return_agent_list = std::make_unique<std::vector<AgentID>>();
auto population = model->get_population();
if (!population)
return std::nullopt;
for (auto &agent_id: *agent_list) {
auto agent_opt = population.value()->get_agent_by_id(agent_id);
if (agent_opt) {
auto agent = std::static_pointer_cast<StagedAgent>(agent_opt.value());
agent->advance(model);
return_agent_list->push_back(agent_id);
}
agent->advance(model);
return_agent_list->push_back(agent_id);
}
return std::move(return_agent_list);

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

@@ -53,18 +53,15 @@ TEST(MultiGrid1D, add_agent) {
{
auto agent_id_baz = multigrid1d_foo.add_agent(agent_id_foo, coord2);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_foo);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
{
auto agent_id_baz = multigrid1d_foo.add_agent(agent_id_bar, coord2);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_bar);
EXPECT_EQ(agent_id_baz, agent_id_bar);
}
{
auto agent_id_baz = multigrid1d_foo.add_agent(agent_id_bar, coord3);
EXPECT_TRUE(agent_id_baz);
EXPECT_EQ(agent_id_baz.value(), agent_id_bar);
EXPECT_EQ(agent_id_baz, agent_id_bar);
}
}
@@ -77,8 +74,7 @@ TEST(MultiGrid1D, delete_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
{
MultiGrid1D multigrid1d_foo(10, true);
@@ -86,8 +82,7 @@ TEST(MultiGrid1D, delete_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
{
MultiGrid1D multigrid1d_foo(10, true);
@@ -95,8 +90,7 @@ TEST(MultiGrid1D, delete_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_bar);
}
{
@@ -104,8 +98,7 @@ TEST(MultiGrid1D, delete_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
{
MultiGrid1D multigrid1d_foo(10, true);
@@ -113,8 +106,7 @@ TEST(MultiGrid1D, delete_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
{
MultiGrid1D multigrid1d_foo(10, true);
@@ -122,15 +114,13 @@ TEST(MultiGrid1D, delete_agent) {
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);
EXPECT_EQ(agent_id_baz, 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);
@@ -138,7 +128,6 @@ TEST(MultiGrid1D, delete_agent) {
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);
@@ -146,7 +135,6 @@ TEST(MultiGrid1D, delete_agent) {
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);
}
}
@@ -202,15 +190,13 @@ TEST(MultiGrid1D, move_agent) {
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);
EXPECT_EQ(agent_id_baz, 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);
@@ -218,8 +204,7 @@ TEST(MultiGrid1D, move_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
{
MultiGrid1D multigrid1d_foo(10, true);
@@ -227,8 +212,7 @@ TEST(MultiGrid1D, move_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
}
@@ -239,78 +223,70 @@ TEST(MultiGrid1D, get_neighborhood) {
{
MultiGrid1D multigrid1d_foo(10, true);
auto tval = unordered_set<GridCoord1D>({coord0, coord1, coord9});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord1, coord9 });
auto rval = multigrid1d_foo.get_neighborhood(coord0, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid1D multigrid1d_foo(10, true);
auto tval = unordered_set<GridCoord1D>({coord0, coord1, coord2});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord1, coord2 });
auto rval = multigrid1d_foo.get_neighborhood(coord1, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid1D multigrid1d_foo(10, false);
auto tval = unordered_set<GridCoord1D>({coord0, coord1});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord1 });
auto rval = multigrid1d_foo.get_neighborhood(coord0, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid1D multigrid1d_foo(10, false);
auto tval = unordered_set<GridCoord1D>({coord0, coord1, coord2});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord1, coord2 });
auto rval = multigrid1d_foo.get_neighborhood(coord1, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid1D multigrid1d_foo(10, true);
auto tval = unordered_set<GridCoord1D>({coord1, coord9});
auto tval = unordered_set < GridCoord1D > ({ coord1, coord9 });
auto rval = multigrid1d_foo.get_neighborhood(coord0, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid1D multigrid1d_foo(10, true);
auto tval = unordered_set<GridCoord1D>({coord0, coord2});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord2 });
auto rval = multigrid1d_foo.get_neighborhood(coord1, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid1D multigrid1d_foo(10, false);
auto tval = unordered_set<GridCoord1D>({coord1});
auto tval = unordered_set < GridCoord1D > ({ coord1 });
auto rval = multigrid1d_foo.get_neighborhood(coord0, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid1D multigrid1d_foo(10, false);
auto tval = unordered_set<GridCoord1D>({coord0, coord2});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord2 });
auto rval = multigrid1d_foo.get_neighborhood(coord1, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid1D multigrid1d_foo(10, true);
auto tval = unordered_set<GridCoord1D>({coord0, coord1, coord9});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord1, coord9 });
auto rval = multigrid1d_foo.get_neighborhood(agent_id_foo, true);
EXPECT_FALSE(rval);
@@ -318,81 +294,73 @@ TEST(MultiGrid1D, get_neighborhood) {
{
MultiGrid1D multigrid1d_foo(10, true);
multigrid1d_foo.add_agent(agent_id_foo, coord0);
auto tval = unordered_set<GridCoord1D>({coord0, coord1, coord9});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord1, coord9 });
auto rval = multigrid1d_foo.get_neighborhood(agent_id_foo, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid1D multigrid1d_foo(10, true);
multigrid1d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord1D>({coord0, coord1, coord2});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord1, coord2 });
auto rval = multigrid1d_foo.get_neighborhood(agent_id_foo, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid1D multigrid1d_foo(10, false);
multigrid1d_foo.add_agent(agent_id_foo, coord0);
auto tval = unordered_set<GridCoord1D>({coord0, coord1});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord1 });
auto rval = multigrid1d_foo.get_neighborhood(agent_id_foo, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid1D multigrid1d_foo(10, false);
multigrid1d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord1D>({coord0, coord1, coord2});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord1, coord2 });
auto rval = multigrid1d_foo.get_neighborhood(agent_id_foo, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid1D multigrid1d_foo(10, true);
multigrid1d_foo.add_agent(agent_id_foo, coord0);
auto tval = unordered_set<GridCoord1D>({coord1, coord9});
auto tval = unordered_set < GridCoord1D > ({ coord1, coord9 });
auto rval = multigrid1d_foo.get_neighborhood(agent_id_foo, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid1D multigrid1d_foo(10, true);
multigrid1d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord1D>({coord0, coord2});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord2 });
auto rval = multigrid1d_foo.get_neighborhood(agent_id_foo, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid1D multigrid1d_foo(10, false);
multigrid1d_foo.add_agent(agent_id_foo, coord0);
auto tval = unordered_set<GridCoord1D>({coord1});
auto tval = unordered_set < GridCoord1D > ({ coord1 });
auto rval = multigrid1d_foo.get_neighborhood(agent_id_foo, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid1D multigrid1d_foo(10, false);
multigrid1d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord1D>({coord0, coord2});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord2 });
auto rval = multigrid1d_foo.get_neighborhood(agent_id_foo, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
}
@@ -403,17 +371,16 @@ TEST(MultiGrid1D, get_location_by_agent) {
{
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));
auto loc1 = multigrid1d_foo.get_location_by_agent(agent_id_foo);
auto loc2 = 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));
auto loc = multigrid1d_foo.get_location_by_agent(agent_id_bar);
}
}
@@ -433,7 +400,7 @@ TEST(MultiGrid1D, get_location_contents) {
auto agent_list_foo = multigrid1d_foo.get_location_contents(coord1);
EXPECT_TRUE(agent_list_foo);
EXPECT_TRUE(agent_list_foo.value()->empty());
EXPECT_TRUE(agent_list_foo->empty());
}
{
MultiGrid1D multigrid1d_foo(10, true);
@@ -441,11 +408,11 @@ TEST(MultiGrid1D, get_location_contents) {
static_cast<void>(multigrid1d_foo.add_agent(agent_id_bar, coord1));
static_cast<void>(multigrid1d_foo.add_agent(agent_id_baz, coord1));
auto tval = set<AgentID>({agent_id_foo, agent_id_bar, agent_id_baz});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid1D multigrid1d_foo(10, true);
@@ -453,11 +420,11 @@ TEST(MultiGrid1D, get_location_contents) {
static_cast<void>(multigrid1d_foo.add_agent(agent_id_bar, coord1));
static_cast<void>(multigrid1d_foo.add_agent(agent_id_baz, coord9));
auto tval = set<AgentID>({agent_id_foo, agent_id_bar});
auto tval = set < AgentID > ({ agent_id_foo, agent_id_bar });
auto rval = multigrid1d_foo.get_location_contents(coord1);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
}

513
test/unit-kami-multigrid2d.cc
View File

@@ -53,18 +53,15 @@ TEST(MultiGrid2D, add_agent) {
{
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);
EXPECT_EQ(agent_id_baz, 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);
EXPECT_EQ(agent_id_baz, 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);
EXPECT_EQ(agent_id_baz, agent_id_bar);
}
}
@@ -77,8 +74,7 @@ TEST(MultiGrid2D, delete_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
@@ -86,8 +82,7 @@ TEST(MultiGrid2D, delete_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
@@ -95,8 +90,7 @@ TEST(MultiGrid2D, delete_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_bar);
}
{
@@ -104,8 +98,7 @@ TEST(MultiGrid2D, delete_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
@@ -113,8 +106,7 @@ TEST(MultiGrid2D, delete_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
@@ -122,15 +114,13 @@ TEST(MultiGrid2D, delete_agent) {
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);
EXPECT_EQ(agent_id_baz, 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);
@@ -138,7 +128,6 @@ TEST(MultiGrid2D, delete_agent) {
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);
@@ -146,7 +135,6 @@ TEST(MultiGrid2D, delete_agent) {
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);
}
}
@@ -202,15 +190,13 @@ TEST(MultiGrid2D, move_agent) {
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);
EXPECT_EQ(agent_id_baz, 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);
@@ -218,8 +204,7 @@ TEST(MultiGrid2D, move_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
@@ -227,8 +212,7 @@ TEST(MultiGrid2D, move_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
}
@@ -239,97 +223,113 @@ TEST(MultiGrid2D, get_neighborhood_VonNeumann) {
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
auto tval = unordered_set<GridCoord2D>({{0, 1},
{0, 1},
{9, 0},
{0, 9},
{1, 0},
{0, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
auto tval = unordered_set<GridCoord2D>({{1, 2},
{2, 1},
{1, 0},
{0, 1},
{1, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
auto tval = unordered_set<GridCoord2D>({{0, 1},
{1, 0},
{0, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
auto tval = unordered_set<GridCoord2D>({{1, 2},
{2, 1},
{1, 0},
{0, 1},
{1, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
auto tval = unordered_set<GridCoord2D>({{1, 0},
{0, 1},
{9, 0},
{0, 9}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
auto tval = unordered_set<GridCoord2D>({{1, 0},
{0, 1},
{9, 0},
{0, 9}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
auto tval = unordered_set<GridCoord2D>({{1, 0},
{0, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
auto tval = unordered_set<GridCoord2D>({{1, 0},
{0, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
@@ -340,105 +340,121 @@ TEST(MultiGrid2D, get_neighborhood_VonNeumann) {
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
multigrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = unordered_set<GridCoord2D>({{0, 1},
{9, 0},
{0, 9},
{1, 0},
{0, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
multigrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord2D>({{1, 2},
{2, 1},
{1, 0},
{0, 1},
{1, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
multigrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = unordered_set<GridCoord2D>({{0, 1},
{1, 0},
{0, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
multigrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord2D>({{1, 2},
{2, 1},
{1, 0},
{0, 1},
{1, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
multigrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = unordered_set<GridCoord2D>({{1, 0},
{0, 1},
{9, 0},
{0, 9}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
multigrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord2D>({{0, 1},
{1, 2},
{2, 1},
{1, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
multigrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = unordered_set<GridCoord2D>({{1, 0},
{0, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
multigrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord2D>({{0, 1},
{1, 2},
{2, 1},
{1, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
}
@@ -451,117 +467,132 @@ TEST(MultiGrid2D, get_neighborhood_Moore) {
auto tval = unordered_set<GridCoord2D>({{9, 9},
{9, 1},
{1, 1},
{0, 1},
{9, 0},
{1, 9},
{0, 9},
{1, 0},
{0, 0}});
{ 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
auto tval = unordered_set<GridCoord2D>({{2, 2},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0},
{2, 0},
{0, 1},
{1, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
auto tval = unordered_set<GridCoord2D>({{1, 1},
{0, 1},
{1, 0},
{0, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
auto tval = unordered_set<GridCoord2D>({{2, 2},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0},
{2, 0},
{0, 1},
{1, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
auto tval = unordered_set<GridCoord2D>({{9, 9},
{9, 1},
{1, 0},
{1, 1},
{0, 1},
{0, 9},
{1, 9},
{9, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
auto tval = unordered_set<GridCoord2D>({{9, 9},
{9, 1},
{1, 0},
{1, 1},
{0, 1},
{0, 9},
{1, 9},
{9, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
auto tval = unordered_set<GridCoord2D>({{1, 0},
{1, 1},
{0, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
auto tval = unordered_set<GridCoord2D>({{1, 0},
{1, 1},
{0, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
@@ -574,129 +605,144 @@ TEST(MultiGrid2D, get_neighborhood_Moore) {
multigrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = unordered_set<GridCoord2D>({{9, 9},
{9, 1},
{1, 1},
{0, 1},
{9, 0},
{1, 9},
{0, 9},
{1, 0},
{0, 0}});
{ 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
multigrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord2D>({{2, 2},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0},
{2, 0},
{0, 1},
{1, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
multigrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = unordered_set<GridCoord2D>({{1, 1},
{0, 1},
{1, 0},
{0, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
multigrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord2D>({{2, 2},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0},
{2, 0},
{0, 1},
{1, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
multigrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = unordered_set<GridCoord2D>({{9, 9},
{9, 1},
{1, 0},
{1, 1},
{0, 1},
{0, 9},
{1, 9},
{9, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, true, true);
multigrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord2D>({{2, 2},
{2, 0},
{0, 1},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
multigrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = unordered_set<GridCoord2D>({{1, 0},
{1, 1},
{0, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
MultiGrid2D multigrid2d_foo(10, 10, false, false);
multigrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord2D>({{2, 2},
{2, 0},
{0, 1},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
}
@@ -707,17 +753,16 @@ TEST(MultiGrid2D, get_location_by_agent) {
{
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));
auto loc1 = multigrid2d_foo.get_location_by_agent(agent_id_foo);
auto loc2 = 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));
auto loc = multigrid2d_foo.get_location_by_agent(agent_id_bar);
}
}

10
test/unit-kami-population.cc
View File

@@ -88,7 +88,7 @@ TEST(Population, get_agent_by_id) {
auto agent_baz_opt = population_foo.get_agent_by_id(agent_foo->get_agent_id());
EXPECT_TRUE(agent_baz_opt);
auto agent_baz = dynamic_pointer_cast<TestAgent>(agent_baz_opt.value());
auto agent_baz = dynamic_pointer_cast<TestAgent>(agent_baz_opt);
EXPECT_EQ(agent_baz->getval(), 8675309);
}
{
@@ -105,13 +105,13 @@ TEST(Population, get_agent_by_id) {
auto agent_baz_opt = population_foo.get_agent_by_id(agent_foo->get_agent_id());
EXPECT_TRUE(agent_baz_opt);
auto agent_baz = dynamic_pointer_cast<TestAgent>(agent_baz_opt.value());
auto agent_baz = dynamic_pointer_cast<TestAgent>(agent_baz_opt);
EXPECT_EQ(agent_baz->getval(), 8675309);
auto agent_qux_opt = population_foo.get_agent_by_id(agent_bar->get_agent_id());
EXPECT_TRUE(agent_qux_opt);
auto agent_qux = dynamic_pointer_cast<TestAgent>(agent_qux_opt.value());
auto agent_qux = dynamic_pointer_cast<TestAgent>(agent_qux_opt);
EXPECT_EQ(agent_qux->getval(), 1729);
}
{
@@ -122,13 +122,13 @@ TEST(Population, get_agent_by_id) {
auto agent_qux_opt = population_foo.get_agent_by_id(agent_bar->get_agent_id());
EXPECT_TRUE(agent_qux_opt);
auto agent_qux = dynamic_pointer_cast<TestAgent>(agent_qux_opt.value());
auto agent_qux = dynamic_pointer_cast<TestAgent>(agent_qux_opt);
EXPECT_EQ(agent_qux->getval(), 1729);
auto agent_baz_opt = population_foo.get_agent_by_id(agent_foo->get_agent_id());
EXPECT_TRUE(agent_baz_opt);
auto agent_baz = dynamic_pointer_cast<TestAgent>(agent_baz_opt.value());
auto agent_baz = dynamic_pointer_cast<TestAgent>(agent_baz_opt);
EXPECT_EQ(agent_baz->getval(), 8675309);
}
}

36
test/unit-kami-random.cc
View File

@@ -51,12 +51,12 @@ public:
shared_ptr<vector<AgentID>> retval;
shared_ptr<Model> step() override {
retval = _sched->step(shared_from_this()).value();
retval = _sched->step(shared_from_this());
return shared_from_this();
}
shared_ptr<Model> step(unique_ptr<vector<AgentID>> agent_list) {
retval = _sched->step(shared_from_this(), std::move(agent_list)).value();
retval = _sched->step(shared_from_this(), std::move(agent_list));
return shared_from_this();
}
};
@@ -93,8 +93,8 @@ TEST(RandomScheduler, DefaultConstructor) {
}
TEST_F(RandomSchedulerTest, step_interface1) {
auto tval = mod->get_population().value()->get_agent_list();
auto aval = mod->get_population().value()->get_agent_list();
auto tval = mod->get_population()->get_agent_list();
auto aval = mod->get_population()->get_agent_list();
mod->step(std::move(aval));
auto rval = mod->retval;
@@ -103,14 +103,14 @@ TEST_F(RandomSchedulerTest, step_interface1) {
// Sort both return values and just make sure all of them all the same...
// We cannot test permutation since, well, you know...
set<AgentID> tval_set = set(tval->begin(), tval->end());
set<AgentID> rval_set = set(rval->begin(), rval->end());
set < AgentID > tval_set = set(tval->begin(), tval->end());
set < AgentID > rval_set = set(rval->begin(), rval->end());
EXPECT_EQ(tval_set, rval_set);
}
TEST_F(RandomSchedulerTest, step_interface2) {
auto tval = mod->get_population().value()->get_agent_list();
auto aval = mod->get_population().value()->get_agent_list();
auto tval = mod->get_population()->get_agent_list();
auto aval = mod->get_population()->get_agent_list();
mod->step(std::move(aval));
auto rval = mod->retval;
@@ -118,16 +118,16 @@ TEST_F(RandomSchedulerTest, step_interface2) {
EXPECT_TRUE(rval);
EXPECT_EQ(rval->size(), 10);
set<AgentID> tval_set = set(tval->begin(), tval->end());
set<AgentID> rval_set = set(rval->begin(), rval->end());
set < AgentID > tval_set = set(tval->begin(), tval->end());
set < AgentID > rval_set = set(rval->begin(), rval->end());
EXPECT_EQ(tval_set, rval_set);
}
TEST_F(RandomSchedulerTest, step_10000) {
// Do it a lot...
for (auto i = 0; i < 10000; i++) {
auto tval = mod->get_population().value()->get_agent_list();
auto aval = mod->get_population().value()->get_agent_list();
auto tval = mod->get_population()->get_agent_list();
auto aval = mod->get_population()->get_agent_list();
mod->step(std::move(aval));
auto rval = mod->retval;
@@ -135,24 +135,24 @@ TEST_F(RandomSchedulerTest, step_10000) {
EXPECT_TRUE(rval);
EXPECT_EQ(rval->size(), 10);
set<AgentID> tval_set = set(tval->begin(), tval->end());
set<AgentID> rval_set = set(rval->begin(), rval->end());
set < AgentID > tval_set = set(tval->begin(), tval->end());
set < AgentID > rval_set = set(rval->begin(), rval->end());
EXPECT_EQ(tval_set, rval_set);
}
}
TEST_F(RandomSchedulerTest, get_rng) {
auto rval = static_pointer_cast<RandomScheduler>(mod->get_scheduler().value())->get_rng();
auto rval = static_pointer_cast<RandomScheduler>(mod->get_scheduler())->get_rng();
EXPECT_EQ(rng, rval);
}
TEST_F(RandomSchedulerTest, set_rng) {
auto new_rng = make_shared<mt19937>();
auto rval1 = static_pointer_cast<RandomScheduler>(mod->get_scheduler().value())->get_rng();
auto rval1 = static_pointer_cast<RandomScheduler>(mod->get_scheduler())->get_rng();
static_cast<void>(static_pointer_cast<RandomScheduler>(mod->get_scheduler().value())->set_rng(new_rng));
auto rval2 = static_pointer_cast<RandomScheduler>(mod->get_scheduler().value())->get_rng();
static_cast<void>(static_pointer_cast<RandomScheduler>(mod->get_scheduler())->set_rng(new_rng));
auto rval2 = static_pointer_cast<RandomScheduler>(mod->get_scheduler())->get_rng();
EXPECT_EQ(new_rng, rval2);
EXPECT_NE(new_rng, rval1);

10
test/unit-kami-reporter.cc
View File

@@ -45,7 +45,7 @@ public:
return get_agent_id();
}
std::optional<std::unique_ptr<nlohmann::json>> collect() override {
std::unique_ptr<nlohmann::json> collect() override {
auto json_ret_val = std::make_unique<nlohmann::json>();
(*json_ret_val)["fname"] = "Jesse";
@@ -59,7 +59,7 @@ class TestModel : public ReporterModel {
public:
shared_ptr<vector<AgentID>> retval;
std::optional<std::unique_ptr<nlohmann::json>> collect() override {
std::unique_ptr<nlohmann::json> collect() override {
auto json_ret_val = std::make_unique<nlohmann::json>();
(*json_ret_val)["fname"] = "Walter";
@@ -99,17 +99,17 @@ TEST(ReporterModel, DefaultConstructor) {
}
TEST_F(ReporterModelTest, collect) {
auto aval = mod->get_population().value()->get_agent_list();
auto aval = mod->get_population()->get_agent_list();
mod->step();
auto rval = mod->collect();
EXPECT_TRUE(rval);
EXPECT_EQ(rval.value()->dump(), "{\"fname\":\"Walter\",\"lname\":\"White\"}");
EXPECT_EQ(rval->dump(), "{\"fname\":\"Walter\",\"lname\":\"White\"}");
}
TEST_F(ReporterModelTest, report) {
for (auto i = 0; i < 2; i++) {
auto aval = mod->get_population().value()->get_agent_list();
auto aval = mod->get_population()->get_agent_list();
mod->step();
auto rval = mod->collect();

8
test/unit-kami-reporteragent.cc
View File

@@ -41,7 +41,7 @@ public:
return get_agent_id();
}
std::optional<std::unique_ptr<nlohmann::json>> collect() override {
std::unique_ptr<nlohmann::json> collect() override {
auto json_ret_val = std::make_unique<nlohmann::json>();
(*json_ret_val)["fname"] = "Gus";
@@ -53,7 +53,7 @@ public:
class TestModel : public ReporterModel {
public:
std::optional<std::unique_ptr<nlohmann::json>> collect() override {
std::unique_ptr<nlohmann::json> collect() override {
return std::make_unique<nlohmann::json>();
}
};
@@ -92,8 +92,8 @@ TEST_F(ReporterAgentTest, step) {
}
TEST_F(ReporterAgentTest, collect) {
EXPECT_EQ(agent_foo.collect().value()->dump(), "{\"fname\":\"Gus\",\"lname\":\"Fring\"}");
EXPECT_NE(agent_bar.collect().value()->dump(), "{\"fname\":\"Hank\",\"lname\":\"Schrader\"}");
EXPECT_EQ(agent_foo.collect()->dump(), "{\"fname\":\"Gus\",\"lname\":\"Fring\"}");
EXPECT_NE(agent_bar.collect()->dump(), "{\"fname\":\"Hank\",\"lname\":\"Schrader\"}");
}
TEST_F(ReporterAgentTest, equality) {

16
test/unit-kami-sequential.cc
View File

@@ -49,12 +49,12 @@ public:
shared_ptr<vector<AgentID>> retval;
shared_ptr<Model> step() override {
retval = _sched->step(shared_from_this()).value();
retval = _sched->step(shared_from_this());
return shared_from_this();
}
shared_ptr<Model> step(unique_ptr<vector<AgentID>> agent_list) {
retval = _sched->step(shared_from_this(), std::move(agent_list)).value();
retval = _sched->step(shared_from_this(), std::move(agent_list));
return shared_from_this();
}
};
@@ -89,8 +89,8 @@ TEST(SequentialScheduler, DefaultConstructor) {
}
TEST_F(SequentialSchedulerTest, step_interface1) {
auto tval = mod->get_population().value()->get_agent_list();
auto aval = mod->get_population().value()->get_agent_list();
auto tval = mod->get_population()->get_agent_list();
auto aval = mod->get_population()->get_agent_list();
mod->step(std::move(aval));
auto rval = mod->retval;
@@ -101,8 +101,8 @@ TEST_F(SequentialSchedulerTest, step_interface1) {
}
TEST_F(SequentialSchedulerTest, step_interface2) {
auto tval = mod->get_population().value()->get_agent_list();
auto aval = mod->get_population().value()->get_agent_list();
auto tval = mod->get_population()->get_agent_list();
auto aval = mod->get_population()->get_agent_list();
mod->step(std::move(aval));
auto rval = mod->retval;
@@ -115,8 +115,8 @@ TEST_F(SequentialSchedulerTest, step_interface2) {
TEST_F(SequentialSchedulerTest, step_10000) {
// Do it a lot...
for (auto i = 0; i < 10000; i++) {
auto tval = mod->get_population().value()->get_agent_list();
auto aval = mod->get_population().value()->get_agent_list();
auto tval = mod->get_population()->get_agent_list();
auto aval = mod->get_population()->get_agent_list();
mod->step(std::move(aval));
auto rval = mod->retval;

133
test/unit-kami-sologrid1d.cc
View File

@@ -53,17 +53,14 @@ TEST(SoloGrid1D, add_agent) {
{
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);
EXPECT_EQ(agent_id_baz, 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);
EXPECT_EQ(agent_id_baz, agent_id_bar);
}
}
@@ -76,8 +73,7 @@ TEST(SoloGrid1D, delete_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
{
SoloGrid1D sologrid1d_foo(10, true);
@@ -85,8 +81,7 @@ TEST(SoloGrid1D, delete_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
{
SoloGrid1D sologrid1d_foo(10, true);
@@ -94,7 +89,6 @@ TEST(SoloGrid1D, delete_agent) {
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);
}
{
@@ -102,8 +96,7 @@ TEST(SoloGrid1D, delete_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
{
SoloGrid1D sologrid1d_foo(10, true);
@@ -111,8 +104,7 @@ TEST(SoloGrid1D, delete_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
{
SoloGrid1D sologrid1d_foo(10, true);
@@ -120,14 +112,12 @@ TEST(SoloGrid1D, delete_agent) {
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);
@@ -135,7 +125,6 @@ TEST(SoloGrid1D, delete_agent) {
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);
@@ -143,7 +132,6 @@ TEST(SoloGrid1D, delete_agent) {
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);
}
}
@@ -199,15 +187,13 @@ TEST(SoloGrid1D, move_agent) {
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);
EXPECT_EQ(agent_id_baz, 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);
@@ -215,8 +201,7 @@ TEST(SoloGrid1D, move_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
{
SoloGrid1D sologrid1d_foo(10, true);
@@ -224,8 +209,7 @@ TEST(SoloGrid1D, move_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
}
@@ -236,78 +220,70 @@ TEST(SoloGrid1D, get_neighborhood) {
{
SoloGrid1D sologrid1d_foo(10, true);
auto tval = unordered_set<GridCoord1D>({coord0, coord1, coord9});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord1, coord9 });
auto rval = sologrid1d_foo.get_neighborhood(coord0, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid1D sologrid1d_foo(10, true);
auto tval = unordered_set<GridCoord1D>({coord0, coord1, coord2});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord1, coord2 });
auto rval = sologrid1d_foo.get_neighborhood(coord1, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid1D sologrid1d_foo(10, false);
auto tval = unordered_set<GridCoord1D>({coord0, coord1});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord1 });
auto rval = sologrid1d_foo.get_neighborhood(coord0, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid1D sologrid1d_foo(10, false);
auto tval = unordered_set<GridCoord1D>({coord0, coord1, coord2});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord1, coord2 });
auto rval = sologrid1d_foo.get_neighborhood(coord1, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid1D sologrid1d_foo(10, true);
auto tval = unordered_set<GridCoord1D>({coord1, coord9});
auto tval = unordered_set < GridCoord1D > ({ coord1, coord9 });
auto rval = sologrid1d_foo.get_neighborhood(coord0, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid1D sologrid1d_foo(10, true);
auto tval = unordered_set<GridCoord1D>({coord0, coord2});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord2 });
auto rval = sologrid1d_foo.get_neighborhood(coord1, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid1D sologrid1d_foo(10, false);
auto tval = unordered_set<GridCoord1D>({coord1});
auto tval = unordered_set < GridCoord1D > ({ coord1 });
auto rval = sologrid1d_foo.get_neighborhood(coord0, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid1D sologrid1d_foo(10, false);
auto tval = unordered_set<GridCoord1D>({coord0, coord2});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord2 });
auto rval = sologrid1d_foo.get_neighborhood(coord1, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid1D sologrid1d_foo(10, true);
auto tval = unordered_set<GridCoord1D>({coord0, coord1, coord9});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord1, coord9 });
auto rval = sologrid1d_foo.get_neighborhood(agent_id_foo, true);
EXPECT_FALSE(rval);
@@ -315,81 +291,73 @@ TEST(SoloGrid1D, get_neighborhood) {
{
SoloGrid1D sologrid1d_foo(10, true);
sologrid1d_foo.add_agent(agent_id_foo, coord0);
auto tval = unordered_set<GridCoord1D>({coord0, coord1, coord9});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord1, coord9 });
auto rval = sologrid1d_foo.get_neighborhood(agent_id_foo, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid1D sologrid1d_foo(10, true);
sologrid1d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord1D>({coord0, coord1, coord2});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord1, coord2 });
auto rval = sologrid1d_foo.get_neighborhood(agent_id_foo, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid1D sologrid1d_foo(10, false);
sologrid1d_foo.add_agent(agent_id_foo, coord0);
auto tval = unordered_set<GridCoord1D>({coord0, coord1});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord1 });
auto rval = sologrid1d_foo.get_neighborhood(agent_id_foo, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid1D sologrid1d_foo(10, false);
sologrid1d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord1D>({coord0, coord1, coord2});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord1, coord2 });
auto rval = sologrid1d_foo.get_neighborhood(agent_id_foo, true);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid1D sologrid1d_foo(10, true);
sologrid1d_foo.add_agent(agent_id_foo, coord0);
auto tval = unordered_set<GridCoord1D>({coord1, coord9});
auto tval = unordered_set < GridCoord1D > ({ coord1, coord9 });
auto rval = sologrid1d_foo.get_neighborhood(agent_id_foo, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid1D sologrid1d_foo(10, true);
sologrid1d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord1D>({coord0, coord2});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord2 });
auto rval = sologrid1d_foo.get_neighborhood(agent_id_foo, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid1D sologrid1d_foo(10, false);
sologrid1d_foo.add_agent(agent_id_foo, coord0);
auto tval = unordered_set<GridCoord1D>({coord1});
auto tval = unordered_set < GridCoord1D > ({ coord1 });
auto rval = sologrid1d_foo.get_neighborhood(agent_id_foo, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid1D sologrid1d_foo(10, false);
sologrid1d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord1D>({coord0, coord2});
auto tval = unordered_set < GridCoord1D > ({ coord0, coord2 });
auto rval = sologrid1d_foo.get_neighborhood(agent_id_foo, false);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
}
@@ -400,17 +368,16 @@ TEST(SoloGrid1D, get_location_by_agent) {
{
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));
auto loc1 = sologrid1d_foo.get_location_by_agent(agent_id_foo);
auto loc2 = 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));
auto loc = sologrid1d_foo.get_location_by_agent(agent_id_bar);
}
}
@@ -430,7 +397,7 @@ TEST(SoloGrid1D, get_location_contents) {
auto agent_list_foo = sologrid1d_foo.get_location_contents(coord1);
EXPECT_TRUE(agent_list_foo);
EXPECT_TRUE(agent_list_foo.value()->empty());
EXPECT_TRUE(agent_list_foo->empty());
}
{
SoloGrid1D sologrid1d_foo(10, true);
@@ -438,11 +405,11 @@ TEST(SoloGrid1D, get_location_contents) {
static_cast<void>(sologrid1d_foo.add_agent(agent_id_bar, coord1));
static_cast<void>(sologrid1d_foo.add_agent(agent_id_baz, coord1));
auto tval = set<AgentID>({agent_id_foo});
auto tval = set < AgentID > ({ agent_id_foo });
auto rval = sologrid1d_foo.get_location_contents(coord1);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid1D sologrid1d_foo(10, true);
@@ -450,11 +417,11 @@ TEST(SoloGrid1D, get_location_contents) {
static_cast<void>(sologrid1d_foo.add_agent(agent_id_bar, coord1));
static_cast<void>(sologrid1d_foo.add_agent(agent_id_baz, coord9));
auto tval = set<AgentID>({agent_id_foo});
auto tval = set < AgentID > ({ agent_id_foo });
auto rval = sologrid1d_foo.get_location_contents(coord1);
EXPECT_TRUE(rval);
EXPECT_EQ(tval, *rval.value());
EXPECT_EQ(tval, *rval);
}
}

557
test/unit-kami-sologrid2d.cc
View File

@@ -53,17 +53,14 @@ TEST(SoloGrid2D, add_agent) {
{
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);
EXPECT_EQ(agent_id_baz, 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);
EXPECT_EQ(agent_id_baz, agent_id_bar);
}
}
@@ -76,8 +73,7 @@ TEST(SoloGrid2D, delete_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
@@ -85,8 +81,7 @@ TEST(SoloGrid2D, delete_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
@@ -94,7 +89,6 @@ TEST(SoloGrid2D, delete_agent) {
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);
}
{
@@ -102,8 +96,7 @@ TEST(SoloGrid2D, delete_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
@@ -111,8 +104,7 @@ TEST(SoloGrid2D, delete_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
@@ -120,14 +112,12 @@ TEST(SoloGrid2D, delete_agent) {
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);
@@ -135,7 +125,6 @@ TEST(SoloGrid2D, delete_agent) {
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);
@@ -143,7 +132,6 @@ TEST(SoloGrid2D, delete_agent) {
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);
}
}
@@ -199,15 +187,13 @@ TEST(SoloGrid2D, move_agent) {
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);
EXPECT_EQ(agent_id_baz, 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);
@@ -215,8 +201,7 @@ TEST(SoloGrid2D, move_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
@@ -224,8 +209,7 @@ TEST(SoloGrid2D, move_agent) {
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);
EXPECT_EQ(agent_id_baz, agent_id_foo);
}
}
@@ -236,206 +220,220 @@ TEST(SoloGrid2D, get_neighborhood_VonNeumann) {
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
auto tval = unordered_set<GridCoord2D>({{0, 1},
{0, 1},
{9, 0},
{0, 9},
{1, 0},
{0, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
auto tval = unordered_set<GridCoord2D>({{1, 2},
{2, 1},
{1, 0},
{0, 1},
{1, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
auto tval = unordered_set<GridCoord2D>({{0, 1},
{1, 0},
{0, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
auto tval = unordered_set<GridCoord2D>({{1, 2},
{2, 1},
{1, 0},
{0, 1},
{1, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
auto tval = unordered_set<GridCoord2D>({{1, 0},
{0, 1},
{9, 0},
{0, 9}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
auto tval = unordered_set<GridCoord2D>({{1, 0},
{0, 1},
{9, 0},
{0, 9}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
auto tval = unordered_set<GridCoord2D>({{1, 0},
{0, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
auto tval = unordered_set<GridCoord2D>({{1, 0},
{0, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
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 = unordered_set<GridCoord2D>({{0, 1},
{9, 0},
{0, 9},
{1, 0},
{0, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
sologrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord2D>({{1, 2},
{2, 1},
{1, 0},
{0, 1},
{1, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
sologrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = unordered_set<GridCoord2D>({{0, 1},
{1, 0},
{0, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
sologrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord2D>({{1, 2},
{2, 1},
{1, 0},
{0, 1},
{1, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
sologrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = unordered_set<GridCoord2D>({{1, 0},
{0, 1},
{9, 0},
{0, 9}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
sologrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord2D>({{0, 1},
{1, 2},
{2, 1},
{1, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
sologrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = unordered_set<GridCoord2D>({{1, 0},
{0, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
sologrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord2D>({{0, 1},
{1, 2},
{2, 1},
{1, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
}
@@ -447,253 +445,279 @@ TEST(SoloGrid2D, get_neighborhood_Moore) {
SoloGrid2D sologrid2d_foo(10, 10, true, true);
auto tval = unordered_set<GridCoord2D>({{9, 9},
{9, 1},
{1, 1},
{0, 1},
{9, 0},
{1, 9},
{0, 9},
{1, 0},
{0, 0}});
{ 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_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
auto tval = 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_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
SoloGrid2D sologrid2d_foo(10, 10, false, false);
auto tval = unordered_set<GridCoord2D>({{2, 2},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0},
{2, 0},
{0, 1},
{1, 1}});
auto tval = 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 = 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 = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
auto tval = unordered_set<GridCoord2D>({{9, 9},
{9, 1},
{1, 0},
{1, 1},
{0, 1},
{0, 9},
{1, 9},
{9, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
auto tval = unordered_set<GridCoord2D>({{9, 9},
{9, 1},
{1, 0},
{1, 1},
{0, 1},
{0, 9},
{1, 9},
{9, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
auto tval = unordered_set<GridCoord2D>({{1, 0},
{1, 1},
{0, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
auto tval = unordered_set<GridCoord2D>({{1, 0},
{1, 1},
{0, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
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 = unordered_set<GridCoord2D>({{9, 9},
{9, 1},
{1, 1},
{0, 1},
{9, 0},
{1, 9},
{0, 9},
{1, 0},
{0, 0}});
{ 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
sologrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord2D>({{2, 2},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0},
{2, 0},
{0, 1},
{1, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
sologrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = unordered_set<GridCoord2D>({{1, 1},
{0, 1},
{1, 0},
{0, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
sologrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord2D>({{2, 2},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0},
{2, 0},
{0, 1},
{1, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
sologrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = unordered_set<GridCoord2D>({{9, 9},
{9, 1},
{1, 0},
{1, 1},
{0, 1},
{0, 9},
{1, 9},
{9, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, true, true);
sologrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord2D>({{2, 2},
{2, 0},
{0, 1},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
sologrid2d_foo.add_agent(agent_id_foo, coord0);
auto tval = unordered_set<GridCoord2D>({{1, 0},
{1, 1},
{0, 1}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
{
SoloGrid2D sologrid2d_foo(10, 10, false, false);
sologrid2d_foo.add_agent(agent_id_foo, coord1);
auto tval = unordered_set<GridCoord2D>({{2, 2},
{2, 0},
{0, 1},
{0, 2},
{1, 2},
{0, 0},
{2, 1},
{1, 0}});
auto tval = 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());
EXPECT_EQ(tval, *rval);
}
}
@@ -704,17 +728,16 @@ TEST(SoloGrid2D, get_location_by_agent) {
{
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_foo.get_location_by_agent(agent_id_foo));
(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));
(sologrid2d_foo.get_location_by_agent(agent_id_bar));
}
}

19
test/unit-kami-staged.cc
View File

@@ -54,12 +54,12 @@ public:
shared_ptr<vector<AgentID>> retval;
shared_ptr<Model> step() override {
retval = _sched->step(shared_from_this()).value();
retval = _sched->step(shared_from_this());
return shared_from_this();
}
shared_ptr<Model> step(unique_ptr<vector<AgentID>> agent_list) {
retval = _sched->step(shared_from_this(), std::move(agent_list)).value();
retval = _sched->step(shared_from_this(), std::move(agent_list));
return shared_from_this();
}
};
@@ -94,25 +94,23 @@ TEST(StagedScheduler, DefaultConstructor) {
}
TEST_F(StagedSchedulerTest, step_interface1) {
auto tval = mod->get_population().value()->get_agent_list();
auto aval = mod->get_population().value()->get_agent_list();
auto tval = mod->get_population()->get_agent_list();
auto aval = mod->get_population()->get_agent_list();
mod->step(std::move(aval));
auto rval = mod->retval;
EXPECT_TRUE(rval);
EXPECT_EQ(rval->size(), 10);
EXPECT_EQ(*rval, *tval);
}
TEST_F(StagedSchedulerTest, step_interface2) {
auto tval = mod->get_population().value()->get_agent_list();
auto aval = mod->get_population().value()->get_agent_list();
auto tval = mod->get_population()->get_agent_list();
auto aval = mod->get_population()->get_agent_list();
mod->step(std::move(aval));
auto rval = mod->retval;
EXPECT_TRUE(rval);
EXPECT_EQ(rval->size(), 10);
EXPECT_EQ(*rval, *tval);
}
@@ -120,13 +118,12 @@ TEST_F(StagedSchedulerTest, step_interface2) {
TEST_F(StagedSchedulerTest, step_10000) {
// Do it a lot...
for (auto i = 0; i < 10000; i++) {
auto tval = mod->get_population().value()->get_agent_list();
auto aval = mod->get_population().value()->get_agent_list();
auto tval = mod->get_population()->get_agent_list();
auto aval = mod->get_population()->get_agent_list();
mod->step(std::move(aval));
auto rval = mod->retval;
EXPECT_TRUE(rval);
EXPECT_EQ(rval->size(), 10);
EXPECT_EQ(*rval, *tval);
}