Esempio n. 1
0
static bool testClientsManagerExecurePurchase(){

	Email email = NULL;
	emailCreate("baba@ganosh", &email);
	Email mail = NULL;
	emailCreate("baba@gash", &mail);
	ClientsManager manager = clientsManagerCreate();
	clientsManagerAdd( manager, email, 1, 1, 200);

	ASSERT_TEST( clientsManagerExecutePurchase( NULL, email, 330) ==
			CLIENT_MANAGER_INVALID_PARAMETERS);
	ASSERT_TEST( clientsManagerExecutePurchase( manager, NULL, 330) ==
			CLIENT_MANAGER_INVALID_PARAMETERS);

	ASSERT_TEST( clientsManagerExecutePurchase( manager, mail, 330) ==
			CLIENT_MANAGER_NOT_EXISTS);

	ASSERT_TEST( clientsManagerExecutePurchase( manager, email, 330) ==
				CLIENT_MANAGER_SUCCESS);

	emailDestroy(mail);
	emailDestroy(email);
	clientsManagerDestroy(manager);
	return true;
}
Esempio n. 2
0
File: tests.cpp Progetto: KnowNo/pal
static void test_decoding_of_type2_message()
{
    char const * data = "TlRMTVNTUAACAAAAAAAAADgAAADzgpjiavm/AUnPdy4AAAAAAAAAAIYAhgA4AAAABQLODgAAAA8CABAAQgBJAFIARABMAEEATgBEAAEACgBZAFUAQwBDAEEABAAYAGIAaQByAGQAbABhAG4AZAAuAGkAbgB0AAMAJAB5AHUAYwBjAGEALgBiAGkAcgBkAGwAYQBuAGQALgBpAG4AdAAFABgAYgBpAHIAZABsAGEAbgBkAC4AaQBuAHQAAAAAAA==";
    pal::type2_message t2(pal::as_bytes_from_base64_string(data));
    ASSERT_TEST( t2.challenge() == (uint64_t)0x2e77cf4901bff96a );
    ASSERT_TEST( t2.ssp_flags() == (uint32_t)0xe29882f3 );
}
Esempio n. 3
0
/* Release PCIe device */
static int pcie_release (llio_t *self, llio_endpoint_t *endpoint)
{
    (void) endpoint;

    if (!llio_get_endpoint_open (self)) {
        /* Nothing to close */
        return 0;
    }

    llio_err_e lerr = LLIO_SUCCESS;
    int err = 0;
    llio_dev_pcie_t *dev_pcie = llio_get_dev_handler (self);
    ASSERT_TEST(dev_pcie != NULL, "Could not get PCIe handler",
            err_dev_pcie_handler, -1);

    /* Deattach specific device handler to generic one */
    lerr = llio_dev_pcie_destroy (&dev_pcie);
    ASSERT_TEST (lerr==LLIO_SUCCESS, "Could not close device appropriately",
            err_dealloc, -1);

    llio_set_dev_handler (self, NULL);
    llio_set_endpoint_open (self, false);

    DBE_DEBUG (DBG_LL_IO | DBG_LVL_INFO,
            "[ll_io_pcie] Closed PCIe device located at %s\n",
            llio_get_endpoint_name (self));

    return err;

err_dealloc:
err_dev_pcie_handler:
    return err;
}
Esempio n. 4
0
int test_insertion3(){
	Lock_list<int> list;
	Node<int>* node;
	int x = 1;
	
	list.insertFirst(x);
	node = list.lockFirst();
	//1
	ASSERT_TEST(**node == 1);
	list.unlockCurrent(node);
	x = 3;
	list.insertBeforeCurrent(x, node);
	node = list.lockPrev(node);
	//3,1
	ASSERT_TEST(**node == 3);
	list.unlockCurrent(node);
	node = list.lockNext(node);
	ASSERT_TEST(**node == 1);
	list.unlockCurrent(node);

	x = 5;
	list.insertAfterCurrent(x, node);
	node = list.lockNext(node);
	//3,1,5
	ASSERT_TEST(**node == 5);
	list.unlockCurrent(node);

	return 1;



}
static ssize_t _thsafe_zmq_client_recv_write (smio_t *self)
{
    ssize_t ret_size = -1;

    /* Returns NULL if confirmation was not OK or in case of error.
     * Returns the original message if the confirmation was OK */
    zmsg_t *recv_msg = _thsafe_zmq_client_recv_confirmation (self);
    ASSERT_TEST(recv_msg != NULL, "Could not receive confirmation code", err_null_recv_msg);

    /* If we are here, confirmation code was OK. Check for second frame */
    zframe_t *reply_frame = zmsg_pop (recv_msg);
    zframe_destroy (&reply_frame); /* Don't do anything with the reply code */

    zframe_t *return_frame = zmsg_pop (recv_msg);
    ASSERT_TEST(return_frame != NULL, "Could not receive retrurn code", err_null_ret_code_frame);

    if (zframe_size (return_frame) != THSAFE_RETURN_SIZE) {
        DBE_DEBUG (DBG_MSG | DBG_LVL_ERR, "[smio_thsafe_client:zmq] Return frame size is wrong\n");
        goto err_wrong_size_ret_frame;
    }

    ret_size = *(THSAFE_RETURN_TYPE *) zframe_data (return_frame);

    DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Received code: %zd\n", ret_size);

err_wrong_size_ret_frame:
    zframe_destroy (&return_frame);
err_null_ret_code_frame:
err_null_recv_msg:
    return ret_size;
}
Esempio n. 6
0
static void _devio_destroy_smio (devio_t *self, uint32_t smio_id)
{
    assert (self);

    /* Stringify ID */
    char *key_c = halutils_stringify_key (smio_id);
    ASSERT_ALLOC (key_c, err_key_alloc);

    /* Lookup SMIO reference in hash table */
    void *pipe = zhash_lookup (self->sm_io_h, key_c);
    ASSERT_TEST (pipe != NULL, "Could not find SMIO registered with this ID",
            err_hash_lookup);

    /* Send message to SMIO informing it to destroy itself */
    /* This cannot fail at this point... but it can */
    zmsg_t *send_msg = zmsg_new ();
    ASSERT_ALLOC (send_msg, err_msg_alloc);
    /* An empty message means to selfdestruct */
    zmsg_pushstr (send_msg, "");
    int zerr = zmsg_send (&send_msg, pipe);
    ASSERT_TEST (zerr == 0, "Could not send self-destruct message to SMIO instance",
            err_send_msg);

    /* Finally, remove the pipe from hash */
    zhash_delete (self->sm_io_h, key_c);

err_send_msg:
    zmsg_destroy (&send_msg);
err_msg_alloc:
err_hash_lookup:
    free (key_c);
err_key_alloc:
    return;
}
Esempio n. 7
0
static bool testCacheExtractElementByKey() {
	char * andykaufman = "andykaufman";
	char * agonist = "agonist";
	char * nightwish = "nightwish";

	Cache cache = cacheCreate(256, freeString, copyString, compareStrings, getFirstLetter);
	ASSERT_TEST(cache != NULL);

	ASSERT_TEST(cachePush(cache, nightwish) == CACHE_SUCCESS);
	ASSERT_TEST(cachePush(cache, nightwish) == CACHE_ITEM_ALREADY_EXISTS);
	ASSERT_TEST(cacheIsIn(cache, nightwish));
	ASSERT_TEST(cachePush(cache, andykaufman) == CACHE_SUCCESS);
	ASSERT_TEST(cachePush(cache, andykaufman) == CACHE_ITEM_ALREADY_EXISTS);
	ASSERT_TEST(cacheIsIn(cache, andykaufman));
	ASSERT_TEST(cachePush(cache, agonist) == CACHE_SUCCESS);
	ASSERT_TEST(cachePush(cache, agonist) == CACHE_ITEM_ALREADY_EXISTS);
	ASSERT_TEST(cacheIsIn(cache, agonist));

	const int SIZE = 3;
	char * elements[SIZE];
	int i = 0;
	CACHE_FOREACH(set, cache) {
		SET_FOREACH(char *, str, set) {
			elements[i++] = str;
		}
	}
Esempio n. 8
0
bool block_program_test() {
  	const char* name1 = "/root/hw1_tests/prog1";
	const char* name2 = "/root/hw1_tests/prog2";
  	const char* name3 = "";
  	int len = strlen(name1);
  	ASSERT_TEST(block_program(NULL, 5) == -1);
  	ASSERT_TEST(errno == EINVAL);
  	ASSERT_TEST(block_program(name3, 0) == -1);
    ASSERT_TEST(errno == EINVAL);
 	ASSERT_TEST(block_program(name1, 0) == -1);
    ASSERT_TEST(errno == EINVAL);
  	ASSERT_TEST(block_program(name2, len) == 0);
  	ASSERT_TEST(block_program(name1, len) == 0);
    ASSERT_TEST(block_program(name2, len) == 1);
    ASSERT_TEST(block_program(name1, len) == 1);
    char *argva[] = {"/root/hw1_tests/prog1", 0};
    char *argvb[] = {"/root/hw1_tests/prog2", 0};
    
    //fails
	execv(name1, argva);
	execv(name2, argvb);

    unblock_program (name1, len);
    unblock_program (name2, len);
	return true;
}
static ssize_t _thsafe_zmq_client_read_generic (smio_t *self, loff_t offs, uint8_t *data,
        uint32_t size)
{
    assert (self);
    ssize_t ret_size = -1;
    zmsg_t *send_msg = zmsg_new ();
    ASSERT_ALLOC(send_msg, err_msg_alloc);
    uint32_t opcode;

    DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Calling _thsafe_read_generic\n");

    switch (size) {
        case THSAFE_READ_16_DSIZE:
            opcode = THSAFE_READ_16;
        break;

        case THSAFE_READ_32_DSIZE:
            opcode = THSAFE_READ_32;
        break;

        case THSAFE_READ_64_DSIZE:
            opcode = THSAFE_READ_64;
        break;

        default:
            opcode = THSAFE_READ_32;
    }

    /* Message is:
     * frame 0: READ<size> opcode
     * frame 1: offset */
    int zerr = zmsg_addmem (send_msg, &opcode, sizeof (opcode));
    ASSERT_TEST(zerr == 0, "Could not add READ opcode in message",
            err_add_opcode);
    zerr = zmsg_addmem (send_msg, &offs, sizeof (offs));
    ASSERT_TEST(zerr == 0, "Could not add offset in message",
            err_add_offset);

    DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Sending message:\n");
#ifdef LOCAL_MSG_DBG
    zmsg_print (send_msg);
#endif

    zerr = zmsg_send (&send_msg, self->pipe);
    ASSERT_TEST(zerr == 0, "Could not send message", err_send_msg);

    /* Message is:
     * frame 0: reply code
     * frame 1: return code
     * frame 2: data */
    ret_size = _thsafe_zmq_client_recv_read (self, data, size);

err_send_msg:
err_add_offset:
err_add_opcode:
    zmsg_destroy (&send_msg);
err_msg_alloc:
    return ret_size;
}
Esempio n. 10
0
File: tests.cpp Progetto: KnowNo/pal
static void test_creating_nt_response()
{
    std::vector<uint8_t> pwdhash = pal::create_password_hash("secret");
    std::vector<uint8_t> expected = pal::as_bytes_from_hex_string("878D8014606CDA29677A44EFA1353FC7");
    ASSERT_TEST(pwdhash.size() == 16);
    ASSERT_TEST(pwdhash.size() == expected.size());
    ASSERT_TEST(std::equal(pwdhash.begin(), pwdhash.end(), expected.begin()));
}
Esempio n. 11
0
File: tests.cpp Progetto: KnowNo/pal
static void test_creating_md4_digest()
{
    std::vector<uint8_t> input = pal::as_bytes_from_hex_string("8899AABBCCDDEEFF0011223344556677");
    std::vector<uint8_t> output = pal::md4(input);
    std::vector<uint8_t> expected = pal::as_bytes_from_hex_string("5C0EC35E7A167E8D218C3CE168888723");
    ASSERT_TEST(expected.size() == output.size());
    ASSERT_TEST(std::equal(expected.begin(), expected.end(), output.begin()));
}
Esempio n. 12
0
File: tests.cpp Progetto: KnowNo/pal
static void test_encoding_with_rc4()
{
    std::vector<uint8_t> text = pal::as_bytes_from_hex_string("8899AABBCCDDEEFF0011223344556677");
    std::vector<uint8_t> key = pal::as_bytes_from_hex_string("00112233445566778899AABBCCDDEEFF");
    std::vector<uint8_t> cipher = pal::rc4(key,text);
    std::vector<uint8_t> expected = pal::as_bytes_from_hex_string("0DC206EC5EFA8F7AF8489B08D1101BE3");
    ASSERT_TEST(expected.size() == cipher.size());
    ASSERT_TEST(std::equal(expected.begin(), expected.end(), cipher.begin()));
}
Esempio n. 13
0
File: tests.cpp Progetto: KnowNo/pal
static void test_converting_string_to_unicode()
{
    std::vector<uint8_t> ustr = pal::as_unicode("Hello");
    uint8_t expected[] = {'H',0,'e',0,'l',0,'l',0,'o',0};
    ASSERT_TEST( std::equal(ustr.begin(), ustr.end(), expected) );
    ASSERT_TEST( ustr.size() == 10 );
    ustr = pal::as_unicode("");
    ASSERT_TEST( ustr.size() == 0 );
}
Esempio n. 14
0
File: tests.cpp Progetto: KnowNo/pal
static void test_calculating_lm_response()
{
    uint64_t challenge = 0xCAFEBABEDEADBEEF;
    std::vector<uint8_t> lmr = pal::calculate_lm_response("secret", challenge);
    ASSERT_TEST( lmr.size() == 24 );
    std::vector<uint8_t> expected = pal::as_bytes_from_hex_string("86730DE4EE77DB37308780F2801F7097CE876C4F37A90E18");
    ASSERT_TEST( lmr.size() == expected.size() );
    ASSERT_TEST( std::equal(expected.begin(), expected.end(), lmr.begin()) );
}
Esempio n. 15
0
File: tests.cpp Progetto: KnowNo/pal
static void test_creating_encrypted_session_key()
{
    std::vector<uint8_t> ph = pal::create_password_hash("secret");
    std::vector<uint8_t> sk = pal::as_bytes_from_hex_string("00112233445566778899AABBCCDDEEFF");
    std::vector<uint8_t> esk = pal::create_encrypted_session_key(ph,sk);
    std::vector<uint8_t> expected = pal::as_bytes_from_hex_string("F108FD16C6A48F619EDC61EC9EEC32F9");
    ASSERT_TEST(esk.size() == expected.size());
    ASSERT_TEST(std::equal(esk.begin(), esk.end(), expected.begin()));
}
Esempio n. 16
0
static bool testCacheFreeElement(void) {
	Cache cache = cacheCreate(255, freeString, copyString, compareStrings, getFirstLetter);

	char outOfRange[2] = { (char)255, '\0' };
	char *notInCache = "Rock";
	char *doubled = "Louna";
	char * elements[] = {
			"Ramones",
			"Lumen",
			"Louna",
			"Arch Enemy"
			"Linkin park",
	};
	const int ELEMENTS_SIZE = sizeof(elements) / sizeof(*elements);

	for (int i = 0; i < ELEMENTS_SIZE; ++i) {
		ASSERT_TEST(cachePush(cache, elements[i]) == CACHE_SUCCESS);
	}
	ASSERT_TEST(cachePush(cache, outOfRange) == CACHE_OUT_OF_RANGE);
	ASSERT_TEST(cachePush(cache, doubled) == CACHE_ITEM_ALREADY_EXISTS);

	ASSERT_TEST(cacheFreeElement(cache, outOfRange) == CACHE_ITEM_DOES_NOT_EXIST);
	ASSERT_TEST(cacheFreeElement(cache, notInCache) == CACHE_ITEM_DOES_NOT_EXIST);
	for (int i = ELEMENTS_SIZE-1; i >= 0; --i) {
		ASSERT_TEST(cacheFreeElement(cache, elements[i]) == CACHE_SUCCESS);
	}
	ASSERT_TEST(cacheFreeElement(cache, doubled) == CACHE_ITEM_DOES_NOT_EXIST);
	ASSERT_TEST(cacheFreeElement(NULL, doubled) == CACHE_NULL_ARGUMENT);
	ASSERT_TEST(cacheFreeElement(NULL, NULL) == CACHE_NULL_ARGUMENT);

	cacheDestroy(cache);
	return true;
}
/**
 * List of tests, one for each function is usually a good thumb rule.
 */
static bool testListCreate() {
	ASSERT_TEST(listCreate(NULL,NULL) == NULL);
	ASSERT_TEST(listCreate(NULL,NULL) == NULL);
	ASSERT_TEST(listCreate(personCopyHelper,NULL) == NULL);
	ASSERT_TEST(listCreate(NULL,personDestroyHelper) == NULL);
	List list = listCreate(personCopyHelper, personDestroyHelper);
	ASSERT_TEST(list != NULL);
	listDestroy(list);

	return true;
}
Esempio n. 18
0
File: tests.cpp Progetto: KnowNo/pal
static void test_converting_between_hex_string_and_bytes()
{
    std::vector<uint8_t> buf = pal::as_bytes_from_hex_string("CAFE0142");
    ASSERT_TEST(buf.size() == 4);
    ASSERT_TEST(buf[0] == 0xCA && buf[1] == 0xFE &&
                buf[2] == 0x01 && buf[3] == 0x42);
    std::string str = pal::as_hex_string(buf);
    ASSERT_TEST(str == "CAFE0142");
    buf = pal::as_bytes_from_hex_string("");
    ASSERT_TEST(buf.size() == 0);
    str = pal::as_hex_string(buf);
    ASSERT_TEST(str == "");
}
Esempio n. 19
0
int test_doremove(){
	Lock_list<int> list;
	Node<int>* node;
	for (int i = 0; i < 10; i++){
		list.insertLast(i);
	}
	// 0, ... , 9

	node = list.lockFirst();
	list.unlockCurrent(node);
	node = list.lockNext(node);
	list.unlockCurrent(node);
	node = list.lockNext(node); // should point to 2
	ASSERT_TEST(**node == 2);
	// 0,1,3...,9
	node=list.doRemove(node);
	ASSERT_TEST(**node == 1);
	node = list.lockNext(node);
	ASSERT_TEST(**node == 3);
	list.unlockCurrent(node);
	
	node = list.lockLast();
	ASSERT_TEST(**node == 9);
	node = list.lockPrev(node);
	ASSERT_TEST(**node == 8);
	list.unlockNext(node);
	list.unlockCurrent(node);
	// 0,1,3,..,7,9
	node=list.doRemove(node);
	ASSERT_TEST(**node == 7);
	node = list.lockNext(node);
	ASSERT_TEST(**node == 9);
	list.unlockCurrent(node);

	node = list.lockFirst();
	ASSERT_TEST(**node == 0);
	node = list.doRemove(node);
	ASSERT_TEST(node==NULL);

	node = list.lockFirst();
	ASSERT_TEST(**node == 1);
	list.unlockCurrent(node);

	return 1;



}
static ssize_t _thsafe_zmq_client_recv_read (smio_t *self, uint8_t *data,
        uint32_t size)
{
    ssize_t ret_size = -1;

    /* Returns NULL if confirmation was not OK or in case of error.
     * Returns the original message if the confirmation was OK */
    zmsg_t *recv_msg = _thsafe_zmq_client_recv_confirmation (self);
    ASSERT_TEST(recv_msg != NULL, "Could not receive confirmation code", err_null_recv_msg);

    /* If we are here, confirmation code was OK. Check for second frame */
    zframe_t *reply_frame = zmsg_pop (recv_msg);
    zframe_destroy (&reply_frame); /* Don't do anything with the reply code */

    zframe_t *return_frame = zmsg_pop (recv_msg);
    ASSERT_TEST(return_frame != NULL, "Could not receive retrurn code", err_null_ret_code_frame);

    if (zframe_size (return_frame) != THSAFE_RETURN_SIZE) {
        DBE_DEBUG (DBG_MSG | DBG_LVL_ERR, "[smio_thsafe_client:zmq] Return frame size is wrong\n");
        goto err_wrong_size_ret_frame;
    }

    zframe_t *data_frame = zmsg_pop (recv_msg);
    ASSERT_TEST(data_frame != NULL, "Could not receive data", err_recv_data);

    /* Check if the frame has the number of bytes requested.
     * For now, we consider a success only when the number of
     * bytes requested is the same as the actually read*/
    if ((ssize_t) zframe_size (data_frame) != *(THSAFE_RETURN_TYPE *) zframe_data (return_frame)) {
        DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Data frame size is wrong\n");
        goto err_recv_data;
    }

    uint8_t* raw_data = (uint8_t *) zframe_data (data_frame);
    memcpy (data, raw_data, size);
    ret_size = size;

    DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Received data successfully\n");

    zframe_destroy (&data_frame);
err_recv_data:
err_wrong_size_ret_frame:
    zframe_destroy (&return_frame);
err_null_ret_code_frame:
    zmsg_destroy (&recv_msg);
err_null_recv_msg:
    return ret_size;
}
Esempio n. 21
0
/**************** Helper Functions ***************/
static devio_err_e _devio_do_smio_op (devio_t *self, void *msg)
{
    zmq_server_args_t *server_args = (zmq_server_args_t *) msg;
    /* Message is:
     * frame 0: opcode
     * frame 1: payload */
    /* Extract the first frame and determine the opcode */
    zframe_t *opcode = zmsg_pop (*server_args->msg);
    devio_err_e err = (opcode == NULL) ? DEVIO_ERR_BAD_MSG : DEVIO_SUCCESS;
    ASSERT_TEST(opcode != NULL, "Could not receive opcode", err_null_opcode);

    if (zframe_size (opcode) != THSAFE_OPCODE_SIZE) {
        DBE_DEBUG (DBG_DEV_IO | DBG_LVL_ERR,
                "[dev_io_core:poll_all_sm] Invalid opcode size received\n");
        err = DEVIO_ERR_BAD_MSG;
        goto err_wrong_opcode_size;
    }

    uint32_t opcode_data = *(uint32_t *) zframe_data (opcode);
    if (opcode_data > THSAFE_OPCODE_END-1) {
        DBE_DEBUG (DBG_DEV_IO | DBG_LVL_ERR,
                "[dev_io_core:poll_all_sm] Invalid opcode received\n");
        err = DEVIO_ERR_BAD_MSG;
        goto err_invalid_opcode;
    }

    /* Do the actual work... */
    disp_table_call (self->disp_table_thsafe_ops, opcode_data, self, server_args);

err_invalid_opcode:
err_wrong_opcode_size:
    zframe_destroy (&opcode);
err_null_opcode:
    return err;
}
Esempio n. 22
0
/* Creates a new instance of the SMCH PCA9547 */
smch_pca9547_t * smch_pca9547_new (smio_t *parent, uint64_t base, uint32_t addr,
        int verbose)
{
    (void) verbose;
    assert (parent);

    smch_pca9547_t *self = (smch_pca9547_t *) zmalloc (sizeof *self);
    ASSERT_ALLOC(self, err_self_alloc);

    self->i2c = smpr_new (SMCH_PCA9547_NAME, parent, SMPR_I2C, verbose);
    ASSERT_ALLOC(self->i2c, err_i2c_alloc);

    /* Initalize the I2C protocol */
    int smpr_err = smpr_open (self->i2c, base, NULL /* Default parameters are fine */);
    ASSERT_TEST(smpr_err == 0, "Could not initialize SMPR protocol", err_smpr_init);

    self->addr = addr;

    DBE_DEBUG (DBG_SM_CH | DBG_LVL_INFO, "[sm_ch:pca9547] Created instance of SMCH\n");
    return self;

err_smpr_init:
    smpr_destroy (&self->i2c);
err_i2c_alloc:
    free (self);
err_self_alloc:
    return NULL;
}
Esempio n. 23
0
static halutils_err_e _disp_table_insert (disp_table_t *self, uint32_t key,
        disp_table_func_fp func_fp)
{
    if (func_fp == NULL) {
        return HALUTILS_ERR_NULL_POINTER;
    }

    DBE_DEBUG (DBG_HAL_UTILS | DBG_LVL_TRACE,
            "[halutils:disp_table] Registering function (%p) opcode (%u) into dispatch table\n",
            func_fp, key);

    func_fp_wrapper_t *func_fp_wrapper = zmalloc (sizeof *func_fp_wrapper);
    ASSERT_ALLOC (func_fp_wrapper, err_func_wrapper_alloc);

    /* Initialize func_p_wrapper struct */
    func_fp_wrapper->func_fp = func_fp;

    char *key_c = halutils_stringify_key (key);
    ASSERT_ALLOC (key_c, err_key_c_alloc);
    int zerr = zhash_insert (self->table_h, key_c, func_fp_wrapper);
    ASSERT_TEST(zerr == 0, "Could not insert item into dispatch table", err_insert_hash);
    /* Setup free function */
    zhash_freefn (self->table_h, key_c, _disp_table_free_item);

    free (key_c);
    return HALUTILS_SUCCESS;

err_insert_hash:
    free (key_c);
err_key_c_alloc:
    free (func_fp_wrapper);
err_func_wrapper_alloc:
    return HALUTILS_ERR_ALLOC;
}
Esempio n. 24
0
int test_insertion2(){
	Lock_list<int> list;
	Node<int>* node;
	for (int i = 0; i < 10; i++){
		list.insertFirst(i);
	}
	list.iterFirst(&node);
	for (int i = 9; i >=0; i--){
		ASSERT_TEST(**node== i);
		list.iterNext(&node);
	}

	ASSERT_TEST(node==NULL);
	
	return 1;
}
/* TODO: Avoid exporting the functions before we have initialized
 * our server with the default values */
smio_err_e trigger_iface_config_defaults (char *broker_endp, char *service,
       const char *log_file_name)
{
    (void) log_file_name;
    DBE_DEBUG (DBG_SM_IO | DBG_LVL_INFO, "[sm_io:trigger_iface_defaults] Configuring SMIO "
            "TRIGGER_IFACE with default values ...\n");
    bpm_client_err_e client_err = BPM_CLIENT_SUCCESS;
    smio_err_e err = SMIO_SUCCESS;

    bpm_client_t *config_client = bpm_client_new_log_mode (broker_endp, 0,
            log_file_name, SMIO_TRIGGER_IFACE_LIBBPMCLIENT_LOG_MODE);
    ASSERT_ALLOC(config_client, err_alloc_client);

    uint32_t chan;
    for (chan = 0; chan < SMIO_TRIGGER_IFACE_MAX_CHAN; ++chan) {
        client_err = bpm_set_trigger_dir (config_client, service, chan, TRIGGER_IFACE_DFLT_DIR);
        client_err |= bpm_set_trigger_dir_pol (config_client, service, chan, TRIGGER_IFACE_DFLT_DIR_POL);
        client_err |= bpm_set_trigger_rcv_count_rst (config_client, service, chan, TRIGGER_IFACE_DFLT_RCV_RST);
        client_err |= bpm_set_trigger_transm_count_rst (config_client, service, chan, TRIGGER_IFACE_DFLT_TRANSM_RST);
        client_err |= bpm_set_trigger_rcv_len (config_client, service, chan, TRIGGER_IFACE_DFLT_RCV_LEN);
        client_err |= bpm_set_trigger_transm_len (config_client, service, chan, TRIGGER_IFACE_DFLT_TRANSM_LEN);
    }

    ASSERT_TEST(client_err == BPM_CLIENT_SUCCESS, "Could set trigger defaults",
            err_param_set, SMIO_ERR_CONFIG_DFLT);

err_param_set:
    bpm_client_destroy (&config_client);
err_alloc_client:
    DBE_DEBUG (DBG_SM_IO | DBG_LVL_INFO, "[sm_io:trigger_iface_defaults] Exiting Config thread %s\n",
        service);
    return err;
}
Esempio n. 26
0
/* Creates a new instance of the SMCH RFFE */
smch_rffe_t * smch_rffe_new (smio_t *parent, int verbose)
{
    (void) verbose;
    assert (parent);

    smch_rffe_t *self = (smch_rffe_t *) zmalloc (sizeof *self);
    ASSERT_ALLOC(self, err_self_alloc);

    self->bsmp = smpr_new (SMCH_RFFE_NAME, parent, SMPR_BSMP, verbose);
    ASSERT_ALLOC(self->bsmp, err_bsmp_alloc);

    /* Initalize the BSMP protocol */
    int smpr_err = smpr_open (self->bsmp, 0, NULL /* Default parameters are fine */);
    ASSERT_TEST(smpr_err == 0, "Could not initialize SMPR protocol", err_smpr_init);

    DBE_DEBUG (DBG_SM_CH | DBG_LVL_INFO, "[sm_ch:rffe] Created instance of SMCH\n");
    return self;

err_smpr_init:
    smpr_destroy (&self->bsmp);
err_bsmp_alloc:
    free (self);
err_self_alloc:
    return NULL;
}
/**** Write data block from device function pointer, size in bytes ****/
ssize_t thsafe_zmq_client_write_block (smio_t *self, loff_t offs, size_t size, const uint32_t *data)
{
    assert (self);
    ssize_t ret_size = -1;
    zmsg_t *send_msg = zmsg_new ();
    ASSERT_ALLOC(send_msg, err_msg_alloc);
    uint32_t opcode = THSAFE_WRITE_BLOCK;

    DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Calling thsafe_write_block\n");

    /* Message is:
     * frame 0: WRITE_BLOCK opcode
     * frame 1: offset
     * frame 2: data to be written
     * */
    int zerr = zmsg_addmem (send_msg, &opcode, sizeof (opcode));
    ASSERT_TEST(zerr == 0, "Could not add WRITE opcode in message",
            err_add_opcode);
    zerr = zmsg_addmem (send_msg, &offs, sizeof (offs));
    ASSERT_TEST(zerr == 0, "Could not add offset in message",
            err_add_offset);
    zerr = zmsg_addmem (send_msg, data, size);
    ASSERT_TEST(zerr == 0, "Could not add data in message",
            err_add_data);

    DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Sending message:\n");
#ifdef LOCAL_MSG_DBG
    zmsg_print (send_msg);
#endif

    zerr = zmsg_send (&send_msg, self->pipe);
    ASSERT_TEST(zerr == 0, "Could not send message", err_send_msg);

    /* Message is:
     * frame 0: reply code
     * frame 1: return code */
    ret_size = _thsafe_zmq_client_recv_write (self);

err_send_msg:
err_add_data:
err_add_offset:
err_add_opcode:
    zmsg_destroy (&send_msg);
err_msg_alloc:
    return ret_size;
}
/**** Read data block from device function pointer, size in bytes ****/
ssize_t thsafe_zmq_client_read_block (smio_t *self, loff_t offs, size_t size, uint32_t *data)
{
    assert (self);
    ssize_t ret_size = -1;
    zmsg_t *send_msg = zmsg_new ();
    ASSERT_ALLOC(send_msg, err_msg_alloc);
    uint32_t opcode = THSAFE_READ_BLOCK;

    DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Calling thsafe_read_block\n");

    /* Message is:
     * frame 0: READ_BLOCK opcode
     * frame 1: offset
     * frame 2: number of bytes to be read */
    int zerr = zmsg_addmem (send_msg, &opcode, sizeof (opcode));
    ASSERT_TEST(zerr == 0, "Could not add READ opcode in message",
            err_add_opcode);
    zerr = zmsg_addmem (send_msg, &offs, sizeof (offs));
    ASSERT_TEST(zerr == 0, "Could not add offset in message",
            err_add_offset);
    zerr = zmsg_addmem (send_msg, &size, sizeof (size));
    ASSERT_TEST(zerr == 0, "Could not add size in message",
            err_add_size);

    DBE_DEBUG (DBG_MSG | DBG_LVL_TRACE, "[smio_thsafe_client:zmq] Sending message:\n");
#ifdef LOCAL_MSG_DBG
    zmsg_print (send_msg);
#endif

    zerr = zmsg_send (&send_msg, self->pipe);
    ASSERT_TEST(zerr == 0, "Could not send message", err_send_msg);

    /* Message is:
     * frame 0: reply code
     * frame 1: return code
     * frame 2: data */
    ret_size = _thsafe_zmq_client_recv_read (self, (uint8_t *) data, size);

err_send_msg:
err_add_size:
err_add_offset:
err_add_opcode:
    zmsg_destroy (&send_msg);
err_msg_alloc:
    return ret_size;
}
Esempio n. 29
0
static bool testClientsManagerAddClient(){
	Email email = NULL;
	emailCreate("baba@ganosh", &email);
	ClientsManager manager = clientsManagerCreate();
	ASSERT_TEST( clientsManagerAdd( NULL, email, 1, 1, 200) ==
			CLIENT_MANAGER_NULL_PARAMETERS);
	ASSERT_TEST( clientsManagerAdd( manager, NULL, 1, 1, 200) ==
			CLIENT_MANAGER_NULL_PARAMETERS);

	ASSERT_TEST( clientsManagerAdd( manager, email, -2, 1, 200) ==
			CLIENT_MANAGER_INVALID_PARAMETERS);
	ASSERT_TEST( clientsManagerAdd( manager, email, 1, 0, 200) ==
			CLIENT_MANAGER_INVALID_PARAMETERS);
	ASSERT_TEST( clientsManagerAdd( manager, email, 1, 1, -9) ==
			CLIENT_MANAGER_INVALID_PARAMETERS);


	ASSERT_TEST( clientsManagerAdd( manager, email, 1, 1, 200) ==
				CLIENT_MANAGER_SUCCESS);

	ASSERT_TEST( clientsManagerAdd( manager, email, 1, 1, 200) ==
			CLIENT_MANAGER_ALREADY_EXISTS);

	emailDestroy(email);
	clientsManagerDestroy(manager);
	return true;
}
Esempio n. 30
0
static bpm_client_err_e _bpm_data_acquire (bpm_client_t *self, char *service,
        acq_req_t *acq_req)
{
    assert (self);
    assert (service);
    assert (acq_req);

    bpm_client_err_e err = BPM_CLIENT_SUCCESS;
    ACQ_OPCODE_TYPE operation = ACQ_OPCODE_DATA_ACQUIRE;

    /* Message is:
     * frame 0: operation code
     * frame 1: number of samples
     * frame 2: channel             */
    zmsg_t *request = zmsg_new ();
    zmsg_addmem (request, &operation, sizeof (operation));
    zmsg_addmem (request, &acq_req->num_samples, sizeof (acq_req->num_samples));
    zmsg_addmem (request, &acq_req->chan, sizeof (acq_req->chan));
    mdp_client_send (self->mdp_client, service, &request);

    /* Receive report */
    zmsg_t *report = mdp_client_recv (self->mdp_client, NULL, NULL);
    ASSERT_TEST(report != NULL, "Report received is NULL", err_null_report);
    assert (zmsg_size (report) == 1);

    /* Message is:
     * frame 0: error code      */
    zframe_t *err_code = zmsg_pop(report);
    ASSERT_TEST(err_code != NULL, "Could not receive error code", err_null_code);
    if ( *(ACQ_REPLY_TYPE *) zframe_data(err_code) != ACQ_OK) {
        DBE_DEBUG (DBG_LIB_CLIENT | DBG_LVL_TRACE, "[libclient] bpm_data_acquire: "
                "Data acquire was not required correctly\n");
        err = BPM_CLIENT_ERR_AGAIN;
        goto err_data_acquire;
    }
    DBE_DEBUG (DBG_LIB_CLIENT | DBG_LVL_TRACE, "[libclient] bpm_data_acquire: "
            "Data acquire was successfully required\n");

err_data_acquire:
    zframe_destroy (&err_code);
err_null_code:
    zmsg_destroy (&report);
err_null_report:
    return err;
}