Exemplo n.º 1
0
} END_TEST

// Ensure a single value can be prepended and then shfited off one
// ✔ Data should be as expected
// ✔ Size should be 0 
START_TEST (test_prepend_1_shift_1_list) {
  kld_list_t * list = (kld_list_t *) new_list();
  char * buf = "test data";

  list_prepend(list, buf);
  list_shift(list);

  fail_if(list->size != 0, "Unexpected list size");
  fail_if(!list_is_empty(list), "List doesn't report as empty");
} END_TEST
Exemplo n.º 2
0
Arquivo: eval.c Projeto: samsonjs/lake
static LakeVal *_define(LakeCtx *ctx, Env *env, LakeList *expr)
{
  /* TODO: make these more robust, check all expected params */

  /* (define x 42) */
  if (LIST_N(expr) == 3 && lake_is_type(TYPE_SYM, LIST_VAL(expr, 1))) {
    list_shift(expr); /* drop the "define" symbol */
    LakeSym *var = SYM(list_shift(expr));
    LakeVal *form = list_shift(expr);
    env_define(env, var, eval(ctx, env, form));
  }

  /* (define (inc x) (+ 1 x)) */
  else if (LIST_N(expr) >= 3 && lake_is_type(TYPE_LIST, LIST_VAL(expr, 1))) {
    list_shift(expr); /* drop the "define" symbol */
    LakeList *params = LIST(list_shift(expr));
    LakeSym *var = SYM(list_shift(params));
    LakeList *body = expr;
    env_define(env, var, VAL(fn_make(params, NULL, body, env)));
  }

  /* (define (print format . args) (...)) */
  else if (LIST_N(expr) >= 3 && lake_is_type(TYPE_DLIST, LIST_VAL(expr, 1))) {
    list_shift(expr); /* drop the "define" symbol */
    LakeDottedList *def = DLIST(list_shift(expr));
    LakeList *params = dlist_head(def);
    LakeSym *varargs = SYM(dlist_tail(def));
    LakeSym *var = SYM(list_shift(params));
    LakeList *body = expr;
    env_define(env, var, VAL(fn_make(params, varargs, body, env)));
  }

  else {
    invalid_special_form(expr, "define requires at least 2 parameters");
  }

  return NULL;
}
Exemplo n.º 3
0
static void quote_stats(irc_t *irc, const char *channel, const char *user, list_t *list) {
    const char *who = list_shift(list);
    if (!who) {
        int count   = quote_length();
        int request = database_request_count(irc, "QUOTES");

        return irc_write(irc, channel, "%s: quote stats -> %d quotes -> requested %d times", user, count, request);
    }

    int count = 0;
    if (!quote_count(who, &count))
        return irc_write(irc, channel, "%s: %s has no quotes", user, who);

    const char *plural = (count > 1) ? "quotes" : "quote";
    if (strcmp(user, who))
        irc_write(irc, channel, "%s: %s has %d %s", user, who, count, plural);
    else
        irc_write(irc, channel, "%s: you have %d %s", user, count, plural);
}
Exemplo n.º 4
0
} END_TEST

// Ensure that shifting off a list returns the expected data.
// ✔ Head should be updated
// ✔ Tail should be updated
// ✔ Data should be the same
START_TEST (test_shift_list) {
  kld_list_t * list = (kld_list_t *) new_list();
  char * buf = "test data";
  char * buf2 = "test data2";

  list_append(list, buf);
  list_append(list, buf2);
  
  kld_list_node_t * tmp = (kld_list_node_t *) list_shift(list);

  fail_if(tmp == NULL, "Returned value is null");
  fail_if(tmp->data != "test data", "Unexpected data value for returned list node");  
} END_TEST
Exemplo n.º 5
0
int list_append( list_t *list_in, void *val_in )
{
	/* If there isn't enough memory allocated */
	if( list_in->size + 1 > list_in->alloc )
	{
		if( list_grow( list_in, LIST_SIZE_INC ) == -1 )
			return -1;
	}
	else /* If there is enough, then either there is some at the beginning or some at the end */
	{
		if( (byte_t*)list_in->start > (byte_t*)list_in->pointer )
			if( list_shift( list_in, -1 ) == -1 )
				return -1;
	}

	bcopy( val_in, (byte_t*) list_in->start + list_in->size * list_in->step, list_in->step );
	++list_in->size;
	return list_in->size;
}
Exemplo n.º 6
0
// get the next element without actually removing it from the queeue.
int peekQueue(simplequeue_t *msgqueue, void **data, int *size)
{
	simplewrapper_t *swrap;

	pthread_mutex_lock(&(msgqueue->qlock));

	if (msgqueue->cursize <= 0)
	{
		*size = 0;
		*data = NULL;
		pthread_mutex_unlock(&(msgqueue->qlock));
		return EXIT_FAILURE;
	} else
	{
		swrap = list_shift(msgqueue->queue);
		*size = swrap->size;
		*data = &(swrap->data);
		list_unshift(msgqueue->queue, swrap);
		pthread_mutex_unlock(&(msgqueue->qlock));
		return EXIT_SUCCESS;
	}
}
Exemplo n.º 7
0
static void
utimer(void)
{
	L4_KDB_SetThreadName(sos_my_tid(), "utimer");
	L4_Accept(L4_UntypedWordsAcceptor);

	List *entryq;
	entryq = list_empty();

	for (;;) {
		L4_Yield();

		// Walk the timer list
		L4_Word_t now = L4_KDB_GetTick();
		list_delete(entryq, processExpired, &now);

		// Wait for a new packet either blocking or non-blocking
		L4_MsgTag_t tag = L4_Niltag;
		if (list_null(entryq))
			L4_Set_ReceiveBlock(&tag);
		else
			L4_Clear_ReceiveBlock(&tag);

		L4_ThreadId_t wait_tid = L4_nilthread;
		tag = L4_Ipc(L4_nilthread, L4_anythread, tag, &wait_tid);

		if (!L4_IpcFailed(tag)) {
			// Received a time out request queue it
			L4_Msg_t msg; L4_MsgStore(tag, &msg);	// Get the message
			utimer_entry_t *entry = (utimer_entry_t *) L4_MsgWord(&msg, 0);
			entry->fTid  = wait_tid;
			list_shift(entryq, entry);
		}
		else if (3 == L4_ErrorCode()) // Receive error # 1
			continue;	// no-partner - non-blocking
		else
			assert(!"Unhandled IPC error");
	}
}
Exemplo n.º 8
0
int queue_dequeue(Queue *que, void **data){
	return list_shift(que, data);
}
Exemplo n.º 9
0
void test(string args)
{
    args = splitArg(args, 1);
    if(streql(args, "") || streql(args, "-H"))
    {
        print("\nThis file is in charge of testing the data types embedded in Q-OS.",black);
        print("\nAccepted Arguments:\n-list\tTests the list.c file\n-set \ttests the set.c file", black);
        print("\n-strb\ttests the strbuilder.c file\n-y   \tshould return the current year...",black);
    }
    else if(streql(args, "-LIST"))//For testing lists
    {
        newline();
        list_t test_list = list_init();
        test_list.autoShrink = true;

        for(uint8 i = 0; i < 4; i++)
        {
            list_add(&test_list, "1");
            list_add(&test_list, "2");
            list_add(&test_list, "3");
            list_add(&test_list, "4");
            list_add(&test_list, "5");
            list_add(&test_list, "6");
            list_add(&test_list, "7");
            list_add(&test_list, "8");
            list_add(&test_list, "9");
            list_add(&test_list, "10");
            list_add(&test_list, "11");
            list_add(&test_list, "12");
            list_add(&test_list, "13");
            list_add(&test_list, "14");
            list_add(&test_list, "15");
            list_add(&test_list, "16");
        }
        list_add(&test_list, "Pointless");

        println("Done sizing up", white);
        printint(test_list.capt, white);

        element_t t;
        for(uint8 i = 0; i < 64; i++)
        {
            t = list_shift(&test_list);
        }
        println("\nLast item deleted should be \"16\"", white);
        println(t.udata.strdata, white);
        println("\nDeleting all but element \"Pointless\"", white);
        for(uint8 i = 0; i < test_list.size; i++)
        {
            println(list_get(test_list, i), white);
        }
        println("Done resizing up", white);
        printint(test_list.capt, white);
        list_destroy(&test_list);
    }
    else if(streql(args,"-SET"))
    {
        set_t test_set = set_init();
        for(uint8 i = 0; i < 4; i++)
        {
            set_add(&test_set, "0");
            set_add(&test_set, "1");
            set_add(&test_set, "2");
            set_add(&test_set, "3");
            set_add(&test_set, "4");
            set_add(&test_set, "5");
            set_add(&test_set, "6");
            set_add(&test_set, "7");
            set_add(&test_set, "8");
            set_add(&test_set, "9");
            set_add(&test_set, "10");
            set_add(&test_set, "11");
            set_add(&test_set, "12");
            set_add(&test_set, "13");
            set_add(&test_set, "14");
            set_add(&test_set, "15");
            set_add(&test_set, "16");
            print("\nIteration: ", white);
            printint(i, white);
        }
        println("\n\nInsertion::Output should be 17", white);
        printint(test_set.size, white);

        set_t tmp = set_init();
        set_add(&tmp, "Union item");
        set_union(&test_set, &tmp);
        println("\n\nUnion::Output should be 18", white);
        printint(test_set.size, white);

        set_intersect(&test_set, &tmp);
        println("\n\nIntersect::Output should be 1", white);
        printint(test_set.size, white);

        println("\n\nPreparing for diff test", white);
        set_add(&test_set, "1");
        set_add(&test_set, "2");
        set_add(&test_set, "3");
        set_add(&tmp, "2");
        set_add(&tmp, "3");
        set_add(&tmp, "4");
        set_diff(&test_set, &tmp);
        println("Diff::Output should be 2", white);
        printint(test_set.size, white);

        set_destroy(&tmp);
        set_destroy(&test_set);
    }
    else if(streql(args, "-STRB"))
    {
        static const string bak = "Hello, world ";
        static const uint32 bln = 13;
        strbuilder_t test_strb = strbuilder_init();

        strbuilder_append(&test_strb, bak);
        strbuilder_append(&test_strb, "Hello, 2nd world");
        println("\nTesting backup text. Output should 1", red);
        printint(streql(bak, test_strb.prevTxt), green);
        println("\nOutput should be \"Hello, world Hello, 2nd world\"", red);
        println(strbuilder_tostr(test_strb), green);
        println("\nRemoving greeters from first world", red);
        strbuilder_delete(&test_strb, 0, bln);
        println("\nOutput should be \"Hello, 2nd world\"", red);
        println(strbuilder_tostr(test_strb), green);
        strbuilder_flip(&test_strb);
        println("\nOutput should be \"dlrow dn2 ,olleH\"", red);
        println(strbuilder_tostr(test_strb), green);
        list_t tmp = strbuilder_split(test_strb, " ");
        println("\nOutput should be last str split by spaces", red);
        for(uint8 i = 0; i < tmp.size; i++)
        {
            println(list_get(tmp, i), white);
        }
        list_destroy(&tmp);
        strbuilder_destroy(&test_strb);
    }
    else if(streql(args,"-Y"))
    {
       //getTime() test
       printint(getTime("year"),white);
    }
}
Exemplo n.º 10
0
/** Release a Strophe connection object.
 *  Decrement the reference count by one for a connection, freeing the
 *  connection object if the count reaches 0.
 *
 *  @param conn a Strophe connection object
 *
 *  @return TRUE if the connection object was freed and FALSE otherwise
 *
 *  @ingroup Connections
 */
int xmpp_conn_release(xmpp_conn_t * const conn)
{
	xmpp_ctx_t *ctx;
	list_t *item;
	xmpp_handler_t *temp;
	xmpp_handlist_t *hlitem, *thli;
	hash_iterator_t *iter;
	const char *key;

	if (conn->ref > 1) {
		conn->ref--;
		return 0;
	}

	ctx = conn->ctx;

	/* remove connection from context's connlist */
	item = list_pop_by_data(ctx->connlist, (void *)conn);
	if (item)
		xmpp_free(ctx, item);
	else
		xmpp_error(ctx, "xmpp", "Connection not in context's list\n");

	/* free handler stuff
	 * note that userdata is the responsibility of the client
	 * and the handler pointers don't need to be freed since they
	 * are pointers to functions */

	while ((item = list_shift(conn->timed_handlers))) {
		xmpp_free(ctx, item->data);
		xmpp_free(ctx, item);
	}
	list_destroy(conn->timed_handlers);

	/* id handlers
	 * we have to traverse the hash table freeing list elements
	 * then release the hash table */
	iter = hash_iter_new(conn->id_handlers);
	while ((key = hash_iter_next(iter))) {
		hlitem = (xmpp_handlist_t *)hash_get(conn->id_handlers, key);
		while (hlitem) {
			thli = hlitem;
			hlitem = hlitem->next;
			xmpp_free(ctx, thli->id);
			xmpp_free(ctx, thli);
		}
	}
	hash_iter_release(iter);
	hash_release(conn->id_handlers);

	while ((item = list_shift(conn->handlers))) {
		temp = (xmpp_handler_t *)item->data;

		if (temp->ns)
			xmpp_free(ctx, temp->ns);
		if (temp->name)
			xmpp_free(ctx, temp->name);
		if (temp->type)
			xmpp_free(ctx, temp->type);
		xmpp_free(ctx, temp);
		xmpp_free(ctx, item);
	}
	list_destroy(conn->handlers);

	if (conn->stream_error) {
		xmpp_stanza_release(conn->stream_error->stanza);
		if (conn->stream_error->text)
			xmpp_free(ctx, conn->stream_error->text);
		xmpp_free(ctx, conn->stream_error);
	}

	parser_free(conn->parser);

	/* free send_queue */
	list_destroy(conn->send_queue);

	if (conn->domain)
		xmpp_free(ctx, conn->domain);
	if (conn->jid)
		xmpp_free(ctx, conn->jid);
	if (conn->bound_jid)
		xmpp_free(ctx, conn->bound_jid);
	if (conn->pass)
		xmpp_free(ctx, conn->pass);
	if (conn->stream_id)
		xmpp_free(ctx, conn->stream_id);
	if (conn->lang)
		xmpp_free(ctx, conn->lang);
	if (conn->tls)
		tls_free(conn->tls);
	xmpp_free(ctx, conn);

	return 1;
}