END_TEST
START_TEST(test_ck_assert_int_le)
{
int x = 2;
int y = 3;
ck_assert_int_le(x, y);
ck_assert_int_le(x, x);
ck_assert_int_le(y, x);
#define LINENO_ck_assert_int_le _STR(__LINE__)
}
static void
test_bt_value_group_range_randomize_column (BT_TEST_ARGS)
{
BT_TEST_START;
GST_INFO ("-- arrange --");
BtValueGroup *vg = get_mono_value_group ();
bt_value_group_set_event (vg, 0, 0, "5");
bt_value_group_set_event (vg, 3, 0, "50");
GST_INFO ("-- act --");
bt_value_group_transform_colum (vg, BT_VALUE_GROUP_OP_RANGE_RANDOMIZE, 0, 3,
0);
GST_INFO ("-- assert --");
gchar *str;
gint v, i;
for (i = 0; i < 4; i++) {
GST_DEBUG ("value[%d]", i);
str = bt_value_group_get_event (vg, i, 0);
fail_unless (str != NULL, NULL);
v = atoi (str);
ck_assert_int_ge (v, 5);
ck_assert_int_le (v, 50);
g_free (str);
}
GST_INFO ("-- cleanup --");
BT_TEST_END;
}
END_TEST
START_TEST(test_mg_start_stop_https_server)
{
#ifndef NO_SSL
struct mg_context *ctx;
size_t ports_cnt;
int ports[16];
int ssl[16];
struct mg_callbacks callbacks;
char errmsg[256];
const char *OPTIONS[8]; /* initializer list here is rejected by CI test */
int opt_idx = 0;
const char *ssl_cert = locate_ssl_cert();
ck_assert(ssl_cert != NULL);
memset((void *)OPTIONS, 0, sizeof(OPTIONS));
#if !defined(NO_FILES)
OPTIONS[opt_idx++] = "document_root";
OPTIONS[opt_idx++] = ".";
#endif
OPTIONS[opt_idx++] = "listening_ports";
OPTIONS[opt_idx++] = "8080r,8443s";
OPTIONS[opt_idx++] = "ssl_certificate";
OPTIONS[opt_idx++] = ssl_cert;
ck_assert_int_le(opt_idx, (int)(sizeof(OPTIONS) / sizeof(OPTIONS[0])));
ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 1] == NULL);
ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 2] == NULL);
memset(ports, 0, sizeof(ports));
memset(ssl, 0, sizeof(ssl));
memset(&callbacks, 0, sizeof(callbacks));
memset(errmsg, 0, sizeof(errmsg));
callbacks.log_message = log_msg_func;
ctx = mg_start(&callbacks, (void *)errmsg, OPTIONS);
test_sleep(1);
ck_assert_str_eq(errmsg, "");
ck_assert(ctx != NULL);
ports_cnt = mg_get_ports(ctx, 16, ports, ssl);
ck_assert_uint_eq(ports_cnt, 2);
ck_assert_int_eq(ports[0], 8080);
ck_assert_int_eq(ssl[0], 0);
ck_assert_int_eq(ports[1], 8443);
ck_assert_int_eq(ssl[1], 1);
ck_assert_int_eq(ports[2], 0);
ck_assert_int_eq(ssl[2], 0);
test_sleep(1);
mg_stop(ctx);
#endif
}
END_TEST
START_TEST(test_tree_properties)
{
tree_info_t info;
ck_assert_ptr_eq(tree_info(tree, &info), &info);
ck_assert_int_eq(info.size, tree_size(tree));
ck_assert_int_le(info.height, info.min_height*2);
}
END_TEST
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wused-but-marked-unused"
#endif
START_TEST(dmonth_return_within_range)
{
int m;
m = dmonth(_i);
ck_assert_int_ge(m, 28);
ck_assert_int_le(m, 31);
}
END_TEST
START_TEST(ShellSortRandomTest) {
int* _Test = alloca(sizeof(int) * LARGE);
srand(time(NULL));
for(int i = 0; i < LARGE; ++i)
_Test[i] = rand();
ShellSort(_Test, LARGE);
for(int i = 1; i < LARGE; ++i) {
for(int k = 0; k < i; ++k) {
ck_assert_int_le(_Test[k], _Test[i]);
}
}
}
END_TEST
START_TEST(child_del)
{
unsigned int expected_children_count = 0;
Efl_Future *future;
future = efl_model_children_count_get(object);
ck_assert_ptr_ne(NULL, future);
expected_children_count = efl_model_future_then_u(future);
ck_assert_msg(expected_children_count, "There must be at least 1 child to test");
Eo *child = efl_model_first_child_get(object);
efl_model_child_del(object, child);
future = NULL;
unsigned int actual_children_count = 0;
future = efl_model_children_count_get(object);
ck_assert_ptr_ne(NULL, future);
actual_children_count = efl_model_future_then_u(future);
ck_assert_int_le(expected_children_count, actual_children_count);
}
END_TEST
START_TEST(test_false_positives)
{
float p = 0.01;
int n = 10000;
BloomFilter *bf = BloomFilterCreateWithPAndN(p, n);
float fp = 0;
int i;
for (i = 0; i < n; i++)
BloomFilterAdd(bf, &i, sizeof(int));
for (i = 0; i < n; i++)
{
int r = rand();
if (BloomFilterContains(bf, &r, sizeof(int)))
fp++;
}
ck_assert_int_le(fp / n, p);
}
END_TEST
START_TEST(test_mg_server_and_client_tls)
{
#ifndef NO_SSL
struct mg_context *ctx;
int ports_cnt;
struct mg_server_ports ports[16];
struct mg_callbacks callbacks;
char errmsg[256];
struct mg_connection *client_conn;
char client_err[256];
const struct mg_request_info *client_ri;
int client_res;
struct mg_client_options client_options;
const char *OPTIONS[32]; /* initializer list here is rejected by CI test */
int opt_idx = 0;
char server_cert[256];
char client_cert[256];
const char *res_dir = locate_resources();
ck_assert(res_dir != NULL);
strcpy(server_cert, res_dir);
strcpy(client_cert, res_dir);
#ifdef _WIN32
strcat(server_cert, "cert\\server.pem");
strcat(client_cert, "cert\\client.pem");
#else
strcat(server_cert, "cert/server.pem");
strcat(client_cert, "cert/client.pem");
#endif
memset((void *)OPTIONS, 0, sizeof(OPTIONS));
#if !defined(NO_FILES)
OPTIONS[opt_idx++] = "document_root";
OPTIONS[opt_idx++] = ".";
#endif
OPTIONS[opt_idx++] = "listening_ports";
OPTIONS[opt_idx++] = "8080r,8443s";
OPTIONS[opt_idx++] = "ssl_certificate";
OPTIONS[opt_idx++] = server_cert;
OPTIONS[opt_idx++] = "ssl_verify_peer";
OPTIONS[opt_idx++] = "yes";
OPTIONS[opt_idx++] = "ssl_ca_file";
OPTIONS[opt_idx++] = client_cert;
ck_assert_int_le(opt_idx, (int)(sizeof(OPTIONS) / sizeof(OPTIONS[0])));
ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 1] == NULL);
ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 2] == NULL);
memset(ports, 0, sizeof(ports));
memset(&callbacks, 0, sizeof(callbacks));
memset(errmsg, 0, sizeof(errmsg));
callbacks.log_message = log_msg_func;
ctx = mg_start(&callbacks, (void *)errmsg, OPTIONS);
mark_point();
test_sleep(1);
ck_assert_str_eq(errmsg, "");
ck_assert(ctx != NULL);
ports_cnt = mg_get_server_ports(ctx, 16, ports);
ck_assert_int_eq(ports_cnt, 2);
ck_assert_int_eq(ports[0].protocol, 1);
ck_assert_int_eq(ports[0].port, 8080);
ck_assert_int_eq(ports[0].is_ssl, 0);
ck_assert_int_eq(ports[0].is_redirect, 1);
ck_assert_int_eq(ports[1].protocol, 1);
ck_assert_int_eq(ports[1].port, 8443);
ck_assert_int_eq(ports[1].is_ssl, 1);
ck_assert_int_eq(ports[1].is_redirect, 0);
ck_assert_int_eq(ports[2].protocol, 0);
ck_assert_int_eq(ports[2].port, 0);
ck_assert_int_eq(ports[2].is_ssl, 0);
ck_assert_int_eq(ports[2].is_redirect, 0);
test_sleep(1);
mark_point();
memset(client_err, 0, sizeof(client_err));
client_conn =
mg_connect_client("127.0.0.1", 8443, 1, client_err, sizeof(client_err));
ck_assert(client_conn == NULL);
ck_assert_str_ne(client_err, "");
memset(client_err, 0, sizeof(client_err));
memset(&client_options, 0, sizeof(client_options));
client_options.host = "127.0.0.1";
client_options.port = 8443;
client_options.client_cert = client_cert;
client_options.server_cert = server_cert;
client_conn = mg_connect_client_secure(&client_options,
client_err,
sizeof(client_err));
ck_assert(client_conn != NULL);
ck_assert_str_eq(client_err, "");
mg_printf(client_conn, "GET / HTTP/1.0\r\n\r\n");
client_res =
mg_get_response(client_conn, client_err, sizeof(client_err), 10000);
ck_assert_int_ge(client_res, 0);
ck_assert_str_eq(client_err, "");
client_ri = mg_get_request_info(client_conn);
ck_assert(client_ri != NULL);
#if defined(NO_FILES)
ck_assert_str_eq(client_ri->uri, "404");
#else
ck_assert_str_eq(client_ri->uri, "200");
/* TODO: ck_assert_str_eq(client_ri->request_method, "HTTP/1.0"); */
client_res = (int)mg_read(client_conn, client_err, sizeof(client_err));
ck_assert_int_gt(client_res, 0);
ck_assert_int_le(client_res, sizeof(client_err));
#endif
mg_close_connection(client_conn);
/* TODO: A client API using a client certificate is missing */
mark_point();
test_sleep(1);
mark_point();
mg_stop(ctx);
#endif
}
END_TEST
START_TEST(test_mg_start_stop_https_server)
{
#ifndef NO_SSL
struct mg_context *ctx;
size_t ports_cnt;
int ports[16];
int ssl[16];
struct mg_callbacks callbacks;
char errmsg[256];
const char *OPTIONS[8]; /* initializer list here is rejected by CI test */
int opt_idx = 0;
const char *ssl_cert = locate_ssl_cert();
struct mg_connection *client_conn;
char client_err[256];
const struct mg_request_info *client_ri;
int client_res;
ck_assert(ssl_cert != NULL);
memset((void *)OPTIONS, 0, sizeof(OPTIONS));
#if !defined(NO_FILES)
OPTIONS[opt_idx++] = "document_root";
OPTIONS[opt_idx++] = ".";
#endif
OPTIONS[opt_idx++] = "listening_ports";
OPTIONS[opt_idx++] = "8080r,8443s";
OPTIONS[opt_idx++] = "ssl_certificate";
OPTIONS[opt_idx++] = ssl_cert;
ck_assert_int_le(opt_idx, (int)(sizeof(OPTIONS) / sizeof(OPTIONS[0])));
ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 1] == NULL);
ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 2] == NULL);
memset(ports, 0, sizeof(ports));
memset(ssl, 0, sizeof(ssl));
memset(&callbacks, 0, sizeof(callbacks));
memset(errmsg, 0, sizeof(errmsg));
callbacks.log_message = log_msg_func;
ctx = mg_start(&callbacks, (void *)errmsg, OPTIONS);
mark_point();
test_sleep(1);
ck_assert_str_eq(errmsg, "");
ck_assert(ctx != NULL);
ports_cnt = mg_get_ports(ctx, 16, ports, ssl);
ck_assert_uint_eq(ports_cnt, 2);
ck_assert_int_eq(ports[0], 8080);
ck_assert_int_eq(ssl[0], 0);
ck_assert_int_eq(ports[1], 8443);
ck_assert_int_eq(ssl[1], 1);
ck_assert_int_eq(ports[2], 0);
ck_assert_int_eq(ssl[2], 0);
test_sleep(1);
mark_point();
memset(client_err, 0, sizeof(client_err));
client_conn =
mg_connect_client("127.0.0.1", 8443, 1, client_err, sizeof(client_err));
ck_assert(client_conn != NULL);
ck_assert_str_eq(client_err, "");
mg_printf(client_conn, "GET / HTTP/1.0\r\n\r\n");
client_res =
mg_get_response(client_conn, client_err, sizeof(client_err), 10000);
ck_assert_int_ge(client_res, 0);
ck_assert_str_eq(client_err, "");
client_ri = mg_get_request_info(client_conn);
ck_assert(client_ri != NULL);
#if defined(NO_FILES)
ck_assert_str_eq(client_ri->uri, "404");
#else
ck_assert_str_eq(client_ri->uri, "200");
/* TODO: ck_assert_str_eq(client_ri->request_method, "HTTP/1.0"); */
client_res = (int)mg_read(client_conn, client_err, sizeof(client_err));
ck_assert_int_gt(client_res, 0);
ck_assert_int_le(client_res, sizeof(client_err));
#endif
mg_close_connection(client_conn);
mark_point();
test_sleep(1);
mark_point();
mg_stop(ctx);
#endif
}
