Exemple #1
0
TEST_F(test_param_init_vector, allocate_phase_start)
{
  gradient_structure gs;

  dll_param_init_vector p;
  int min = 2;
  int max = 3;
  int expected_phase_start = 4;
  double array[2];
  p.allocate(&array[0], min, max, expected_phase_start, "p");
  ASSERT_EQ(min, p.indexmin());
  ASSERT_EQ(max, p.indexmax());
  ASSERT_EQ(expected_phase_start, p.get_phase_start());

  dvector vec(2, 3);
  vec(2) = 2.5;
  vec(3) = 3.5;

  p = vec;
  ASSERT_DOUBLE_EQ(2.5, value(p(2)));
  ASSERT_DOUBLE_EQ(3.5, value(p(3)));

  dvar_vector varvec(2, 3);
  varvec(2) = 12.5;
  varvec(3) = 13.5;

  p = varvec;

  ASSERT_DOUBLE_EQ(12.5, value(p(2)));
  ASSERT_DOUBLE_EQ(13.5, value(p(3)));

  dvariable var = 6.5;
  p = var;

  ASSERT_DOUBLE_EQ(6.5, value(p(2)));
  ASSERT_DOUBLE_EQ(6.5, value(p(3)));

  double val = 16.5;
  p = val;
  ASSERT_DOUBLE_EQ(16.5, value(p(2)));
  ASSERT_DOUBLE_EQ(16.5, value(p(3)));
}
Exemple #2
0
void test_variant()
{
    {
        variant v1;
        check(v1.is(variant::VOID));
    }
    {
        variant v1 = variant::null;
        check(v1.is_null());
        variant v2 = v1;
        check(v2.is_null());
        variant v3;
        v3 = v2;
        check(v3.is_null());
    }
    {
        variant v1 = 10; check(v1.as_ord() == 10);
        variant v2 = v1; check(v2.as_ord() == 10);
        variant v3; v3 = v2; check(v3.as_ord() == 10);
    }
    {
        variant v1 = "abc"; check(v1.as_str() == "abc");
        variant v2 = v1; check(v2.as_str() == "abc");
        variant v3; v3 = v2; check(v3.as_str() == "abc");
        str s = "def";
        variant v4 = s; check(v4.as_str() == "def");
        v4 = 20; check(v4.as_ord() == 20);
    }

    {
//        variant v1 = range(20, 50); check(v1.is(variant::RANGE)); check(v1.as_range().equals(20, 50));
//        variant v2 = v1; check(v2.is(variant::RANGE)); check(v2.as_range().equals(20, 50));
//        variant v3; v3 = v1; check(v3.is(variant::RANGE)); check(v3.as_range().equals(20, 50));
//        check(v2 == v3 && v1 == v3);
    }

    {
        variant v1 = varvec();
        check(v1.is(variant::VEC));
        variant v2 = v1;
        check(v1 == v2);
        v2.as_vec().push_back("ABC");
        check(v2.as_vec()[0].as_str() == "ABC");
        check(v1 != v2);
        v1 = 20;
        v1 = v2;
        v2 = 30;
        v1 = v2;
    }
    {
        variant v1 = ordset(); check(v1.is(variant::ORDSET));
    }
    {
        variant v1 = vardict(); check(v1.is(variant::DICT));
    }
    {
        variant v1 = range(0, 10);
        variant v2 = range(0, 20);
        check(v1.as_range().left() == 0);
        check(v1.as_range().right() == 10);
        check(v2.as_range().left() == 0);
        check(v2.as_range().right() == 20);
        check(v1.compare(v2) == -1);
    }
}