C++ ck_assert_ptr_ne函数代码示例

static void setup() {
  ck_assert_ptr_ne(keystore = nuts_keystore_new(NUTS_SESSION_SRV), NULL);

  ck_assert_ptr_ne(handler = nuts_service_create(), NULL);
  env.rw = malloc(sizeof(struct nuts_session_rw));
  ck_assert_int_eq(nuts_session_rw_init(env.rw, NUTS_SESSION_SRV, keystore), 0);

  ck_assert_ptr_ne(buf_s2c = &env.rw->lv[NUTS_WRITE], NULL);
  nuts_lv_clear(buf_s2c);

  nuts_lv_init(&msg_buf);

  payload = NULL;
  npayload = 0;
  cstr = NULL;
  selected_invocations = 0;
  cleanup_invocations = 0;
  tick_invocations = 0;

  ck_assert_int_eq(nuts_service_add_srv_spec(handler, &inval_spec, &test_ctx), 0);
  ck_assert_int_eq(nuts_service_add_srv_spec(handler, &error_spec, &test_ctx), 0);
  ck_assert_int_eq(nuts_service_add_srv_spec(handler, &done_spec, &test_ctx), 0);
  ck_assert_int_eq(nuts_service_add_srv_spec(handler, &continue_spec, &test_ctx), 0);
  ck_assert_int_eq(nuts_service_add_srv_spec(handler, &again_spec, &test_ctx), 0);
}

END_TEST

START_TEST(arrayCopyShallMakeADeepCopy) {
	// given
	UA_String a1[3];
	a1[0] = (UA_String){1, (UA_Byte*)"a"};
	a1[1] = (UA_String){2, (UA_Byte*)"bb"};
	a1[2] = (UA_String){3, (UA_Byte*)"ccc"};
	// when
	UA_String *a2;
	UA_Int32   retval = UA_Array_copy((const void *)a1, 3, &UA_TYPES[UA_STRING], (void **)&a2);
	// then
	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
	ck_assert_int_eq(a1[0].length, 1);
	ck_assert_int_eq(a1[1].length, 2);
	ck_assert_int_eq(a1[2].length, 3);
	ck_assert_int_eq(a1[0].length, a2[0].length);
	ck_assert_int_eq(a1[1].length, a2[1].length);
	ck_assert_int_eq(a1[2].length, a2[2].length);
	ck_assert_ptr_ne(a1[0].data, a2[0].data);
	ck_assert_ptr_ne(a1[1].data, a2[1].data);
	ck_assert_ptr_ne(a1[2].data, a2[2].data);
	ck_assert_int_eq(a1[0].data[0], a2[0].data[0]);
	ck_assert_int_eq(a1[1].data[0], a2[1].data[0]);
	ck_assert_int_eq(a1[2].data[0], a2[2].data[0]);
	// finally
	UA_Array_delete((void *)a2, 3, &UA_TYPES[UA_STRING]);
}

END_TEST

START_TEST (test_expression)
{
    int i;
    expression *e = get_expression("c1, symbol O+C");

    ck_assert_ptr_ne(e,NULL);
    ck_assert_int_eq(e->type, E_SELECTION);
    ck_assert_ptr_ne(e->left, NULL);
    ck_assert_ptr_eq(e->right, NULL);
    ck_assert_str_eq(e->value, "c1");
    ck_assert_int_eq(e->left->type,E_SYMBOL);
    ck_assert_ptr_ne(e->left->left,NULL);
    ck_assert_ptr_eq(e->left->right,NULL);
    ck_assert_int_eq(e->left->left->type,E_PLUS);
    ck_assert_int_eq(e->left->left->left->type,E_ID);
    ck_assert_int_eq(e->left->left->right->type,E_ID);
    ck_assert_str_eq(e->left->left->right->value,"C");
    ck_assert_str_eq(e->left->left->left->value,"O");
    for (i = E_SELECTION; i <= E_RANGE_OPEN_R; ++i) {
        ck_assert_ptr_ne(e_str(i), NULL);
    }
    ck_assert_ptr_eq(e_str(E_RANGE_OPEN_R+1), NULL);
}

END_TEST

START_TEST(test_hyperloglog_copy_and_clone)
{
  DESCRIBE_TEST;
  for (uint8_t p = TW_HLL_MIN_PRECISION; p <= TW_HLL_MAX_PRECISION; ++p) {
    const uint32_t n_registers = 1 << p;
    struct tw_hyperloglog *hll = tw_hyperloglog_new(p);
    struct tw_hyperloglog *copy = tw_hyperloglog_new(p);

    /** test linear_count */
    for (size_t k = 0; k < n_registers; ++k) {
      if (k % 2) {
        tw_hyperloglog_add(hll, (void *)&k, sizeof(k));
      }
    }

    ck_assert_ptr_ne(tw_hyperloglog_copy(hll, copy), NULL);
    ck_assert(
        tw_almost_equal(tw_hyperloglog_count(hll), tw_hyperloglog_count(copy)));

    struct tw_hyperloglog *clone = tw_hyperloglog_clone(copy);
    ck_assert_ptr_ne(clone, NULL);
    ck_assert(tw_hyperloglog_equal(hll, clone));
    ck_assert(tw_almost_equal(tw_hyperloglog_count(hll),
                              tw_hyperloglog_count(clone)));

    tw_hyperloglog_free(clone);
    tw_hyperloglog_free(copy);
    tw_hyperloglog_free(hll);
  }
}

END_TEST

START_TEST (test_structure)
{
    FILE *file = fopen(DATADIR "1ubq.pdb","r");
    int n;
    freesasa_set_verbosity(FREESASA_V_SILENT);
    ck_assert_ptr_ne(file, NULL);
    ck_assert_ptr_eq(freesasa_structure_new(), NULL);
    ck_assert_ptr_eq(from_pdb_impl(file,interval, NULL, 0), NULL);
    for (int i = 1; i < 100; ++i) {
        set_fail_freq(i);
        rewind(file);
        ck_assert_ptr_eq(freesasa_structure_from_pdb(file, NULL, 0), NULL);
    }
    fclose(file);
    
    file = fopen(DATADIR "2jo4.pdb", "r");
    ck_assert_ptr_ne(file,NULL);
    for (int i = 1; i < 50; ++i) {
        set_fail_freq(i);
        rewind(file);
        ck_assert_ptr_eq(freesasa_structure_array(file, &n, NULL, FREESASA_SEPARATE_MODELS),NULL);
        rewind(file);
        ck_assert_ptr_eq(freesasa_structure_array(file, &n, NULL, FREESASA_SEPARATE_MODELS | FREESASA_SEPARATE_CHAINS),NULL);
    }
    set_fail_freq(1);
    fclose(file);
    freesasa_set_verbosity(FREESASA_V_NORMAL);
}

END_TEST

START_TEST(test_osgetelements)
{
    char xml_file_name[256];
    create_xml_file("<root><child1/><child2/></root>", xml_file_name, 256);
    OS_XML xml;
    ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
    ck_assert_int_eq(OS_ApplyVariables(&xml), 0);
    const char *xml_path[] = { "root", NULL };
    char **content1, **content2;
    ck_assert_ptr_ne(content1 = OS_GetElements(&xml, xml_path), NULL);
    ck_assert_str_eq(content1[0], "child1");
    ck_assert_str_eq(content1[1], "child2");
    ck_assert_ptr_eq(content1[2], NULL);
    ck_assert_ptr_ne(content2 = OS_GetElements(&xml, NULL), NULL);
    ck_assert_str_eq(content2[0], "root");
    ck_assert_ptr_eq(content2[1], NULL);
    const char *xml_path2[] = { NULL };
    ck_assert_ptr_eq(OS_GetElements(&xml,  xml_path2), NULL);

    int i = 0;
    while (content1[i]) {
        free(content1[i++]);
    }
    free(content1);
    i = 0;
    while (content2[i]) {
        free(content2[i++]);
    }
    free(content2);
    OS_ClearXML(&xml);
    unlink(xml_file_name);
}

END_TEST

START_TEST (test_copy_cell)
{
	apr_pool_t* pool = NULL;
    apr_pool_create(&pool, NULL);
	cell* parent = sexpr_cell(pool);
    cell* childa = sym_cell(pool, "a");
    cell* childb = sym_cell(pool, "b");
    cell* childc = sym_cell(pool, "c");	
	
	add_cell(pool, parent, childc);
    add_cell(pool, parent, childb);
    add_cell(pool, parent, childa);

	cell* clone = copy_cell(pool, parent);
	ck_assert_int_eq(3, clone->count);
	cell* clonec = pop_cell(pool, clone, 0);
	ck_assert_ptr_ne(clonec, childc);
	ck_assert_str_eq(clonec->sym, childc->sym);
	cell* cloneb = pop_cell(pool, clone, 0);
	ck_assert_ptr_ne(cloneb, childb);
	ck_assert_str_eq(cloneb->sym, childb->sym);
	cell* clonea = pop_cell(pool, clone, 0);
	ck_assert_ptr_ne(clonea, childa);
	ck_assert_str_eq(clonea->sym, childa->sym);
	ck_assert_int_eq(0, clone->count);	

    apr_pool_destroy(pool);
}

END_TEST

START_TEST (test_two_subscribers_and_push_event)
{
    printf("\n-----test_two_subscribers_and_push_event start-----\n");
    sentToCallback = NULL;
    sentToCallback2 = NULL;
    InitEventProcessor();
    int16_t stakeholderId = RegisterStakeholder("teststakeholder");
    eventSubscription_t subscription;
    subscription.stakeholderId = stakeholderId;
    subscription.eventType = EVENT_HEARTBEAT;
    subscription.callback = &test_callback;
    Subscribe(subscription);

    stakeholderId = RegisterStakeholder("teststakeholder2");
    eventSubscription_t subscription2;
    subscription2.stakeholderId = stakeholderId;
    subscription2.callback = &test_callback2;
    subscription2.eventType = EVENT_HEARTBEAT;
    Subscribe(subscription2);

    struct timespec tms;
    clock_gettime(CLOCK_REALTIME, &tms);
    event_t* event = (event_t*)malloc(sizeof(event_t));
    event->timeStamp = tms.tv_sec;
    event->prio = 123;
    event->sourceId = stakeholderId;
    event->eventType = EVENT_HEARTBEAT;
    event->payloadSize = 0;
    event->payload = NULL;

    printf("pushing eventdata ptr=%p, timeStamp=%d, prio=%d, sourceId=%d, eventType=%d, payloadSize=%d, *payload=%p\n", event, event->timeStamp, event->prio, event->sourceId, event->eventType, event->payloadSize, event->payload);

    int rsp = PushEvent(event);
    
    printf("Done with PushEvent, moving on to asserts, waiting for callbacks to be called\n");
    fflush(stdout);

    int waitForCallback = WaitForCallback();
    ck_assert_int_eq (waitForCallback, 0);
    int waitForCallback2 = WaitForCallback2();
    ck_assert_int_eq (waitForCallback2, 0);
    ck_assert_int_eq (rsp, EP_OK); 
    printf("sentToCallback=%p sentToCallback2=%p\n", sentToCallback, sentToCallback2);
    ck_assert_ptr_ne (sentToCallback, (event_t*)0);
    ck_assert_ptr_ne (sentToCallback2, (event_t*)0);
    if ((sentToCallback - sentToCallback2) == 0) ck_abort_msg("Failed! Same event sent to both subscribers");


    int firstEventEqual = CompareEvent(event, sentToCallback); 
    ck_assert_int_eq (firstEventEqual, 0);
    int secondEventEqual = CompareEvent(event, sentToCallback2); 
    ck_assert_int_eq (secondEventEqual, 0);
    printf("-----test_two_subscribers_and_push_event done-----\n\n");
    free(event);
}

static void setup() {
  nuts_lv_init(&lv);
  nuts_lv_init(&I_C); nuts_lv_set_cstr(&I_C, "clients KEXINIT payload");
  nuts_lv_init(&I_S); nuts_lv_set_cstr(&I_S, "servers KEXINIT payload");
  nuts_lv_init(&K_S); nuts_lv_set_cstr(&K_S, "the hostkey");
  ck_assert_ptr_ne(e = nuts_mpi_new_ul(1), NULL);
  ck_assert_ptr_ne(f = nuts_mpi_new_ul(2), NULL);
  ck_assert_ptr_ne(K = nuts_mpi_new_ul(3), NULL);
}

END_TEST

START_TEST(test_ck_assert_ptr_ne)
{
  int * x = (int*)0x1;
  int * y = (int*)0x2;
  int * z = x;
  ck_assert_ptr_ne(x,    y);
  ck_assert_ptr_ne(x,    NULL);
  ck_assert_ptr_ne(NULL, y);
  ck_assert_ptr_ne(x,    z);
  #define LINENO_ck_assert_ptr_ne _STR(__LINE__)
}

END_TEST

START_TEST(test_curve25519_generate_public)
{
    int result;

    uint8_t alicePublic[] = {
            0x05, 0x1b, 0xb7, 0x59, 0x66,
            0xf2, 0xe9, 0x3a, 0x36, 0x91,
            0xdf, 0xff, 0x94, 0x2b, 0xb2,
            0xa4, 0x66, 0xa1, 0xc0, 0x8b,
            0x8d, 0x78, 0xca, 0x3f, 0x4d,
            0x6d, 0xf8, 0xb8, 0xbf, 0xa2,
            0xe4, 0xee, 0x28};

    uint8_t alicePrivate[] = {
            0xc8, 0x06, 0x43, 0x9d, 0xc9,
            0xd2, 0xc4, 0x76, 0xff, 0xed,
            0x8f, 0x25, 0x80, 0xc0, 0x88,
            0x8d, 0x58, 0xab, 0x40, 0x6b,
            0xf7, 0xae, 0x36, 0x98, 0x87,
            0x90, 0x21, 0xb9, 0x6b, 0xb4,
            0xbf, 0x59};

    ec_private_key *alice_private_key = 0;
    ec_public_key *alice_expected_public_key = 0;
    ec_public_key *alice_public_key = 0;

    /* Initialize Alice's private key */
    result = curve_decode_private_point(&alice_private_key, alicePrivate, sizeof(alicePrivate), global_context);
    ck_assert_int_eq(result, 0);
    ck_assert_ptr_ne(alice_private_key, 0);

    /* Initialize Alice's expected public key */
    result = curve_decode_point(&alice_expected_public_key, alicePublic, sizeof(alicePublic), global_context);
    ck_assert_int_eq(result, 0);
    ck_assert_ptr_ne(alice_expected_public_key, 0);

    /* Generate Alice's actual public key */
    result = curve_generate_public_key(&alice_public_key, alice_private_key);
    ck_assert_int_eq(result, 0);
    ck_assert_ptr_ne(alice_public_key, 0);

    /* Assert that expected and actual public keys match */
    ck_assert_int_eq(ec_public_key_compare(alice_expected_public_key, alice_public_key), 0);

    /* Cleanup */
    SIGNAL_UNREF(alice_public_key);
    SIGNAL_UNREF(alice_expected_public_key);
    SIGNAL_UNREF(alice_private_key);
}

END_TEST


START_TEST (test_connects_tcp_and_establishes_protocol)
{
    uint32_t version = htonl(1);
    rb_append(in_rb, &version, sizeof(version));

    neo4j_connection_t *connection = neo4j_tcp_connect(
            "localhost", 7687, config, 0);
    ck_assert_ptr_ne(connection, NULL);
    ck_assert_ptr_eq(connection->iostream, client_ios);

    ck_assert_int_eq(rb_used(out_rb), 20);
    uint8_t expected_hello[4] = { 0x60, 0x60, 0xB0, 0x17 };
    uint8_t hello[4];
    rb_extract(out_rb, hello, 4);
    ck_assert(memcmp(hello, expected_hello, 4) == 0);

    uint32_t expected_versions[4] = { htonl(1), 0, 0, 0 };
    uint32_t versions[4];
    rb_extract(out_rb, versions, 16);
    ck_assert(memcmp(versions, expected_versions, 16) == 0);

    neo4j_close(connection);
}

END_TEST

START_TEST(test_version_string) {
    const struct vca_boilerplate_version * const version = vca_boilerplate_get_version();
    ck_assert_ptr_ne(NULL, version);
    ck_assert_str_eq(version->string, VCA_BOILERPLATE_VERSION_STRING);
}

END_TEST

START_TEST(test_jwt_encode_alg_none)
{
	const char res[] = "eyJhbGciOiJub25lIn0.eyJhdWQiOiJ3d3cucGx1Z2dlcnM"
		"ubmwiLCJleHAiOjE0Nzc1MTQ4MTIsInN1YiI6IlBsdWdnZXJzIFNvZnR3YXJlIn0.";
	jwt_t *jwt = NULL;
	int ret = 0;
	char *out;

	ALLOC_JWT(&jwt);

	ret = jwt_add_grant(jwt, "aud", "www.pluggers.nl");
	ck_assert_int_eq(ret, 0);

	ret = jwt_add_grant_int(jwt, "exp", 1477514812);
	ck_assert_int_eq(ret, 0);

	ret = jwt_add_grant(jwt, "sub", "Pluggers Software");
	ck_assert_int_eq(ret, 0);

	ret = jwt_set_alg(jwt, JWT_ALG_NONE, NULL, 0);
	ck_assert_int_eq(ret, 0);

	out = jwt_encode_str(jwt);
	ck_assert_ptr_ne(out, NULL);

	ck_assert_str_eq(out, res);

	free(out);

	jwt_free(jwt);
}

void _setup_number_lexer(void) {
  lexa = setup_with_scanners();
  lexa_add_scanner(lexa, "number");
  ck_assert_int_eq(dict_size(lexa -> scanners), 4);
  lexa_build_lexer(lexa);
  ck_assert_ptr_ne(lexa -> config, NULL);
}