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(); }