本文整理汇总了C++中ck_assert_msg函数的典型用法代码示例。如果您正苦于以下问题:C++ ck_assert_msg函数的具体用法?C++ ck_assert_msg怎么用?C++ ck_assert_msg使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了ck_assert_msg函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: START_TEST
END_TEST
START_TEST(test_cjose_jws_import_get_plain_after_verify)
{
cjose_err err;
// import the common key
cjose_jwk_t *jwk = cjose_jwk_import(JWK_COMMON, strlen(JWK_COMMON), &err);
ck_assert_msg(NULL != jwk, "cjose_jwk_import failed: "
"%s, file: %s, function: %s, line: %ld",
err.message, err.file, err.function, err.line);
// import the jws created with the common key
cjose_jws_t *jws = cjose_jws_import(JWS_COMMON, strlen(JWS_COMMON), &err);
ck_assert_msg(NULL != jws, "cjose_jws_import failed: "
"%s, file: %s, function: %s, line: %ld",
err.message, err.file, err.function, err.line);
// verify the imported jws
ck_assert_msg(cjose_jws_verify(jws, jwk, &err), "cjose_jws_verify failed: "
"%s, file: %s, function: %s, line: %ld",
err.message, err.file, err.function, err.line);
// get plaintext from imported and verified jws
uint8_t *plaintext = NULL;
size_t plaintext_len = 0;
ck_assert_msg(cjose_jws_get_plaintext(jws, &plaintext, &plaintext_len, &err), "cjose_jws_get_plaintext failed: "
"%s, file: %s, function: %s, line: %ld",
err.message, err.file, err.function, err.line);
// compare the verified plaintext to the expected value
ck_assert_msg(strncmp(PLAIN_COMMON, plaintext, strlen(PLAIN_COMMON)) == 0,
"verified plaintext from JWS doesn't match the original");
cjose_jws_release(jws);
cjose_jwk_release(jwk);
}
示例2: START_TEST
END_TEST
/*******************************************************************************
* test for chunk_map and friends
*/
START_TEST(test_chunk_map)
{
chunk_t *map, contents = chunk_from_chars(0x01,0x02,0x03,0x04,0x05);
char *path = "/tmp/strongswan-chunk-map-test";
ck_assert(chunk_write(contents, path, 022, TRUE));
/* read */
map = chunk_map(path, FALSE);
ck_assert(map != NULL);
ck_assert_msg(chunk_equals(*map, contents), "%B", map);
/* altering mapped chunk should not hurt */
*map = chunk_empty;
ck_assert(chunk_unmap(map));
/* write */
map = chunk_map(path, TRUE);
ck_assert(map != NULL);
ck_assert_msg(chunk_equals(*map, contents), "%B", map);
map->ptr[0] = 0x06;
ck_assert(chunk_unmap(map));
/* verify write */
contents.ptr[0] = 0x06;
map = chunk_map(path, FALSE);
ck_assert(map != NULL);
ck_assert_msg(chunk_equals(*map, contents), "%B", map);
ck_assert(chunk_unmap(map));
unlink(path);
}
示例3: START_TEST
END_TEST
START_TEST(test_bits_io_write_bit)
{
BitsIOFile *bfile = bits_io_open("test/test.hf", "r");
unsigned char bit;
bit = bits_io_read_bit(bfile);
ck_assert_int_eq(bit, 1);
bit = bits_io_read_bit(bfile);
ck_assert_int_eq(bit, 1);
bit = bits_io_read_bit(bfile);
ck_assert_int_eq(bit, 0);
bit = bits_io_read_bit(bfile);
ck_assert_int_eq(bit, 1);
bit = bits_io_read_bit(bfile);
ck_assert_int_eq(bit, 0);
int nbytes = bits_io_num_bytes(bfile);
ck_assert_int_eq(nbytes, 0);
int result = bits_io_close(bfile);
ck_assert_msg(result != EOF, "closing the file should not be EOF.");
bfile = bits_io_open("test/test-stress.hf", "r");
for (int i = 0; i < BIT_ITERATIONS; i++) {
bit = bits_io_read_bit(bfile);
ck_assert_int_eq(bit, i%2);
}
ck_assert_int_eq(bits_io_num_bytes(bfile), BIT_ITERATIONS/7);
result = bits_io_close(bfile);
ck_assert_msg(result != EOF, "closing the file should not be EOF.");
// Delete the files:
remove("test/test.hf");
remove("test/test-stress.hf");
}
示例4: START_TEST
END_TEST
START_TEST(check_parser_header) {
dmime_common_headers_t *header1, *header2;
int res = 0;
size_t outsize;
unsigned char *formatted;
header1 = dime_prsr_headers_create();
header1->headers[HEADER_TYPE_DATE] = st_import("11:34:12 AM March 12, 2004", 26);
header1->headers[HEADER_TYPE_TO] = st_import("[email protected]", 13);
header1->headers[HEADER_TYPE_CC] = st_import("[email protected]", 16);
header1->headers[HEADER_TYPE_FROM] = st_import("[email protected]", 22);
header1->headers[HEADER_TYPE_ORGANIZATION] = st_import("Cool people organization", 24);
header1->headers[HEADER_TYPE_SUBJECT] = st_import("here's stuff", 12);
formatted = dime_prsr_headers_format(header1, &outsize);
ck_assert_msg(formatted != NULL, "Failed to format common headers.\n");
header2 = dime_prsr_headers_parse(formatted, outsize);
ck_assert_msg(header2 != NULL, "Failed to parse common headers.\n");
res = st_cmp_cs_eq(header1->headers[HEADER_TYPE_DATE], header2->headers[HEADER_TYPE_DATE]);
ck_assert_msg(res == 0, "Date header was corrupted.\n");
res = st_cmp_cs_eq(header1->headers[HEADER_TYPE_TO], header2->headers[HEADER_TYPE_TO]);
ck_assert_msg(res == 0, "To header was corrupted.\n");
res = st_cmp_cs_eq(header1->headers[HEADER_TYPE_CC], header2->headers[HEADER_TYPE_CC]);
ck_assert_msg(res == 0, "CC header was corrupted.\n");
res = st_cmp_cs_eq(header1->headers[HEADER_TYPE_FROM], header2->headers[HEADER_TYPE_FROM]);
ck_assert_msg(res == 0, "From header was corrupted.\n");
res = st_cmp_cs_eq(header1->headers[HEADER_TYPE_ORGANIZATION], header2->headers[HEADER_TYPE_ORGANIZATION]);
ck_assert_msg(res == 0, "Organization header was corrupted.\n");
res = st_cmp_cs_eq(header1->headers[HEADER_TYPE_SUBJECT], header2->headers[HEADER_TYPE_SUBJECT]);
ck_assert_msg(res == 0, "Subject header was corrupted.\n");
dime_prsr_headers_destroy(header1);
dime_prsr_headers_destroy(header2);
free(formatted);
fprintf(stderr, "DMIME common header parsing complete.\n");
}
示例5: START_TEST
END_TEST
START_TEST(test_large_data)
{
unsigned char k[CRYPTO_SHARED_KEY_SIZE];
unsigned char n[CRYPTO_NONCE_SIZE];
unsigned char m1[MAX_CRYPTO_PACKET_SIZE - CRYPTO_MAC_SIZE];
unsigned char c1[sizeof(m1) + CRYPTO_MAC_SIZE];
unsigned char m1prime[sizeof(m1)];
unsigned char m2[MAX_CRYPTO_PACKET_SIZE];
unsigned char c2[sizeof(m2) + CRYPTO_MAC_SIZE];
int c1len, c2len;
int m1plen;
//Generate random messages
rand_bytes(m1, sizeof(m1));
rand_bytes(m2, sizeof(m2));
rand_bytes(n, CRYPTO_NONCE_SIZE);
//Generate key
rand_bytes(k, CRYPTO_SHARED_KEY_SIZE);
c1len = encrypt_data_symmetric(k, n, m1, sizeof(m1), c1);
c2len = encrypt_data_symmetric(k, n, m2, sizeof(m2), c2);
ck_assert_msg(c1len == sizeof(m1) + CRYPTO_MAC_SIZE, "could not encrypt");
ck_assert_msg(c2len == sizeof(m2) + CRYPTO_MAC_SIZE, "could not encrypt");
m1plen = decrypt_data_symmetric(k, n, c1, c1len, m1prime);
ck_assert_msg(m1plen == sizeof(m1), "decrypted text lengths differ");
ck_assert_msg(memcmp(m1prime, m1, sizeof(m1)) == 0, "decrypted texts differ");
}
示例6: serve_echo
/**
* Run an echo server
*/
static job_requeue_t serve_echo(echo_server_config_t *config)
{
tls_socket_t *tls;
int sfd, cfd;
identification_t *server, *client = NULL;
ssize_t len, total, done;
char buf[128];
server = identification_create_from_string(config->addr);
if (config->cauth)
{
client = server;
}
sfd = config->fd;
while (TRUE)
{
cfd = accept(sfd, NULL, NULL);
if (cfd < 0)
{
break;
}
tls = tls_socket_create(TRUE, server, client, cfd, NULL,
config->version, TRUE);
ck_assert(tls != NULL);
while (TRUE)
{
len = tls->read(tls, buf, sizeof(buf), TRUE);
if (len <= 0)
{
break;
}
total = 0;
while (total < len)
{
done = tls->write(tls, buf + total, len - total);
ck_assert_msg(done > 0, "%s", strerror(errno));
total += done;
}
}
tls->destroy(tls);
close(cfd);
}
server->destroy(server);
return JOB_REQUEUE_NONE;
}
示例7: START_TEST
END_TEST
#define NUM_VALORES 9
START_TEST( test_cola_prioridad_pop) {
const tipo_dato VALORES[NUM_VALORES] = { 9, 5, 10, 1, 6, 11, 0, 2, 3 };
const tipo_dato VALORES_FINALES_INORDER[NUM_VALORES - 2] = { 2, 3, 4, 5, 6,
9, 10 };
int resultado = 0;
int num_datos_colectados = 0;
cola_prioridad_contexto ctx;
tipo_dato valores_inorder_resultado[NUM_VALORES] = { 0 };
nodo_cola_prioridad **referencias_directas = NULL;
nodo_cola_prioridad *nodo_pop_1 = NULL;
nodo_cola_prioridad *nodo_pop_2 = NULL;
caca_log_debug("empezando el año");
cola_prioridad_init(&ctx, NULL, (tipo_dato *) VALORES, NULL, NUM_VALORES,
NULL, NULL);
referencias_directas = ctx.referencias_directas_por_indice;
for (int i = 0; i < NUM_VALORES + 1; i++) {
caca_log_debug("referencias directas indice %d valor %ld", i,
ARBOL_AVL_GET_VALOR(*(referencias_directas + i)));
}
nodo_pop_1 = cola_prioridad_pop(&ctx);
nodo_pop_2 = cola_prioridad_pop(&ctx);
cola_prioridad_get_valores(&ctx, valores_inorder_resultado,
&num_datos_colectados);
for (int i = 0; i < NUM_VALORES; i++) {
caca_log_debug("eien pressure %d %ld", i,
*(valores_inorder_resultado + i));
}
resultado = num_datos_colectados == (NUM_VALORES - 2)
&& !memcmp(VALORES_FINALES_INORDER, valores_inorder_resultado, 9)
&& nodo_pop_1->valor == 0 && nodo_pop_2->valor == 1;
zlog_fini();
ck_assert_msg(resultado, "los datos colectados %d", num_datos_colectados);
}
示例8: START_TEST
END_TEST
START_TEST (test_reject_p1_n1_c2) {
int i;
s_array * paths;
c_array * line_buffer;
i_array * stat_indices;
d_array * obs_stats;
d_array * means;
d_array * std_devs;
s_array * header;
sample_array * samples;
int num_to_retain;
num_to_retain = 1;
paths = init_s_array(1);
line_buffer = init_c_array(1023);
stat_indices = init_i_array(4);
means = init_d_array(1);
std_devs = init_d_array(1);
obs_stats = init_d_array(1);
header = init_s_array(1);
append_s_array(paths, "data/test_parameter_stat_samples.txt");
parse_header(get_s_array(paths, 0), line_buffer, header);
for (i = 3; i < header->length; i += 2) {
append_i_array(stat_indices, i);
}
append_d_array(obs_stats, 0.21);
append_d_array(obs_stats, 2.0);
append_d_array(means, 0.2225);
append_d_array(means, 3.0);
append_d_array(std_devs, 0.009574271);
append_d_array(std_devs, 1.154701);
standardize_vector(obs_stats, means, std_devs);
samples = reject(paths, line_buffer, stat_indices, obs_stats, means,
std_devs, num_to_retain, header);
ck_assert_int_eq(samples->length, num_to_retain);
ck_assert_int_eq(samples->capacity, num_to_retain);
ck_assert_msg((almost_equal(samples->a[0]->distance, 0.0, 0.000001)),
"euclidean distance was %lf, expected %lf",
samples->a[0]->distance, 0.0);
free_s_array(paths);
free_c_array(line_buffer);
free_i_array(stat_indices);
free_d_array(obs_stats);
free_sample_array(samples);
free_d_array(means);
free_d_array(std_devs);
free_s_array(header);
}
示例9: START_TEST
}END_TEST
START_TEST(check_Fs_LoadFile)
{
void *buffer;
int64_t len = Fs_Load("quetoo.cfg", &buffer);
ck_assert_msg(len > 0, "Failed to load quetoo.cfg");
const char *prefix = "// generated by Quetoo, do not modify\n";
ck_assert(g_str_has_prefix((const char *) buffer, prefix));
Fs_Free(buffer);
}END_TEST
示例10: START_TEST
END_TEST
START_TEST(test_modu)
{
double a[]= {10.0, 0.0, 0.0};
double m;
modu(a,&m);
// fail_unless( m == 10.0);
ck_assert_msg( fabs(m - 10.0) < EPS,
"Was expecting m to be 10.0 but found %f \n", m);
}
示例11: START_TEST
END_TEST
START_TEST(test_pack_loc_limit)
{
LocMsg lmsg;
LocMsg *lmsgp = NULL;
char *buf;
enum ck_msg_type type;
lmsg.file = (char *) "";
lmsg.line = 0;
pack (CK_MSG_LOC, &buf, (CheckMsg *) &lmsg);
lmsg.file = NULL;
upack (buf, (CheckMsg *) &lmsg, &type);
ck_assert_msg (lmsg.file != NULL,
"Empty string not handled properly");
ck_assert_msg (strcmp (lmsg.file, "") == 0,
"Empty string not handled properly");
free (lmsg.file);
lmsg.file = NULL;
pack (CK_MSG_LOC, &buf, (CheckMsg *) &lmsg);
pack (CK_MSG_LOC, &buf, (CheckMsg *) lmsgp);
}
示例12: test_expire_basic
void
test_expire_basic(uint32_t policy, bool cas)
{
#define KEY "key"
#define VAL "value"
#define NOW 12345678
struct bstring key;
struct val val;
rstatus_i status;
struct item *it;
test_reset(policy, cas);
key.data = KEY;
key.len = sizeof(KEY) - 1;
val.type = VAL_TYPE_STR;
val.vstr.data = VAL;
val.vstr.len = sizeof(VAL) - 1;
now = NOW;
status = cuckoo_insert(&key, &val, NOW + 1);
ck_assert_msg(status == CC_OK, "cuckoo_insert not OK - return status %d",
status);
it = cuckoo_get(&key);
ck_assert_msg(it != NULL, "cuckoo_get returned NULL");
now += 2;
it = cuckoo_get(&key);
ck_assert_msg(it == NULL, "cuckoo_get returned not NULL after expiration");
#undef NOW
#undef KEY
#undef VAL
}
示例13: START_TEST
END_TEST
START_TEST (test_send_disconnect)
{
int err;
memif_connection_t conn;
conn.fd = -1;
/* only possible fail if memif_msg_send fails... */
/* obsolete without socket */
if ((err =
memif_msg_send_disconnect (conn.fd, (uint8_t *)"unit_test_dc",
0)) != MEMIF_ERR_SUCCESS)
ck_assert_msg (err == MEMIF_ERR_BAD_FD, "err code: %u, err msg: %s", err,
memif_strerror (err));
}
示例14: START_TEST
END_TEST
START_TEST(test_fork1c_pass)
{
pid_t pid;
if((pid = check_fork()) < 0) {
ck_abort_msg("Failed to fork new process");
} else if (pid > 0) {
check_waitpid_and_exit(pid);
} else {
ck_assert_msg(1, NULL);
check_waitpid_and_exit(0);
}
}
示例15: START_TEST
END_TEST
START_TEST(test_getself_name)
{
char *nickname = "testGallop";
int len = strlen(nickname);
char nick_check[len];
setname(m, (uint8_t *)nickname, len);
getself_name(m, (uint8_t *)nick_check);
ck_assert_msg((memcmp(nickname, nick_check, len) == 0),
"getself_name failed to return the known name!\n"
"known name: %s\nreturned: %s\n", nickname, nick_check);
}