TEST_F(GuardObjectTest, SharedTests) {
shared_object<int> so1; //Default Constructor
ASSERT_FALSE(so1.initialized()); //default initialization test
int val = 0;
so1 = 1; //object assignment
ASSERT_TRUE(so1.initialized(val)); //atomic assignment & initialization test
ASSERT_TRUE(val == 1);
val = 2;
shared_object<int> so2(val); //object copy constructor
val = 1;
ASSERT_TRUE(so2.initialized(val));
ASSERT_TRUE(val == 2);
so1.reset(); //reset
ASSERT_FALSE(so1.initialized());
so1.reset(); //reset is idempotent
so1 = so2; //assignment between referenced objects
ASSERT_TRUE(so1.initialized());
ASSERT_TRUE(so1 == 2);
so2 = 3;
shared_object<int> so3(so2); //shared_object copy constructor
ASSERT_TRUE(so3.initialized());
val = so3; //implicit cast to copy
ASSERT_TRUE(val == 3);
ASSERT_TRUE(so2 == 3); //Shared reference is also modified
ASSERT_TRUE(so1 == 2); //Separate reference is not modified
so2 = so3; //Avoid deadlock in self-assignment
ASSERT_TRUE(so2 == 3);
}
TEST_F(GuardObjectTest, UnlockTests) {
shared_object<int> so1; //Default Constructor
ASSERT_FALSE(so1.initialized()); //default initialization test
{
unlock_object<int> so1_unlock1(so1); //successful unlock
ASSERT_TRUE(static_cast<bool>(so1_unlock1));
unlock_object<int> so1_unlock2(so1, true); //prevented try_unlock
ASSERT_FALSE(static_cast<bool>(so1_unlock2));
*so1_unlock1 = 1; //object assignment
} //delete one empty and one held unlock_object instance
int val = 0;
ASSERT_TRUE(so1.initialized(val)); //condition for unlock_object construction
ASSERT_TRUE(val == 1);
shared_object<int> so2(2); //Default Constructor
{
unlock_object<int> so_unlock3(so1); //successful unlock
ASSERT_TRUE(static_cast<bool>(so_unlock3));
ASSERT_TRUE(*so_unlock3 == 1);
so_unlock3.reset(so2); //reset with argument
ASSERT_TRUE(static_cast<bool>(so_unlock3));
ASSERT_TRUE(*so_unlock3 == 2);
so_unlock3.reset(so2); //reset is idempotent
ASSERT_TRUE(static_cast<bool>(so_unlock3));
ASSERT_TRUE(*so_unlock3 == 2);
}
}
TEST(generateExpression, integrate_ode) {
static const bool user_facing = true;
std::stringstream msgs;
stan::lang::integrate_ode so; // null ctor should work and not raise error
std::string integration_function_name = "bar";
std::string system_function_name = "foo";
stan::lang::variable y0("y0_var_name");
y0.set_type(stan::lang::bare_array_type(stan::lang::double_type()));
stan::lang::variable t0("t0_var_name");
t0.set_type(stan::lang::double_type());
stan::lang::variable ts("ts_var_name");
ts.set_type(stan::lang::bare_array_type(stan::lang::double_type()));
stan::lang::variable theta("theta_var_name");
theta.set_type(stan::lang::bare_array_type(stan::lang::double_type()));
stan::lang::variable x("x_var_name");
x.set_type(stan::lang::bare_array_type(stan::lang::double_type()));
stan::lang::variable x_int("x_int_var_name");
x.set_type(stan::lang::bare_array_type(stan::lang::int_type()));
stan::lang::integrate_ode so2(integration_function_name, system_function_name,
y0, t0, ts, theta, x, x_int);
stan::lang::expression e1(so2);
generate_expression(e1, user_facing, msgs);
EXPECT_EQ(msgs.str(),
"bar(foo_functor__(), y0_var_name, t0_var_name, ts_var_name, "
"theta_var_name, x_var_name, x_int_var_name, pstream__)");
}
void Genetic::normal_cross(Answer * fa, Answer * mo) { // 常规交叉法
int pos = rand() % ncity;
// std::cout << "pos: " << pos << std::endl;
Answer so1(*fa);
Answer so2(*mo);
double rev = Answer::rand_0_1();
if (rev < 0.8) {
fa->reverse();
mo->reverse();
}
int * fa_occur = new int[ncity];
int * mo_occur = new int[ncity];
for (size_t i = 0; i < ncity; i++) {
fa_occur[i] = mo_occur[i] = 0;
}
for (size_t i = 0; i < pos; i++) {
// std::cout << (*fa)[i] << ' ' << (*mo)[i] << std::endl;
so1.setAt(i, (*fa)[i]);
so2.setAt(i, (*mo)[i]);
// std::cout << so1[i] << ' ' << so2[i] << std::endl;
fa_occur[ so1[i] ] = 1;
mo_occur[ so2[i] ] = 1;
}
int mpos = pos;
for (size_t i = 0; i < ncity && (pos < ncity || mpos < ncity); i++) {
// when pos or mpos < ncity, loop should not stop
if (!fa_occur[ (*mo)[i] ]) {
so1.setAt(pos++, (*mo)[i]);
fa_occur[ (*mo)[i] ] = 1;
}
if (!mo_occur[ (*fa)[i] ]) {
so2.setAt(mpos++, (*fa)[i]);
mo_occur[ (*fa)[i] ] = 1;
}
}
delete [] fa_occur;
delete [] mo_occur;
*fa = so1;
*mo = so2;
}
TEST(generateExpression, algebra_solver) {
static const bool user_facing = true;
std::stringstream msgs;
stan::lang::algebra_solver so; // null ctor should work and not raise error
std::string system_function_name = "bronzino";
stan::lang::variable y("y_var_name");
y.set_type(stan::lang::vector_type());
stan::lang::variable theta("theta_var_name");
theta.set_type(stan::lang::vector_type());
stan::lang::variable x_r("x_r_r_var_name");
x_r.set_type(stan::lang::bare_array_type(stan::lang::double_type()));
stan::lang::variable x_i("x_i_var_name");
x_i.set_type(stan::lang::bare_array_type(stan::lang::int_type()));
stan::lang::algebra_solver so2(system_function_name, y, theta, x_r, x_i);
stan::lang::expression e1 = so2;
generate_expression(e1, user_facing, msgs);
EXPECT_EQ(msgs.str(),
"algebra_solver(bronzino_functor__(), y_var_name, "
"theta_var_name, x_r_r_var_name, x_i_var_name, pstream__)");
}
