예제 #1
0
파일: list.c 프로젝트: alobbs/libchula
int
list_add (void)
{
    ret_t        ret;
    size_t       s1, s2;
    chula_list_t list    = LIST_HEAD_INIT(list);

    for (int i=0; i<10; i++) {
        /* Add a new list entry */
        chula_list_get_len (&list, &s1);
        ret = chula_list_content_add (&list, INT_TO_POINTER(i));
        chula_list_get_len (&list, &s2);

        /* Check return code */
        assert (((ret == ret_ok) && (s2 > s1)) ||
                ((ret == ret_nomem) && (s2 <= s1)));
    }

    chula_list_content_free (&list, NULL);

    for (int i=0; i<10; i++) {
        /* Add a new list entry */
        chula_list_get_len (&list, &s1);
        ret = chula_list_content_add_tail (&list, INT_TO_POINTER(100 + i));
        chula_list_get_len (&list, &s2);

        /* Check return code */
        assert (((ret == ret_ok) && (s2 > s1)) ||
                ((ret == ret_nomem) && (s2 <= s1)));
    }

    chula_list_content_free (&list, NULL);

    return 0;
}
예제 #2
0
파일: avl_test.c 프로젝트: alobbs/libchula
END_TEST

START_TEST (len)
{
    ret_t       ret;
    size_t      len;
    chula_avl_t avl;

    /* None */
    chula_avl_init (&avl);
    ch_assert (chula_avl_is_empty (AVL_GENERIC(&avl)));

    ret = chula_avl_len (AVL_GENERIC(&avl), &len);
    ch_assert (ret == ret_ok);
    ch_assert (len == 0);

    /* Single */
    chula_avl_add_ptr (&avl, "uno", INT_TO_POINTER(1));
    ch_assert (ret == ret_ok);
    ch_assert (! chula_avl_is_empty (AVL_GENERIC(&avl)));

    chula_avl_len (AVL_GENERIC(&avl), &len);
    ch_assert (len == 1);

    /* Multiple */
    chula_avl_add_ptr (&avl, "dos", INT_TO_POINTER(2));
    ch_assert (ret == ret_ok);
    ch_assert (! chula_avl_is_empty (AVL_GENERIC(&avl)));

    chula_avl_len (AVL_GENERIC(&avl), &len);
    ch_assert (len == 2);

    chula_avl_mrproper (AVL_GENERIC(&avl), NULL);
}
예제 #3
0
파일: test-list.c 프로젝트: lubomir/stest
void test_list_foreach(void)
{
    List *l = list_prepend(NULL, INT_TO_POINTER(1));
    l = list_prepend(l, INT_TO_POINTER(2));
    l = list_prepend(l, INT_TO_POINTER(3));

    int sum = 0;
    list_foreach(l, foreach_cb, &sum);
    cut_assert_equal_int(6, sum);
}
예제 #4
0
파일: test-list.c 프로젝트: lubomir/stest
void
test_two_appends(void)
{
    List *l = list_append(NULL, INT_TO_POINTER(1));
    cut_assert_not_null(l);
    cut_assert_null(l->next);
    cut_assert_equal_pointer(INT_TO_POINTER(1), l->data);

    l = list_append(l, INT_TO_POINTER(2));
    cut_assert_equal_pointer(INT_TO_POINTER(1), l->data);
    cut_assert_not_null(l->next);
    cut_assert_equal_pointer(INT_TO_POINTER(2), l->next->data);
    cut_assert_null(l->next->next);
}
예제 #5
0
static void sx9500_thread_main(int arg1, int unused)
{
	struct device *dev = INT_TO_POINTER(arg1);
	struct sx9500_data *data = dev->driver_data;
	uint8_t reg_val;

	ARG_UNUSED(unused);

	while (1) {
		k_sem_take(&data->sem, K_FOREVER);

		if (i2c_reg_read_byte(data->i2c_master, data->i2c_slave_addr,
					SX9500_REG_IRQ_SRC, &reg_val) < 0) {
			SYS_LOG_DBG("sx9500: error %d reading IRQ source register", ret);
			continue;
		}

		if ((reg_val & SX9500_CONV_DONE_IRQ) && data->handler_drdy) {
			data->handler_drdy(dev, &data->trigger_drdy);
		}

		if ((reg_val & SX9500_NEAR_FAR_IRQ) && data->handler_near_far) {
			data->handler_near_far(dev, &data->trigger_near_far);
		}
	}
}
예제 #6
0
파일: avl_test.c 프로젝트: alobbs/libchula
END_TEST

START_TEST (_buf)
{
    ret_t           ret;
    void           *p;
    chula_avl_t     avl;
    chula_buffer_t  uno  = CHULA_BUF_INIT;
    chula_buffer_t  dos  = CHULA_BUF_INIT;
    chula_buffer_t  tres = CHULA_BUF_INIT;

    chula_avl_init (&avl);
    chula_buffer_add_str (&uno,  "uno");
    chula_buffer_add_str (&dos,  "dos");
    chula_buffer_add_str (&tres, "tres");

    ret = chula_avl_add (&avl, &uno, INT_TO_POINTER(1));
    ch_assert (ret == ret_ok);
    ret = chula_avl_add (&avl, &dos, INT_TO_POINTER(2));
    ch_assert (ret == ret_ok);
    ret = chula_avl_add (&avl, &tres, INT_TO_POINTER(3));
    ch_assert (ret == ret_ok);

    chula_avl_get (&avl, &dos, &p);
    ch_assert (POINTER_TO_INT(p) == 2);
    chula_avl_get (&avl, &tres, &p);
    ch_assert (POINTER_TO_INT(p) == 3);
    chula_avl_get (&avl, &uno, &p);
    ch_assert (POINTER_TO_INT(p) == 1);

    chula_avl_del (&avl, &dos, NULL);
    chula_avl_get (&avl, &uno, &p);
    ch_assert (POINTER_TO_INT(p) == 1);

    p = NULL;
    ret = chula_avl_get (&avl, &dos, &p);
    ch_assert (ret != ret_ok);
    ch_assert (p == NULL);

    ret = chula_avl_check (AVL_GENERIC(&avl));
    ch_assert (ret == ret_ok);

    chula_buffer_mrproper (&uno);
    chula_buffer_mrproper (&dos);
    chula_buffer_mrproper (&tres);
    chula_avl_mrproper (AVL_GENERIC(&avl), NULL);
}
예제 #7
0
파일: perfx-main.c 프로젝트: chergert/perfx
static void
PerfxMain_AddPending(PerfxMainHandler *handler) /* IN */
{
   ASSERT(handler);

   gPending = PerfxList_Prepend(gPending, INT_TO_POINTER(handler->id));
   PerfxMain_Wakeup();
}
예제 #8
0
파일: avl_test.c 프로젝트: alobbs/libchula
END_TEST

START_TEST (_ptr)
{
    ret_t        ret;
    void        *p;
    chula_avl_t  avl;

    chula_avl_init (&avl);

    ret = chula_avl_add_ptr (&avl, "uno", INT_TO_POINTER(1));
    ch_assert (ret == ret_ok);
    ret = chula_avl_add_ptr (&avl, "dos", INT_TO_POINTER(2));
    ch_assert (ret == ret_ok);
    ret = chula_avl_add_ptr (&avl, "tres", INT_TO_POINTER(3));
    ch_assert (ret == ret_ok);

    chula_avl_get_ptr (&avl, "dos", &p);
    ch_assert (POINTER_TO_INT(p) == 2);
    chula_avl_get_ptr (&avl, "tres", &p);
    ch_assert (POINTER_TO_INT(p) == 3);
    chula_avl_get_ptr (&avl, "uno", &p);
    ch_assert (POINTER_TO_INT(p) == 1);

    chula_avl_set_case (&avl, true);
    chula_avl_get_ptr (&avl, "TrEs", &p);
    ch_assert (POINTER_TO_INT(p) == 3);
    chula_avl_set_case (&avl, false);

    chula_avl_del_ptr (&avl, "dos", NULL);
    chula_avl_get_ptr (&avl, "uno", &p);
    ch_assert (POINTER_TO_INT(p) == 1);

    p = NULL;
    ret = chula_avl_get_ptr (&avl, "dos", &p);
    ch_assert (ret != ret_ok);
    ch_assert (p == NULL);

    ret = chula_avl_check (AVL_GENERIC(&avl));
    ch_assert (ret == ret_ok);

    chula_avl_mrproper (AVL_GENERIC(&avl), NULL);
}
예제 #9
0
int net_context_tcp_send(struct net_buf *buf)
{
	/* Prepare data to be sent */
	process_post_synch(&ip_buf_context(buf)->tcp,
			   tcpip_event,
			   INT_TO_POINTER(TCP_WRITE_EVENT),
			   buf);


	return ip_buf_sent_status(buf);
}
예제 #10
0
static void tmp007_fiber(int dev_ptr, int unused)
{
	struct device *dev = INT_TO_POINTER(dev_ptr);
	struct tmp007_data *drv_data = dev->driver_data;

	ARG_UNUSED(unused);

	while (1) {
		nano_fiber_sem_take(&drv_data->gpio_sem, TICKS_UNLIMITED);
		tmp007_fiber_cb(dev);
	}
}
예제 #11
0
static void lis2ds12_thread(int dev_ptr, int unused)
{
	struct device *dev = INT_TO_POINTER(dev_ptr);
	struct lis2ds12_data *data = dev->driver_data;

	ARG_UNUSED(unused);

	while (1) {
		k_sem_take(&data->trig_sem, K_FOREVER);
		lis2ds12_handle_int(dev);
	}
}
예제 #12
0
static void lis2dw12_thread(int dev_ptr, int unused)
{
	struct device *dev = INT_TO_POINTER(dev_ptr);
	struct lis2dw12_data *lis2dw12 = dev->driver_data;

	ARG_UNUSED(unused);

	while (1) {
		k_sem_take(&lis2dw12->gpio_sem, K_FOREVER);
		lis2dw12_handle_interrupt(dev);
	}
}
예제 #13
0
static void mpu6050_thread(int dev_ptr, int unused)
{
	struct device *dev = INT_TO_POINTER(dev_ptr);
	struct mpu6050_data *drv_data = dev->driver_data;

	ARG_UNUSED(unused);

	while (1) {
		k_sem_take(&drv_data->gpio_sem, K_FOREVER);
		mpu6050_thread_cb(dev);
	}
}
예제 #14
0
const char *
PerfxQuark_ToString(PerfxQuark quark) /* IN */
{
   PerfxQuarkEntry *entry;

   ASSERT(gQuarks);

   pthread_rwlock_rdlock(&gRWLock);
   entry = PerfxHashTable_Lookup(gQuarks, INT_TO_POINTER(quark));
   pthread_rwlock_unlock(&gRWLock);

   return entry ? entry->string : NULL;
}
예제 #15
0
static void _gpio_sch_poll_status(int data, int unused)
{
	struct device *dev = INT_TO_POINTER(data);
	struct gpio_sch_config *info = dev->config->config_info;
	struct gpio_sch_data *gpio = dev->driver_data;

	ARG_UNUSED(unused);

	/* Cleaning up GTS first */
	_write_gts(_read_gts(info->regs), info->regs);

	while (gpio->poll) {
		uint32_t status;

		if (!gpio->callback) {
			goto loop;
		}

		status = _read_gts(info->regs);
		if (!status) {
			goto loop;
		}

		if (gpio->port_cb) {
			gpio->callback(dev, status);
			goto ack;
		}

		if (gpio->cb_enabled) {
			uint32_t valid_int = status & gpio->cb_enabled;
			int i;

			for (i = 0; i < info->bits; i++) {
				if (valid_int & BIT(i)) {
					gpio->callback(dev, i);
				}
			}
		}
ack:
		/* It's not documented but writing the same status value
		 * into GTS tells to the controller it got handled.
		 */
		_write_gts(status, info->regs);
loop:
		nano_fiber_timer_start(&gpio->poll_timer,
				       GPIO_SCH_POLLING_TICKS);
		nano_fiber_timer_test(&gpio->poll_timer, TICKS_UNLIMITED);
	}
}
예제 #16
0
int
main (int   argc,   /* IN */
      char *argv[]) /* IN */
{
   PerfxHashTable *hashtable;
   uint32_t i;

   hashtable = PerfxHashTable_Create(1024,
                                     perfx_direct_hash,
                                     perfx_direct_equal,
                                     NULL,
                                     NULL);
   for (i = 0; i < 100000; i++) {
      PerfxHashTable_Insert(hashtable, INT_TO_POINTER(i), INT_TO_POINTER(i));
   }
   ASSERT_INT(PerfxHashTable_CountKeys(hashtable), ==, 100000);
   for (i = 0; i < 100000; i++) {
      ASSERT(PerfxHashTable_Contains(hashtable, INT_TO_POINTER(i)));
   }
   ASSERT(!PerfxHashTable_Contains(hashtable, INT_TO_POINTER(100001)));
   PerfxHashTable_Free(hashtable);

   return 0;
}
예제 #17
0
static void arbiter_conn_cb(struct ev_loop *l,struct ev_io *watcher,int revents){
    zero_arbiter_thread *th = watcher->data;
    int cfd;
    if((cfd = accept(th->sockfd,NULL,NULL)) == -1){
        perror("accept error");
        return;
    }
    sock_set_non_block(cfd);
    int idx;
    idx = (th->last_thread + 1) % (th->server->worker_len);
    th->last_thread = idx;
    zero_worker_thread *worker = th->server->ze_workers + idx;
    zero_queue_push(worker->queue,INT_TO_POINTER(cfd));
    uint64_t n = 1;
    write(worker->notify_fd,&n,sizeof(n));
}
예제 #18
0
파일: dirent.c 프로젝트: julp/ugrep
int fchdir(void *x, int fd)
{
    void *ptr;

    if (hashtable_get(HT_FROM_P(x), INT_TO_POINTER(fd), &ptr)) {
        if (NULL == ptr) {
            // errno ?
            return -1;
        } else {
            return chdir(ptr);
        }
    } else {
        // errno ?
        return -1;
    }
}
예제 #19
0
int main(int argc , char ** argv){
	printf("test client begin!\n");	
	rpc_client *client = rpc_client_new();
	rpc_client_connect(client,"127.0.0.1",8778);
	printf("test client started success!");
	
	pointer output;
	size_t len;
	char input[256];
	int i, result;

	rpc_code code;

	for (i = 0; i < 10000; i++) {
		len = sprintf(input, "%d %d", i, i + 1);
		printf("call!\n");
		code = rpc_client_call(client, "TestService", "add", input, strlen(
				input) + 1, &output, &len);
		if (code != RPC_OK) {
			printf("call error %s\n", rpc_code_format(code));
			exit(1);
		}
		result = *(int*) output;
		if (result != (2 * i + 1)) {
			printf("i is %d,result:%d should %d\n", i, result, 2 * i + 1);
			exit(1);
		}
		printf("result:%d\n", result);
	}
	int j;
	for (j = 0; j < 10; j++) {
		for (i = 0; i < 10000; i++) {
			len = sprintf(input, "%d %d", i, i + 1);
			rpc_client_call_async(client, "TestService", "add", strdup(input),
					strlen(input) + 1, cb_add, INT_TO_POINTER(i));
		}
    rpc_sleep(1000);
	}

	printf("test ok\n");
	for (;;) {
		rpc_sleep(1000);
	}
	return EXIT_SUCCESS;
}
예제 #20
0
static void cb_dispatch_conn(struct ev_loop *l, struct ev_io *watcher,
		int revents) {
	rpc_dispatch_thread *th = watcher->data;
	int cfd;
	if ((cfd = accept(th->sock_fd, NULL, NULL)) == -1) {
		//check errno
		perror("accept conn error");
		return;
	}
	rpc_set_non_block(cfd);
	//rrd thread
	int idx;
	idx = (th->last_thread + 1) % (th->server->worker_len);
	th->last_thread = idx;
	rpc_worker_thread *worker = th->server->th_workers + idx;
	//notify
	rpc_queue_push(worker->queue, INT_TO_POINTER(cfd));
	uint64_t n = 1;
	write(worker->notify_fd, &n, sizeof(n));
}
예제 #21
0
파일: test-list.c 프로젝트: lubomir/stest
void
test_reverse_list(void)
{
    List *l = list_prepend(NULL, INT_TO_POINTER(1));
    l = list_prepend(l, INT_TO_POINTER(2));
    l = list_prepend(l, INT_TO_POINTER(3));

    l = list_reverse(l);

    cut_assert_not_null(l);
    cut_assert_equal_pointer(INT_TO_POINTER(1), l->data);
    cut_assert_not_null(l->next);
    cut_assert_equal_pointer(INT_TO_POINTER(2), l->next->data);
    cut_assert_not_null(l->next->next);
    cut_assert_equal_pointer(INT_TO_POINTER(3), l->next->next->data);
    cut_assert_null(l->next->next->next);
}