int testBelugaLowLevelControlLaw()
{
BelugaLowLevelControlLaw control_law;
std::string err_msg;
mt_dVector_t u_in, u_out, state;
u_in.resize(BELUGA_CONTROL_SIZE, 0.0);
state.resize(4, 0.0);
/* the output should have BELUGA_CONTROL_SIZE elements */
START_TEST("Checking output vector size");
u_out = control_law.doControl(state, u_in);
if (u_out.size() != BELUGA_CONTROL_SIZE)
RETURN_ERROR_ELSE_OK("Incorrect size " << u_out.size());
/* the vertical thrust should be zero when u_vert is zero */
START_TEST("Checking that the vertical thrust is zero if no vertical command is given");
u_in = randomVector(3);
state = randomVector(4);
u_in[BELUGA_CONTROL_VERT_SPEED] = 0.0;
state[BELUGA_STATE_Z] = z_off;
u_out = control_law.doControl(state, u_in);
if (u_out[BELUGA_CONTROL_VERT_SPEED] != 0.0)
RETURN_ERROR_ELSE_OK("Control was " << u_out[BELUGA_CONTROL_VERT_SPEED]);
return OK;
}
memory_operation wrapped_calloc(size_t num, size_t size)
{
START_TEST(type_id, FunctionCalls::CALLOC)
data.ptr = memkind_calloc(kind, num, size);
data.error_code = errno;
END_TEST
}
bool test_aecp ( void )
{
bool r = false;
START_TEST();
END_TEST ( r );
return r;
}
static void
test_netaddr_is_in_subnet(void) {
struct netaddr_str str1, str2;
size_t a, s;
START_TEST();
for (s = 0; s < sizeof(in_subnet_subnets) / sizeof(*in_subnet_subnets); s++) {
for (a = 0; a < sizeof(in_subnet_addrs) / sizeof(*in_subnet_addrs); a++) {
CHECK_TRUE(
in_subnet_results[a][s] == netaddr_binary_is_in_subnet(&in_subnet_subnets[s], &in_subnet_addrs[a],
netaddr_get_maxprefix(&in_subnet_addrs[a])/8, in_subnet_addrs[a]._type),
"%s should %sbe in %s",
netaddr_to_string(&str1, &in_subnet_addrs[a]),
in_subnet_results[a][s] ? "" : "not ",
netaddr_to_string(&str2, &in_subnet_subnets[s]));
CHECK_TRUE(
in_subnet_results[a][s] == netaddr_is_in_subnet(&in_subnet_subnets[s], &in_subnet_addrs[a]),
"%s should %sbe in %s",
netaddr_to_string(&str1, &in_subnet_addrs[a]),
in_subnet_results[a][s] ? "" : "not ",
netaddr_to_string(&str2, &in_subnet_subnets[s]));
}
}
END_TEST();
}
static void
test_validate_fractional_miss(void) {
START_TEST();
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"%s", abuf_getptr(&out));
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "fractional", "a");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, NULL),
"validation missed bad integer");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "fractional", "3..4");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, NULL),
"validation missed bad integer");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "fractional", "3.4.5");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, NULL),
"validation missed bad integer");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "fractional", "0");
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, NULL),
"validation had a false positive");
END_TEST();
}
static void
test_validate_fractional_minmax_miss(void) {
START_TEST();
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"%s", abuf_getptr(&out));
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "fractional_minmax", "10.0001");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, &out),
"validation missed int out of range");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "fractional_minmax", "10.0000");
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"validation had false positive (border case)");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "fractional_minmax", "9.9999");
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"validation had false positive inside valid interval");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "fractional_minmax", "-10.0001");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, &out),
"validation missed int out of range");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "fractional_minmax", "-10.0000");
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"validation had false positive (border case)");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "fractional_minmax", "-9.9999");
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"validation had false positive inside valid interval");
END_TEST();
}
memory_operation wrapped_realloc(void* ptr, size_t size)
{
START_TEST(type_id, FunctionCalls::REALLOC)
data.ptr = memkind_realloc(kind, ptr, size);
data.error_code = errno;
END_TEST
}
static void
test_default_named_section_set(void) {
const struct const_strarray *value;
START_TEST();
cfg_db_overwrite_entry(db, CFG_SECTION, CFG_SECTION_NAME, CFG_ENTRY_DEF, CFG_NAMED_VALUE);
cfg_db_overwrite_entry(db, CFG_SECTION, CFG_SECTION_NAME, CFG_ENTRY_NODEF, CFG_NAMED_VALUE);
value = cfg_db_get_entry_value(db, CFG_SECTION, CFG_SECTION_NAME, CFG_ENTRY_DEF);
CHECK_TRUE(value != NULL, "No value found for named section entry with default");
if (value) {
CHECK_TRUE(value->value != NULL && strcmp(value->value, CFG_NAMED_VALUE) == 0,
"Did not got the named_section value with default: %s", value->value);
}
value = cfg_db_get_entry_value(db, CFG_SECTION, CFG_SECTION_NAME, CFG_ENTRY_NODEF);
CHECK_TRUE(value != NULL, "No value found for named section entry without default");
if (value) {
CHECK_TRUE(value->value != NULL && strcmp(value->value, CFG_NAMED_VALUE) == 0,
"Did not got the named_section value without default: %s", value->value);
}
value = cfg_db_get_entry_value(db, CFG_SECTION, NULL, CFG_ENTRY_DEF);
CHECK_TRUE(value != NULL, "No value found for unnamed section entry with default");
if (value) {
CHECK_TRUE(value->value != NULL && strcmp(value->value, CFG_SCHEMA_DEFAULT) == 0,
"Did not got the named_section value with default: %s", value->value);
}
value = cfg_db_get_entry_value(db, CFG_SECTION, NULL, CFG_ENTRY_NODEF);
CHECK_TRUE(value == NULL, "value found for unnamed section entry without default: %s",
value == NULL ? "" : value->value);
END_TEST();
}
void test_simple_list_fill(struct test_list* _head) {
START_TEST();
CHECK_TRUE(_is_equal(_get_by_buffer(_head, bar), 42, bar), "%s", _print_result(_get_by_buffer(_head, bar)));
CHECK_TRUE(_is_equal(_get_by_value(_head, 23), 23, foo), "%s", _print_result(_get_by_value(_head, 23)));
END_TEST();
}
static void
test_validate_success(void) {
START_TEST();
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"%s", abuf_getptr(&out));
END_TEST();
}
int testBelugaWaypointControlLaw()
{
BelugaWaypointControlLaw control_law;
control_law.doActivate(true);
std::string err_msg;
mt_dVector_t u_in, u_out, state;
u_in.resize(BELUGA_WAYPOINT_SIZE, 0.0);
state.resize(BELUGA_NUM_STATES, 0.0);
/* the output should have BELUGA_CONTROL_SIZE elements */
START_TEST("Checking output vector size");
u_out = control_law.doControl(state, u_in);
if (u_out.size() != BELUGA_CONTROL_SIZE)
RETURN_ERROR_ELSE_OK("Incorrect size " << u_out.size());
/* forward speed should max out when robot is far from waypoint */
START_TEST("Checking that speed saturates for large distances");
u_in[BELUGA_WAYPOINT_X] = state[BELUGA_STATE_X];
u_in[BELUGA_WAYPOINT_Y] = state[BELUGA_STATE_Y] + 1.1*control_law.m_dDistThreshold;
u_out = control_law.doControl(state, u_in);
if (!eq_wf(u_out[BELUGA_CONTROL_FWD_SPEED], control_law.m_dMaxSpeed))
RETURN_ERROR_ELSE_OK("Control did not saturate, was " << u_out[BELUGA_CONTROL_FWD_SPEED]);
/* forward speed should decrease as robot approaches waypoint */
START_TEST("Checking that speed decreases as robot nears waypoint");
u_in[BELUGA_WAYPOINT_X] = state[BELUGA_STATE_X];
mt_dVector_t prevOut;
prevOut.resize(BELUGA_CONTROL_SIZE, 500.0);
double N = 1.1;
double step = 0.1;
while (N > 0.0)
{
u_in[BELUGA_WAYPOINT_Y] = state[BELUGA_STATE_Y] + N*control_law.m_dDistThreshold;
u_out = control_law.doControl(state, u_in);
if (u_out[BELUGA_CONTROL_FWD_SPEED] > prevOut[BELUGA_CONTROL_FWD_SPEED])
RETURN_ERROR_ELSE_OK("Speed did not decrease, was " << u_out[BELUGA_CONTROL_FWD_SPEED]);
prevOut = u_out;
N -= step;
}
return OK;
}
static void
test_str_to_isonumber_s64_2(void) {
struct isonumber_str buf;
START_TEST();
CHECK_TRUE(
isonumber_from_s64(&buf,
5185050545986994176ll, "bit/s", 0, true, false) != NULL, "test");
END_TEST();
}
void
FileOperationReadCacheTest::testOpenFile()
{
START_TEST(__func__);
CPPUNIT_ASSERT(pReadCacheManager!=NULL);
//CPPUNIT_ASSERT(pInterface!=NULL);
//CPPUNIT_ASSERT(pInterface->OpenFile(O_RDONLY));
END_TEST(__func__);
}
static void
test_dot_product_enc(int arry_size, bool reencrypt = true) {
mpz_t dp_cipher[2];
mpz_t dp, dp_cpu, dp_gpu, dp_cpu2;
init(dp_cipher, 2, EGGROUP_NBITS);
mpz_init_set_ui(dp, 0);
mpz_init_set_ui(dp_cpu, 0);
mpz_init_set_ui(dp_gpu, 0);
mpz_init_set_ui(dp_cpu2, 0);
dot_product_enc(c, dp, pi, pi, arry_size);
if (reencrypt)
{
#if FAST_INIT == 1
gpuc->elgamal_enc_vec(cipher, pi, arry_size);
#else
c->elgamal_enc_vec(cipher, pi, arry_size);
#endif
}
/*
START_TEST("CPU dot_product_enc");
c->dot_product_enc(arry_size, cipher, pi, dp_cipher[0], dp_cipher[1]);
c->elgamal_dec(dp_cpu, dp_cipher[0], dp_cipher[1]);
RUN_TEST(cmp(dp, dp_cpu));
*/
START_TEST("CPU2 dot_product_enc");
cpu2_c->dot_product_enc(arry_size, cipher, pi, dp_cipher[0], dp_cipher[1]);
cpu2_c->elgamal_dec(dp_cpu2, dp_cipher[0], dp_cipher[1]);
RUN_TEST(cmp(dp, dp_cpu2));
START_TEST("GPU dot_product_enc");
gpuc->dot_product_enc(arry_size, cipher, pi, dp_cipher[0], dp_cipher[1]);
gpuc->elgamal_dec(dp_gpu, dp_cipher[0], dp_cipher[1]);
RUN_TEST(cmp(dp, dp_gpu));
mpz_clear(dp);
clear(dp_cipher, 2);
}
static void
test_validate_printable_miss(void) {
START_TEST();
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"%s", abuf_getptr(&out));
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "printable", "1234\n5678");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, NULL),
"validation missed non-printable character");
END_TEST();
}
void test_simple_list_remove(struct test_list** __head) {
struct test_list* _head;
simple_list_remove(__head, _get_by_buffer(*__head, foo));
_head = *__head;
START_TEST();
CHECK_TRUE(_is_equal(_head, 42, bar), "%s", _print_result(_head));
CHECK_TRUE(_is_equal(_head->next, 1337, baz), "%s", _print_result(_head->next));
END_TEST();
}
static void
test_validate_stringarray_miss(void) {
START_TEST();
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"%s", abuf_getptr(&out));
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "stringarray", "12345678");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, NULL),
"validation missed too long string value");
END_TEST();
}
static void
test_elgamal_enc(int arry_size) {
// We must decrypt since cipher texts contain randomness that we can't test.
START_TEST("CPU elgamal_enc");
c->elgamal_enc_vec(cipher, plain, arry_size);
elgamal_dec_vec(c, plain_cpu, cipher, arry_size);
RUN_TEST(cmp(encoded, plain_cpu, arry_size));
// We must decrypt since cipher texts contain randomness that we can't test.
START_TEST("CPU2 elgamal_enc");
cpu2_c->elgamal_enc_vec(cipher_cpu2, plain, arry_size);
elgamal_dec_vec(cpu2_c, plain_cpu2, cipher_cpu2, arry_size);
RUN_TEST(cmp(encoded, plain_cpu2, arry_size, cmp_callback));
//RUN_TEST(cmp(encoded, plain_cpu2, 1, cmp_callback));
START_TEST("GPU elgamal_enc");
gpuc->elgamal_enc_vec(cipher_gpu, plain, arry_size);
elgamal_dec_vec(gpuc, plain_gpu, cipher_gpu, arry_size);
//RUN_TEST(cmp(encoded, cipher_gpu, 1, cmp_callback));
RUN_TEST(cmp(encoded, plain_gpu, arry_size, cmp_callback));
}
int
main(int argc, char *argv[])
{
CYG_TEST_INIT();
CYG_TEST_INFO("Starting tests from testcase " __FILE__ " for Math library "
"expm1f() function");
START_TEST( test );
CYG_TEST_PASS_FINISH("Testing is not applicable to this configuration");
} // main()
int
main(int argc, char *argv[])
{
CYG_TEST_INIT();
CYG_TEST_INFO("Starting tests from testcase " __FILE__ " for C library "
"mktime() function");
START_TEST( test );
CYG_TEST_NA("Testing is not applicable to this configuration");
} // main()
void test_simple_list_find(struct test_list* _head) {
char buffer[sizeof bar];
memcpy(buffer, bar, sizeof buffer);
START_TEST();
CHECK_TRUE(_is_equal(simple_list_find_memcmp(_head, buffer), 42, bar), "%s", _print_result(simple_list_find_memcmp(_head, buffer)));
CHECK_TRUE(_is_equal(simple_list_find_cmp(_head, buffer, (int (*)(void *, void *)) strcmp), 42, bar),
"%s", _print_result(simple_list_find_cmp(_head, buffer, (int (*)(void *, void *)) strcmp)));
END_TEST();
}
static void
test_validate_choice_miss(void) {
START_TEST();
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"%s", abuf_getptr(&out));
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "choice", "choice42");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, NULL),
"validation missed bad choice");
END_TEST();
}
static void
test_delta_remove_single_section(void) {
START_TEST();
handler_1.cb_delta_handler = handler_remove_section;
cfg_db_add_entry(db_pre, SECTION_TYPE_1, NAME_1, KEY_1, value_1.value);
cfg_db_add_entry(db_pre, SECTION_TYPE_1, NAME_1, KEY_2, value_2.value);
CHECK_TRUE(cfg_schema_handle_db_changes(db_pre, db_post) == 0,
"delta calculation failed");
CHECK_TRUE(callback_counter == 1, "Callback counter was called %d times", callback_counter);
END_TEST();
}
static void
test_validate_netaddr_ipv46_prefix_miss(void) {
const char *key = "p_ipv46";
START_TEST();
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"%s", abuf_getptr(&out));
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, key, "xxxxxxx");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, &out),
"validation missed with bad address");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, key, "10:00:00:00:00:00");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, &out),
"validation missed with bad mac48");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, key, "11-22-33-44-55-66-77-88");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, &out),
"validation missed with bad eui64");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, key, "10.0.0.1");
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"validation had false positive with ipv4");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, key, "10::1");
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"validation had false positive with ipv6");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, key, "10:00:00:00:00:00/10");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, &out),
"validation missed with bad mac48 prefix");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, key, "11-22-33-44-55-66-77-88/11");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, &out),
"validation missed with bad eui64 prefix");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, key, "10.0.0.1/12");
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"validation had false positive with ipv4 prefix");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, key, "10::1/13");
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"validation had false positive with ipv6 prefix");
END_TEST();
}
void test_number_list() {
struct number_list* head = 0;
_add_number_list(&head, 23);
_add_number_list(&head, 42);
_add_number_list(&head, 17);
_add_number_list(&head, 32);
_add_number_list(&head, 1);
START_TEST();
int prev = 0;
struct number_list* node;
simple_list_for_each (head, node) {
CHECK_TRUE(node->value >= prev, "%d < %d", node->value, prev);
prev = node->value;
}
int main ( int argc, char **argv )
{
bool r = true;
START_TEST();
r &= test_aecp();
END_TEST ( r );
if ( r )
{
return 0;
}
else
{
return 1;
}
}
static void
test_str_to_isonumber_u64(void) {
static const char *results[2][3][5] = {
{
{ "999", "1.023k", "999.999k", "1.023M", "1.048M" },
{ "1k", "1.024k", "1M", "1.024M", "1.048M" },
{ "1.001k", "1.025k", "1M", "1.024M", "1.048M" }
},
{
{ "999", "1023", "976.561k", "999.999k", "1023.999k" },
{ "1000", "1k", "976.562k", "1000k", "1M" },
{ "1001", "1k", "976.563k", "1000k", "1M" }
}
};
static uint64_t tests[] = { 1000, 1024, 1000*1000, 1000*1024, 1024*1024 };
struct isonumber_str buf;
uint64_t diff;
int binary;
size_t i;
const char *tmp;
bool correct;
START_TEST();
for (binary=0; binary < 2; binary++) {
for (diff=0; diff < 3; diff++) {
for (i=0; i<ARRAYSIZE(tests); i++) {
tmp = isonumber_from_u64(&buf, tests[i]+diff-1, NULL, 0, binary==1, false);
correct = tmp != NULL && strcmp(tmp, results[binary][diff][i]) == 0;
CHECK_TRUE(tmp != NULL, "str_to_isonumber_u64(%"PRIu64", %s) is not null",
tests[i]+diff-1, binary == 1 ? "binary" : "normal");
CHECK_TRUE(correct, "str_to_isonumber_u64(%"PRIu64", %s) = %s should be %s",
tests[i]+diff-1, binary == 1 ? "binary" : "normal",
tmp, results[binary][diff][i]);
}
}
}
END_TEST();
}
static void
test_validate_double_schema(void) {
START_TEST();
cfg_schema_add_section(&schema, §ion2);
cfg_db_overwrite_entry(db, CFG_SEC, CFG_SECNAME, "stringarray", "123");
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"validation had false positive with double schema");
cfg_db_overwrite_entry(db, CFG_SEC, CFG_SECNAME, "stringarray", "123456");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, &out),
"validation missed with bad double schema");
cfg_db_overwrite_entry(db, CFG_SEC, CFG_SECNAME, "stringarray", "abc");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, &out),
"validation missed with bad double schema");
cfg_schema_remove_section(&schema, §ion2);
END_TEST();
}
static void
test_netaddr_to_string(void) {
size_t i;
const char *ptr;
struct netaddr_str strbuf;
START_TEST();
/* test successful netaddr to string conversions first */
for (i=0; i<sizeof(string_tests) / sizeof(*string_tests); i++) {
ptr = netaddr_to_string(&strbuf, &string_tests[i].bin);
CHECK_TRUE(ptr == strbuf.buf, "netaddr_to_string %s return error condition",
string_tests[i].str);
if(ptr != NULL) {
CHECK_TRUE(strcmp(string_tests[i].str, ptr) == 0,
"netaddr_to_string %s != %s return value", string_tests[i].str, ptr);
}
}
END_TEST();
}
static void
test_netaddr_from_string(void) {
size_t i;
int ret;
struct netaddr netaddr_buf;
START_TEST();
/* test successful string to netaddr conversions first */
for (i=0; i<sizeof(string_tests) / sizeof(*string_tests); i++) {
ret = netaddr_from_string(&netaddr_buf, string_tests[i].str);
CHECK_TRUE(ret == 0, "netaddr_from_string (%s) returns %d", string_tests[i].str, ret);
if (ret == 0) {
CHECK_TRUE(memcmp(&netaddr_buf, &string_tests[i].bin, sizeof(netaddr_buf)) == 0,
"netaddr_from_string (%s) value", string_tests[i].str);
}
}
/* test special cases of string to netaddr conversions next */
for (i=0; i<sizeof(good_netaddr_from_string) / sizeof(*good_netaddr_from_string); i++) {
ret = netaddr_from_string(&netaddr_buf, good_netaddr_from_string[i].str);
CHECK_TRUE(ret == 0, "netaddr_from_string (%s) returns %d", good_netaddr_from_string[i].str, ret);
if (ret == 0) {
CHECK_TRUE(memcmp(&netaddr_buf, &good_netaddr_from_string[i].bin, sizeof(netaddr_buf)) == 0,
"netaddr_from_string (%s) value", good_netaddr_from_string[i].str);
}
}
/* test error cases of string to netaddr conversions next */
for (i=0; i<sizeof(bad_netaddr_from_string)/sizeof(*bad_netaddr_from_string); i++) {
CHECK_TRUE (0 != netaddr_from_string(&netaddr_buf, bad_netaddr_from_string[i]),
"netaddr_from_string %s returns %d", bad_netaddr_from_string[i], ret);
}
END_TEST();
}
