本文整理汇总了C++中ck_assert_int_eq函数的典型用法代码示例。如果您正苦于以下问题:C++ ck_assert_int_eq函数的具体用法?C++ ck_assert_int_eq怎么用?C++ ck_assert_int_eq使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了ck_assert_int_eq函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: START_TEST
//.........这里部分代码省略.........
Flags: 0x00
0... .... = Flags-IP: Not set
.000 000. = Flags-reserved: 0x00
.... ...0 = Flags-Unknown: Not set
Reserved1: 00
Vlan ID: 0
Reserved2: 00000000
IP addr: 0.0.0.0 (0.0.0.0)
Name: MacVlanDiscover
Vlan: ID 50, Name "AdminB2"
Marker 0x99, length 100, type 5 = VL
TLV Marker: 0x99
TLV type: VL (5)
TLV length: 100
Flags: 0x80
1... .... = Flags-IP: Set
.000 000. = Flags-reserved: 0x00
.... ...0 = Flags-Unknown: Not set
Reserved1: 00
Vlan ID: 50
Reserved2: 00000000
IP addr: 10.50.0.63 (10.50.0.63)
Name: AdminB2
Null
Marker 0x99, length 4, type 0 = Null
TLV Marker: 0x99
TLV type: Null (0)
TLV length: 4
*/
struct lldpd_vlan *vlan;
#endif
struct lldpd_chassis *nchassis = NULL;
struct lldpd_port *nport = NULL;
struct lldpd cfg;
char mac1[] = { 0x00, 0x04, 0x96, 0x05, 0x44, 0x6f };
cfg.g_mgmt_pattern = NULL;
fail_unless(edp_decode(&cfg, pkt1, sizeof(pkt1), &hardware,
&nchassis, &nport) != -1);
if (!nchassis || !nport) {
fail("unable to decode packet");
return;
}
ck_assert_int_eq(nchassis->c_id_subtype,
LLDP_CHASSISID_SUBTYPE_LLADDR);
ck_assert_int_eq(nchassis->c_id_len, ETH_ALEN);
fail_unless(memcmp(nchassis->c_id, mac1, ETH_ALEN) == 0);
ck_assert_int_eq(nport->p_id_subtype,
LLDP_PORTID_SUBTYPE_IFNAME);
ck_assert_int_eq(nport->p_id_len, strlen("1/1"));
fail_unless(memcmp(nport->p_id,
"1/1", strlen("1/1")) == 0);
ck_assert_str_eq(nport->p_descr, "Slot 1 / Port 1");
ck_assert_str_eq(nchassis->c_name, "ne0501sw.XXXXXX");
ck_assert_str_eq(nchassis->c_descr, "EDP enabled device, version 7.6.4.0");
ck_assert_int_eq(nchassis->c_cap_enabled, 0);
#ifdef ENABLE_DOT1
/* Add this port to list of remote port for hardware port */
TAILQ_INSERT_TAIL(&hardware.h_rports, nport, p_entries);
nport->p_chassis = nchassis;
nport->p_protocol = LLDPD_MODE_EDP;
/* Recept second packet */
nchassis = NULL;
nport = NULL;
fail_unless(edp_decode(&cfg, pkt2, sizeof(pkt2), &hardware,
&nchassis, &nport) == -1);
nport = TAILQ_FIRST(&hardware.h_rports);
if (!nport) {
fail("unable to find our previous port?");
return;
}
ck_assert_int_eq(TAILQ_FIRST(&nport->p_chassis->c_mgmt)->m_addr.inet.s_addr,
(u_int32_t)inet_addr("10.50.0.63"));
if (TAILQ_EMPTY(&nport->p_vlans)) {
fail("no VLAN");
return;
}
vlan = TAILQ_FIRST(&nport->p_vlans);
ck_assert_int_eq(vlan->v_vid, 1);
ck_assert_str_eq(vlan->v_name, "Default");
vlan = TAILQ_NEXT(vlan, v_entries);
if (!vlan) {
fail("no more VLAN");
return;
}
ck_assert_int_eq(vlan->v_vid, 0);
ck_assert_str_eq(vlan->v_name, "MacVlanDiscover");
vlan = TAILQ_NEXT(vlan, v_entries);
if (!vlan) {
fail("no more VLAN");
return;
}
ck_assert_int_eq(vlan->v_vid, 50);
ck_assert_str_eq(vlan->v_name, "AdminB2");
vlan = TAILQ_NEXT(vlan, v_entries);
fail_unless(vlan == NULL);
#endif
}
示例2: START_TEST
END_TEST
START_TEST (test_roman_digit_check_individual_error)
{
char tst_str[2];
char tst_ch;
tst_str[1]=0;
for(tst_ch = 1; tst_ch <= 'B'; tst_ch++){
*tst_str = tst_ch;
ck_assert_int_eq (rnum_check (tst_str), RNUM_ERR_INPUT_NON_NUMERAL);
}
for(tst_ch = 'E'; tst_ch <= 'H'; tst_ch++){
*tst_str = tst_ch;
ck_assert_int_eq (rnum_check (tst_str), RNUM_ERR_INPUT_NON_NUMERAL);
}
for(tst_ch = 'J'; tst_ch <= 'K'; tst_ch++){
*tst_str = tst_ch;
ck_assert_int_eq (rnum_check (tst_str), RNUM_ERR_INPUT_NON_NUMERAL);
}
for(tst_ch = 'N'; tst_ch <= 'U'; tst_ch++){
*tst_str = tst_ch;
ck_assert_int_eq (rnum_check (tst_str), RNUM_ERR_INPUT_NON_NUMERAL);
}
ck_assert_int_eq (rnum_check ("W"), RNUM_ERR_INPUT_NON_NUMERAL);
for(tst_ch = 'Y'; tst_ch <= 'b'; tst_ch++){
*tst_str = tst_ch;
ck_assert_int_eq (rnum_check (tst_str), RNUM_ERR_INPUT_NON_NUMERAL);
}
for(tst_ch = 'e'; tst_ch <= 'h'; tst_ch++){
*tst_str = tst_ch;
ck_assert_int_eq (rnum_check (tst_str), RNUM_ERR_INPUT_NON_NUMERAL);
}
for(tst_ch = 'j'; tst_ch <= 'k'; tst_ch++){
*tst_str = tst_ch;
ck_assert_int_eq (rnum_check (tst_str), RNUM_ERR_INPUT_NON_NUMERAL);
}
for(tst_ch = 'n'; tst_ch <= 'u'; tst_ch++){
*tst_str = tst_ch;
ck_assert_int_eq (rnum_check (tst_str), RNUM_ERR_INPUT_NON_NUMERAL);
}
ck_assert_int_eq (rnum_check ("w"), RNUM_ERR_INPUT_NON_NUMERAL);
for(tst_ch = 'y'; tst_ch <= 126; tst_ch++){
*tst_str = tst_ch;
ck_assert_int_eq (rnum_check (tst_str), RNUM_ERR_INPUT_NON_NUMERAL);
}
}
示例3: START_TEST
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);
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);
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);
//.........这里部分代码省略.........
示例4: START_TEARDOWN
END_SETUP
START_TEARDOWN(teardown_destroy_data)
{
ck_assert_int_eq(destroy_data_called, 1);
}
示例5: START_TEST
END_TEST
START_TEST(test_peer_split_host) {
char * host;
int port;
ck_assert_int_eq(peer_split_host("localhost:8000", &host, &port), RET_OK);
ck_assert_int_eq(port, 8000);
ck_assert(host != NULL);
ck_assert_str_eq(host, "localhost");
ck_assert_int_eq(peer_split_host("*:8000", &host, &port), RET_OK);
ck_assert_int_eq(port, 8000);
ck_assert(host == NULL);
ck_assert_int_eq(peer_split_host(":8000", &host, &port), RET_OK);
ck_assert_int_eq(port, 8000);
ck_assert(host == NULL);
ck_assert_int_eq(peer_split_host("8000", &host, &port), RET_OK);
ck_assert_int_eq(port, 8000);
ck_assert(host == NULL);
ck_assert_int_eq(peer_split_host("8000localhost", &host, &port), RET_PEER_RESOLVE_ERROR);
ck_assert_int_eq(peer_split_host("localhost", &host, &port), RET_PEER_RESOLVE_ERROR);
ck_assert_int_eq(peer_split_host("localhost:http", &host, &port), RET_PEER_RESOLVE_ERROR);
}
示例6: START_TEST
END_TEST
START_TEST(test_mg_get_var)
{
char buf[32];
int ret;
const char *shortquery = "key1=1&key2=2&key3=3";
const char *longquery = "key1=1&key2=2&key3&key4=4&key5=&key6&"
"key7=this+is+it&key8=8&key9&&key10=&&"
"key7=that+is+it&key12=12";
/* invalid result buffer */
ret = mg_get_var2("", 0, "notfound", NULL, 999, 0);
ck_assert_int_eq(ret, -2);
/* zero size result buffer */
ret = mg_get_var2("", 0, "notfound", buf, 0, 0);
ck_assert_int_eq(ret, -2);
/* too small result buffer */
ret = mg_get_var2("key=toooooooooolong", 19, "key", buf, 4, 0);
/* ck_assert_int_eq(ret, -3);
--> TODO: mg_get_cookie returns -3, mg_get_var -2. This should be
unified. */
ck_assert(ret < 0);
/* key not found in string */
ret = mg_get_var2("", 0, "notfound", buf, sizeof(buf), 0);
ck_assert_int_eq(ret, -1);
ret = mg_get_var2(
longquery, strlen(longquery), "notfound", buf, sizeof(buf), 0);
ck_assert_int_eq(ret, -1);
/* key not found in string */
ret = mg_get_var2(
shortquery, strlen(shortquery), "notfound", buf, sizeof(buf), 0);
ck_assert_int_eq(ret, -1);
/* key not found in string */
ret = mg_get_var2("key1=1&key2=2&key3=3¬found=here",
strlen(shortquery),
"notfound",
buf,
sizeof(buf),
0);
ck_assert_int_eq(ret, -1);
/* key not found in string */
ret = mg_get_var2(
shortquery, strlen(shortquery), "key1", buf, sizeof(buf), 1);
ck_assert_int_eq(ret, -1);
/* keys are found as first, middle and last key */
memset(buf, 77, sizeof(buf));
ret = mg_get_var2(
shortquery, strlen(shortquery), "key1", buf, sizeof(buf), 0);
ck_assert_int_eq(ret, 1);
ck_assert_str_eq("1", buf);
memset(buf, 77, sizeof(buf));
ret = mg_get_var2(
shortquery, strlen(shortquery), "key2", buf, sizeof(buf), 0);
ck_assert_int_eq(ret, 1);
ck_assert_str_eq("2", buf);
memset(buf, 77, sizeof(buf));
ret = mg_get_var2(
shortquery, strlen(shortquery), "key3", buf, sizeof(buf), 0);
ck_assert_int_eq(ret, 1);
ck_assert_str_eq("3", buf);
/* longer value in the middle of a longer string */
memset(buf, 77, sizeof(buf));
ret =
mg_get_var2(longquery, strlen(longquery), "key7", buf, sizeof(buf), 0);
ck_assert_int_eq(ret, 10);
ck_assert_str_eq("this is it", buf);
/* longer value in the middle of a longer string - seccond occurance of key
*/
memset(buf, 77, sizeof(buf));
ret =
mg_get_var2(longquery, strlen(longquery), "key7", buf, sizeof(buf), 1);
ck_assert_int_eq(ret, 10);
ck_assert_str_eq("that is it", buf);
/* key with = but without value in the middle of a longer string */
memset(buf, 77, sizeof(buf));
ret =
mg_get_var2(longquery, strlen(longquery), "key5", buf, sizeof(buf), 0);
ck_assert_int_eq(ret, 0);
ck_assert_str_eq(buf, "");
/* key without = and without value in the middle of a longer string */
memset(buf, 77, sizeof(buf));
ret =
mg_get_var2(longquery, strlen(longquery), "key6", buf, sizeof(buf), 0);
ck_assert_int_eq(ret, -1);
//.........这里部分代码省略.........
示例7: START_TEST
END_TEST
START_TEST(test_basic_broadcast)
{
GpuArray a;
GpuArray b;
GpuArray c;
GpuElemwise *ge;
static const uint32_t data1[3] = {1, 2, 3};
static const uint32_t data2[2] = {4, 5};
uint32_t data3[6] = {0};
size_t dims[2];
gpuelemwise_arg args[3] = {{0}};
void *rargs[3];
dims[0] = 1;
dims[1] = 3;
ga_assert_ok(GpuArray_empty(&a, ctx, GA_UINT, 2, dims, GA_C_ORDER));
ga_assert_ok(GpuArray_write(&a, data1, sizeof(data1)));
dims[0] = 2;
dims[1] = 1;
ga_assert_ok(GpuArray_empty(&b, ctx, GA_UINT, 2, dims, GA_F_ORDER));
ga_assert_ok(GpuArray_write(&b, data2, sizeof(data2)));
dims[0] = 2;
dims[1] = 3;
ga_assert_ok(GpuArray_empty(&c, ctx, GA_UINT, 2, dims, GA_C_ORDER));
args[0].name = "a";
args[0].typecode = GA_UINT;
args[0].flags = GE_READ;
args[1].name = "b";
args[1].typecode = GA_UINT;
args[1].flags = GE_READ;
args[2].name = "c";
args[2].typecode = GA_UINT;
args[2].flags = GE_WRITE;
ge = GpuElemwise_new(ctx, "", "c = a + b", 3, args, 2, 0);
ck_assert_ptr_ne(ge, NULL);
rargs[0] = &a;
rargs[1] = &b;
rargs[2] = &c;
ck_assert_int_eq(GpuElemwise_call(ge, rargs, GE_NOCOLLAPSE), GA_VALUE_ERROR);
ga_assert_ok(GpuElemwise_call(ge, rargs, GE_NOCOLLAPSE|GE_BROADCAST));
ga_assert_ok(GpuArray_read(data3, sizeof(data3), &c));
ck_assert_int_eq(data3[0], 5);
ck_assert_int_eq(data3[1], 6);
ck_assert_int_eq(data3[2], 7);
ck_assert_int_eq(data3[3], 6);
ck_assert_int_eq(data3[4], 7);
ck_assert_int_eq(data3[5], 8);
}
示例8: START_TEST
END_TEST
// --------------------------------------------------------------------------
/// Try to _pop () multiple different values.
START_TEST(test_msg_pop)
{
sam_selftest_introduce ("test_msg_pop");
zmsg_t *zmsg = zmsg_new ();
// data to be pop()'d
char *nbr = "17";
char *str = "test";
char a = 'a';
zframe_t *char_frame = zframe_new (&a, sizeof (a));
void *ptr = (void *) 0xbadc0de;
// compose zmsg out of
// a number (i)
int rc = zmsg_pushstr (zmsg, nbr);
ck_assert_int_eq (rc, 0);
// a char * (s)
rc = zmsg_pushstr (zmsg, str);
ck_assert_int_eq (rc, 0);
// a frame * (f)
zframe_t *frame_dup = zframe_dup (char_frame);
rc = zmsg_prepend (zmsg, &frame_dup);
ck_assert_int_eq (rc, 0);
// a void * (p)
rc = zmsg_pushmem (zmsg, &ptr, sizeof (ptr));
ck_assert_int_eq (rc, 0);
// values to be filled
int pic_nbr;
char *pic_str;
zframe_t *pic_frame;
void *pic_ptr;
// create message
sam_msg_t *msg = sam_msg_new (&zmsg);
ck_assert_int_eq (sam_msg_size (msg), 4);
rc = sam_msg_pop (msg, "pfsi", &pic_ptr, &pic_frame, &pic_str, &pic_nbr);
// test data
ck_assert_int_eq (rc, 0);
ck_assert_int_eq (sam_msg_size (msg), 0);
ck_assert (zframe_eq (char_frame, pic_frame));
ck_assert_int_eq (pic_nbr, atoi (nbr));
ck_assert_str_eq (pic_str, str);
ck_assert_ptr_eq (pic_ptr, ptr);
// clean up
zframe_destroy (&char_frame);
sam_msg_destroy (&msg);
}
示例9: START_TEST
END_TEST
START_TEST(test_tree_basics)
{
int seven = 7, one = 1, three = 3;
ck_assert_int_eq(tree_size(tree), 0);
ck_assert_int_eq(*(int *)tree_insert(tree, &seven, &seven), seven);
ck_assert_int_eq(tree_size(tree), 1);
ck_assert_int_eq(*(int *)tree_insert(tree, &one, &one), one);
ck_assert_int_eq(tree_size(tree), 2);
ck_assert_int_eq(*(int *)tree_insert(tree, &three, &three), three);
ck_assert_int_eq(tree_size(tree), 3);
ck_assert_int_eq(*(int *)tree_find(tree, &seven), seven);
ck_assert_int_eq(*(int *)tree_find(tree, &one), one);
ck_assert_int_eq(*(int *)tree_find(tree, &three), three);
ck_assert_int_eq(*(int *)tree_delete(tree, &seven), seven);
ck_assert_int_eq(tree_size(tree), 2);
ck_assert_int_eq(*(int *)tree_delete(tree, &one), one);
ck_assert_int_eq(tree_size(tree), 1);
ck_assert_int_eq(*(int *)tree_delete(tree, &three), three);
ck_assert_int_eq(tree_size(tree), 0);
}
示例10: START_TEST
END_TEST
START_TEST (test_txt_putch)
{
ck_assert_int_eq(0, ulcd_txt_putch(ulcd, '!'));
}
示例11: teardown
/* Post-test hook. */
void
teardown ()
{
ck_assert_int_eq (fz_memusage (0), 0);
}
示例12: setup
/* Pre-test hook. */
void
setup ()
{
srand (time (0));
ck_assert_int_eq (fz_memusage (0), 0);
}
示例13: s1_msg_process_fn
static int32_t
s1_msg_process_fn(qb_ipcs_connection_t *c,
void *data, size_t size)
{
struct qb_ipc_request_header *req_pt = (struct qb_ipc_request_header *)data;
struct qb_ipc_response_header response = { 0, };
ssize_t res;
if (req_pt->id == IPC_MSG_REQ_TX_RX) {
response.size = sizeof(struct qb_ipc_response_header);
response.id = IPC_MSG_RES_TX_RX;
response.error = 0;
res = qb_ipcs_response_send(c, &response, response.size);
if (res < 0) {
qb_perror(LOG_INFO, "qb_ipcs_response_send");
} else if (res != response.size) {
qb_log(LOG_DEBUG, "qb_ipcs_response_send %zd != %d",
res, response.size);
}
if (turn_on_fc) {
qb_ipcs_request_rate_limit(s1, QB_IPCS_RATE_OFF);
}
} else if (req_pt->id == IPC_MSG_REQ_DISPATCH) {
response.size = sizeof(struct qb_ipc_response_header);
response.id = IPC_MSG_RES_DISPATCH;
response.error = 0;
res = qb_ipcs_event_send(c, &response,
sizeof(response));
if (res < 0) {
qb_perror(LOG_INFO, "qb_ipcs_event_send");
}
} else if (req_pt->id == IPC_MSG_REQ_BULK_EVENTS) {
int32_t m;
int32_t num;
struct qb_ipcs_connection_stats_2 *stats;
uint32_t max_size = MAX_MSG_SIZE;
response.size = sizeof(struct qb_ipc_response_header);
response.error = 0;
stats = qb_ipcs_connection_stats_get_2(c, QB_FALSE);
num = stats->event_q_length;
free(stats);
/* crazy large message */
res = qb_ipcs_event_send(c, &response, max_size*10);
ck_assert_int_eq(res, -EMSGSIZE);
/* send one event before responding */
res = qb_ipcs_event_send(c, &response, sizeof(response));
ck_assert_int_eq(res, sizeof(response));
response.id++;
/* There should be one more item in the event queue now. */
stats = qb_ipcs_connection_stats_get_2(c, QB_FALSE);
ck_assert_int_eq(stats->event_q_length - num, 1);
free(stats);
/* send response */
response.id = IPC_MSG_RES_BULK_EVENTS;
res = qb_ipcs_response_send(c, &response, response.size);
ck_assert_int_eq(res, sizeof(response));
/* send the rest of the events after the response */
for (m = 1; m < num_bulk_events; m++) {
res = qb_ipcs_event_send(c, &response, sizeof(response));
if (res == -EAGAIN || res == -ENOBUFS) {
/* retry */
usleep(1000);
m--;
continue;
}
ck_assert_int_eq(res, sizeof(response));
response.id++;
}
} else if (req_pt->id == IPC_MSG_REQ_STRESS_EVENT) {
struct {
struct qb_ipc_response_header hdr __attribute__ ((aligned(8)));
char data[GIANT_MSG_DATA_SIZE] __attribute__ ((aligned(8)));
uint32_t sent_msgs __attribute__ ((aligned(8)));
} __attribute__ ((aligned(8))) giant_event_send;
int32_t m;
response.size = sizeof(struct qb_ipc_response_header);
response.error = 0;
response.id = IPC_MSG_RES_STRESS_EVENT;
res = qb_ipcs_response_send(c, &response, response.size);
ck_assert_int_eq(res, sizeof(response));
giant_event_send.hdr.error = 0;
giant_event_send.hdr.id = IPC_MSG_RES_STRESS_EVENT;
for (m = 0; m < num_stress_events; m++) {
size_t sent_len = sizeof(struct qb_ipc_response_header);
if (((m+1) % 1000) == 0) {
sent_len = sizeof(giant_event_send);
giant_event_send.sent_msgs = m + 1;
//.........这里部分代码省略.........
示例14: START_TEST
END_TEST
START_TEST(base64_test_1padding)
{
//this is base64'd ASCII string "open62541!!"
UA_String encodedString; UA_STRING_STATIC(encodedString, "b3BlbjYyNTQxISE=");
//assure that we allocate exactly 11 bytes
ck_assert_int_eq(UA_base64_getDecodedSize(&encodedString), 11);
UA_Byte* decodedData = (UA_Byte*)malloc(UA_base64_getDecodedSize(&encodedString));
UA_base64_decode(&encodedString, decodedData);
//check the string
ck_assert_int_eq(decodedData[0], 'o');
ck_assert_int_eq(decodedData[1], 'p');
ck_assert_int_eq(decodedData[2], 'e');
ck_assert_int_eq(decodedData[3], 'n');
ck_assert_int_eq(decodedData[4], '6');
ck_assert_int_eq(decodedData[5], '2');
ck_assert_int_eq(decodedData[6], '5');
ck_assert_int_eq(decodedData[7], '4');
ck_assert_int_eq(decodedData[8], '1');
ck_assert_int_eq(decodedData[9], '!');
ck_assert_int_eq(decodedData[10], '!');
free(decodedData);
}
示例15: START_TEST
}END_TEST
START_TEST (test_init_search_data4)
{
init_symbol_translation( TRANS_QUERY, BOTH_STRANDS, 3, 3 );
p_query query = query_read_from_string( "ATGCCCAAGCTGAATAGCGTAGAGGGGTTTTCATCATTTGAGGACGATGTATAA" );
p_search_data sdp = s_create_searchdata( query );
// query data
ck_assert_int_eq( 6, sdp->q_count );
seq_buffer_t buf = sdp->queries[0];
ck_assert_str_eq( &query->aa[0].seq, &buf.seq.seq );
ck_assert_int_eq( query->aa[0].len, buf.seq.len );
ck_assert_int_eq( 0, buf.frame );
ck_assert_int_eq( 0, buf.strand );
buf = sdp->queries[1];
ck_assert_str_eq( &query->aa[1].seq, &buf.seq.seq );
ck_assert_int_eq( query->aa[1].len, buf.seq.len );
ck_assert_int_eq( 1, buf.frame );
ck_assert_int_eq( 0, buf.strand );
buf = sdp->queries[2];
ck_assert_str_eq( &query->aa[2].seq, &buf.seq.seq );
ck_assert_int_eq( query->aa[2].len, buf.seq.len );
ck_assert_int_eq( 2, buf.frame );
ck_assert_int_eq( 0, buf.strand );
buf = sdp->queries[3];
ck_assert_str_eq( &query->aa[3].seq, &buf.seq.seq );
ck_assert_int_eq( query->aa[3].len, buf.seq.len );
ck_assert_int_eq( 0, buf.frame );
ck_assert_int_eq( 1, buf.strand );
buf = sdp->queries[4];
ck_assert_str_eq( &query->aa[4].seq, &buf.seq.seq );
ck_assert_int_eq( query->aa[4].len, buf.seq.len );
ck_assert_int_eq( 1, buf.frame );
ck_assert_int_eq( 1, buf.strand );
buf = sdp->queries[5];
ck_assert_str_eq( &query->aa[5].seq, &buf.seq.seq );
ck_assert_int_eq( query->aa[5].len, buf.seq.len );
ck_assert_int_eq( 2, buf.frame );
ck_assert_int_eq( 1, buf.strand );
ck_assert_int_eq( 18, sdp->maxqlen );
query_free( query );
}END_TEST