test.cc File Reference

#include <assert.h>
#include <iostream>
#include <boost/test/unit_test.hpp>
#include "../Environment.hh"
#include "../env_param_func_collection.hh"
#include "../env_state_func_collection.hh"

Include dependency graph for test.cc:

Classes
struct	EnvParam
	A non-abstract EnvParam, derived from the base class. More...
struct	EnvCellState
	A non-abstract EnvCellState, derived from the base class. More...

Functions
template<typename T >
void	assert_eq (T arg1, T arg2, const double epsilon=1e-12)
template<typename Model >
void	test_add_env_func (Model &model)
int	main ()

Function Documentation

assert_eq()

template<typename T >

void assert_eq	(	T	arg1,
		T	arg2,
		const double	epsilon = 1e-12
	)

                                                           {
    T diff = std::abs(arg1 - arg2);
    assert(diff < epsilon);
}

main()

int main

(

)

{
    try {
        // Initialize the PseudoParent from config file path
        Utopia::PseudoParent pp("test.yml");
 
        // Initialize the main model instance and directly run it
        // Use the constructed EnvParam and EnvCellState; Have the model in
        // standalone mode.
        auto model = Environment<EnvParam, EnvCellState, true>(
                            "Environment", pp);
 
        // use the register function
        model.track_state("some_het_parameter");
        model.track_parameter("some_glob_parameter");
 
        // Use the push rule function
        test_add_env_func(model);
        
        return 0;
    }
    catch (std::exception& e) {
        std::cerr << e.what() << std::endl;
        return 1;
    }
    catch (...) {
        std::cerr << "Exception occurred!" << std::endl;
        return 1;
    }
}

test_add_env_func()

template<typename Model >

void test_add_env_func

(

Model &

model

)

                                     {
    using EnvStateFunc = typename Model::EnvStateFunc;
    using EnvParamFunc = typename Model::EnvParamFunc;
 
    // Add a custom lambda
    model.add_env_param_func("test_param", []() { return -1; },
                             "some_glob_parameter", {true, true, {}});
 
    EnvParamFunc epf = []() { return -2; };
 
    // Add with update mode
    model.add_env_param_func("another param test", epf, "some_glob_parameter",
                             {true, true, {}});
 
 
    // Add a custom lambda
    model.add_env_state_func("test_state",
        [](const auto& env_cell) {
            auto& env_state = env_cell->state;
            env_state.set_env("some_het_parameter", -1.);
            return env_state;
        }
    );
 
    EnvStateFunc esf = [](const auto& env_cell) {
        auto& env_state = env_cell->state;
        env_state.set_env("some_het_parameter", -1.);
        return env_state;
    };
 
    // Add with update mode
    model.add_env_state_func("another state test", esf, Update::async);
 
    // Add initial env func
    model.template add_env_state_func<true>("initial state", esf);
    // will not be invoked, but this still tests the interface
 
    // Use getter
    double my_param = model.get_parameter("some_glob_parameter");
    BOOST_TEST(my_param == 0.);
 
    // use setter
    model.set_parameter("some_glob_parameter", 100.);
    BOOST_TEST(model.get_parameter("some_glob_parameter") == 100.);
 
    // Iterate
    model.iterate();
}