コード例 #1
0
ファイル: test_list.c プロジェクト: Gratski/SD_Projecto_1
int testRemoveCabeca() {
	int result;
	struct list_t *list;
	struct entry_t *e1, *e2, *e3, *entry;
	struct data_t *data;

	printf("Módulo list -> teste remover cabeça:");

	if ((list = list_create()) == NULL)
		error(1, errno, "  O teste não pode prosseguir");

	if ((data = data_create(5)) == NULL)
		error(1, errno, "  O teste não pode prosseguir");

	e1 = entry_create("abc", data);
	e2 = entry_create("def", data);
	e3 = entry_create("ghi", data);

	if (e1 == NULL || e2 == NULL || e3 == NULL)
		error(1, errno, "  O teste não pode prosseguir");

	memcpy(e1->value->data, "abc1", 5);
	memcpy(e2->value->data, "def1", 5);
	memcpy(e3->value->data, "ghi1", 5);

	list_add(list,e1);
	list_add(list,e2);
	list_add(list,e3);

	assert(list_remove(NULL, "abc") < 0);
	result = (list_remove(NULL, "abc") < 0);

	assert(list_remove(list, NULL) < 0);
	result = result && (list_remove(list, NULL) < 0);

	result = result &&
		 list_remove(list, "abc") == 0 &&
		 list_size(list) == 2;

	entry = list_get(list, "def");
	result = result &&
		 entry != e2 &&
		 strcmp(entry->key, e2->key) == 0;

	entry = list_get(list, "ghi");
	result = result &&
		 entry != e3 &&
		 strcmp(entry->key, e3->key) == 0;

	list_destroy(list);
	entry_destroy(e1);
	entry_destroy(e2);
	entry_destroy(e3);
	data_destroy(data);

	printf(" %s\n", result ? "passou" : "não passou");
	return result;
}
コード例 #2
0
ファイル: pfs_channel.c プロジェクト: liblit/Murphy
int pfs_channel_alloc( pfs_size_t length, pfs_size_t *start )
{
	struct entry *e = head;
	struct entry *tail;
	pfs_size_t newsize;

	length = round_up(length);

	do {
		if(!e->inuse) {
			if(e->length==length) {
				e->inuse = 1;
				*start = e->start;
				memset(channel_base+*start+length-page_size,0,page_size);
				return 1;
			} else if(e->length>length) {
				struct entry *f;
				f = entry_create(e->start+length,e->length-length,e,e->next);
				if(!f) return 0;

				e->length = length;
				e->inuse = 1;
				*start = e->start;
				memset(channel_base+*start+length-page_size,0,page_size);
				return 1;
			} else {
				/* not big enough */
			}
		}
		tail = e;
		e = e->next;
	} while(e!=head);

	debug(D_CHANNEL,"channel is full, attempting to expand it...");
	newsize = channel_size + length;

	if(ftruncate64(channel_fd,newsize)==0) {
		void *newbase;
		newbase = mremap(channel_base,channel_size,newsize,MREMAP_MAYMOVE);
		if(newbase!=MAP_FAILED) {
			e = entry_create(channel_size,newsize-channel_size,tail,head);
			channel_size = newsize;
			channel_base = newbase;
			debug(D_CHANNEL,"channel expanded to 0x%x bytes at base 0x%x",(PTRINT_T)newsize,newbase);
			return pfs_channel_alloc(length,start);
		}
		ftruncate64(channel_fd,channel_size);
	}

	debug(D_CHANNEL|D_NOTICE,"out of channel space: %s",strerror(errno));

	return 0;
}
コード例 #3
0
ファイル: test_list.c プロジェクト: Gratski/SD_Projecto_1
int testGetKeys() {
	int result;
	struct list_t *list;
	struct entry_t *e1, *e2, *e3;
	struct data_t *data;
	char **keys;

	printf("Módulo list -> teste busca chaves:");

	if ((list = list_create()) == NULL)
		error(1, errno, "  O teste não pode prosseguir");

	if ((data = data_create(5)) == NULL)
		error(1, errno, "  O teste não pode prosseguir");

	assert(list_get_keys(NULL) == NULL);
	result = (list_get_keys(NULL) == NULL);

	e1 = entry_create("abc", data);
	e2 = entry_create("def", data);
	e3 = entry_create("ghi", data);

	if (e1 == NULL || e2 == NULL || e3 == NULL)
		error(1, errno, "  O teste não pode prosseguir");

	memcpy(e1->value->data, "abc1", 5);
	memcpy(e2->value->data, "def1", 5);
	memcpy(e3->value->data, "ghi1", 5);

	list_add(list,e1);
	list_add(list,e2);
	list_add(list,e3);

	if ((keys = list_get_keys(list)) == NULL)
		error(1, errno, "  O teste não pode prosseguir");

	result = strcmp(keys[0], e1->key) == 0 && keys[0] != e1->key &&
                 strcmp(keys[1], e2->key) == 0 && keys[1] != e2->key && 
                 strcmp(keys[2], e3->key) == 0 && keys[2] != e3->key && 
                 keys[3] == NULL;

	list_free_keys(keys);
	list_destroy(list);
	entry_destroy(e1);
	entry_destroy(e2);
	entry_destroy(e3);
	data_destroy(data);

	printf(" %s\n", result ? "passou" : "não passou");
	return result;
}
コード例 #4
0
ファイル: pfs_channel.c プロジェクト: liblit/Murphy
int pfs_channel_init( pfs_size_t size )
{
	char path[PATH_MAX];

	sprintf(path,"%s/pfs.tmp.XXXXXX",pfs_temp_dir);
	channel_fd = mkstemp(path);
	if(channel_fd<0) return 0;
	unlink(path);
	ftruncate(channel_fd,size);

	channel_size = size;

	channel_base = (char*) mmap(0,size,PROT_READ|PROT_WRITE,MAP_SHARED,channel_fd,0);
	if(channel_base==MAP_FAILED) {
		close(channel_fd);
		return 0;
	}

	head = entry_create(0,size,0,0);
	if(!head) {
		close(channel_fd);
		munmap(channel_base,size);
		return 0;
	}

	debug(D_CHANNEL,"fd is %d",channel_fd);

	return 1;
}
コード例 #5
0
ファイル: index.c プロジェクト: EngTurtle/CSC190-Project3
bag_t *generate_index(FILE *input, int min_word_len)
{
    bag_t *index = bag_create(entry_cmp);

    if (index) {
        char word[LINE_LENGTH] = "";
        entry_t new_word, *existing_entry;
        bag_elem_t new_entry;
        unsigned page = 0;
        while (get_word(input, word, &page))
        {
            new_word.entry_word = word;
            // check if the length of the word is long enough
            if(strlen(word) >= min_word_len)
            {
                existing_entry = bag_contains(index, &new_word);
                if(existing_entry != NULL) // if the word is already in index
                {
                    entry_add(existing_entry, page); // add the location to the list of locations for that word
                }
                else // if the word isn't in the index
                {
                    new_entry = entry_create(word, page); // create the entry
                    bag_insert(index, new_entry); // add the location
                }
            }
        }
    }
    return index;
}
コード例 #6
0
ファイル: attr.c プロジェクト: tpatki/flux-core
int attr_add_active (attr_t *attrs, const char *name, int flags,
                     attr_get_f get, attr_set_f set, void *arg)
{
    struct entry *e;
    int rc = -1;

    if ((e = zhash_lookup (attrs->hash, name))) {
        if (!set) {
            errno = EEXIST;
            goto done;
        }
        if (set (name, e->val, arg) < 0)
            goto done;
    }
    e = entry_create (name, NULL, flags);
    e->set = set;
    e->get = get;
    e->arg = arg;
    e->flags |= FLUX_ATTRFLAG_ACTIVE;
    zhash_update (attrs->hash, name, e);
    zhash_freefn (attrs->hash, name, entry_destroy);
    rc = 0;
done:
    return rc;
}
コード例 #7
0
int testCreate() {
    char *key = strdup("123abc");
    struct data_t *value = data_create2(strlen("1234567890abc")+1,strdup("1234567890abc"));

    struct entry_t *entry = entry_create(key,value);

    int result = (entry->key == key) &&
                 (entry->value == value);

    entry_destroy(entry);

    printf("Modulo entry -> teste entry_create: %s\n",result?"passou":"nao passou");
    return result;
}
コード例 #8
0
int rtable_conditional_put(struct rtable_t *rtable, char *key, struct data_t *data){
   int result;
   struct message_t *msg = (struct message_t*)malloc(sizeof(struct message_t));
   struct entry_t *entry=(struct entry_t*)malloc(sizeof(struct entry_t));
   entry = entry_create(key, data);
   msg->opcode = OC_COND_PUT;
   msg->c_type = CT_ENTRY;
   msg->content.entry=entry;
   if(network_send_receive(rtable->server, msg)->opcode==OC_COND_PUT+1){ //testar se foi colocado efectivamente no servidor
      result=1;
   } else {
      result = -1;
   }
   return result;
}
コード例 #9
0
ファイル: attr.c プロジェクト: tpatki/flux-core
int attr_add (attr_t *attrs, const char *name, const char *val, int flags)
{
    struct entry *e;

    if (name == NULL || (flags & FLUX_ATTRFLAG_ACTIVE)) {
        errno = EINVAL;
        return -1;
    }
    if ((e = zhash_lookup (attrs->hash, name))) {
        errno = EEXIST;
        return -1;
    }
    e = entry_create (name, val, flags);
    zhash_update (attrs->hash, name, e);
    zhash_freefn (attrs->hash, name, entry_destroy);
    return 0;
}
コード例 #10
0
ファイル: test_list.c プロジェクト: Gratski/SD_Projecto_1
int testAddVarios() {
	int result,i,keysize;
	struct list_t *list;
	struct entry_t *entry[1024];
	struct entry_t *aux;
	struct data_t *data;
	char key[16];

	printf("Módulo list -> teste adicionar vários:");

	if ((list = list_create()) == NULL)
		error(1, errno, "  O teste não pode prosseguir");

	for(i=0; i<1024; i++) {
		sprintf(key, "keyabc-%d",i);
		keysize = strlen(key) + 1;

		if ((data = data_create(keysize)) == NULL)
			error(1, errno, "  O teste não pode prosseguir");

		memcpy(data->data, key, keysize);
		if ((entry[i] = entry_create(key, data)) == NULL)
			error(1, errno, "  O teste não pode prosseguir");

		data_destroy(data);
		list_add(list, entry[i]);
	}

	assert(list_size(list) == 1024);
	result = (list_size(list) == 1024);

	for(i=0; i<1024; i++) {
		assert(list_get(list, entry[i]->key) != entry[i]);
		aux = list_get(list, entry[i]->key);
		result = result &&
			 (aux != entry[i]) &&
			 strcmp(aux->key, entry[i]->key) == 0;
		entry_destroy(entry[i]);
	}

	list_destroy(list);

	printf(" %s\n", result ? "passou" : "não passou");
	return result;
}
コード例 #11
0
ファイル: test_list.c プロジェクト: Gratski/SD_Projecto_1
int testAddCabeca() {
	int result;
	struct list_t *list;

	struct entry_t *entry;
	struct entry_t *entry2;
	struct data_t *data;

	printf("Módulo list -> teste adicionar cabeça:");

	if ((list = list_create()) == NULL)
		error(1, errno, "  O teste não pode prosseguir");

	if ((data = data_create(5)) == NULL)
		error(1, errno, "  O teste não pode prosseguir");

	if ((entry = entry_create("abc", data)) == NULL)
		error(1, errno, "  O teste não pode prosseguir");


	memcpy(entry->value->data, "abc1", 5);

	assert(list_add(NULL, entry) < 0);
	result = (list_add(NULL, entry) < 0);

	assert(list_add(list, NULL) < 0);
	result = result && (list_add(list, NULL) < 0);

	result = result && (list_add(list, entry) == 0);

	entry2 = list_get(list, "abc");

	result = result &&
		 entry2 != entry && 
                 list_size(list) == 1 &&
		 strcmp(entry->key, entry2->key) == 0;

	entry_destroy(entry);
	data_destroy(data);
	list_destroy(list);

	printf(" %s\n",result ? "passou" : "não passou");
	return result;
}
コード例 #12
0
int testDup() {
    char *key = strdup("123abc");
    struct data_t *value = data_create2(strlen("1234567890abc")+1,strdup("1234567890abc"));

    struct entry_t *entry = entry_create(key,value);

    struct entry_t *entry2 = entry_dup(entry);

    int result = (entry->key != entry2->key) &&
                 (strcmp(entry->key,entry2->key) == 0) &&
                 (entry->value != entry2->value) &&
                 (entry->value->datasize == entry2->value->datasize) &&
                 (memcmp(entry->value->data, entry2->value->data, entry->value->datasize) == 0);

    entry_destroy(entry);
    entry_destroy(entry2);

    printf("Modulo entry -> teste entry_dup: %s\n",result?"passou":"não passou");
    return result;
}
コード例 #13
0
/* Função para adicionar um par chave valor na tabela.
 * Devolve 0 (ok) ou -1 (problemas).
 */
int ptable_put(struct ptable_t *ptable, char *key, struct data_t *value)
{
	uint16_t result,size;
	result = -1;
	if(ptable->isOpen)
	{
		struct message_t *msg;
		char *msg_buffer, *buffer;
		result = table_put(ptable->table,key,value);
	 	if(result==0)
		{	
			msg = (struct message_t*) malloc(sizeof(struct message_t));
			msg->opcode = OC_PUT;
			msg->c_type = CT_ENTRY;
			msg->content.entry = entry_create(key,value);
			//
			size = message_to_buffer(msg,&msg_buffer);
			//Alocar memoria
			buffer = (char *) malloc(size+sizeof(uint16_t));
			if(buffer == NULL)
			{
				perror("Out of memory");
				return -1;
			}
			//Copiar o tamanho da mensagem
			memcpy(buffer,&size,sizeof(uint16_t));
			//Copiar a mensagem
			memcpy(buffer+sizeof(uint16_t),msg_buffer,size);
			//Escrever mensagem
			if(pmanager_log(ptable->pmanager,buffer)==-1)
			{
				printf("Falha na escrita\n");
			}
			//Free(s)
			free(buffer);
			free(msg_buffer);
			free_message(msg);
		}
	}
	return result;
}
コード例 #14
0
ファイル: hashmap.c プロジェクト: iamscottmoyers/hashmap
static int bucket_insert_existed( bucket_t *bucket, const hashmap_key_t key, const hashmap_value_t value, unsigned int * const existed )
{
	entry_t *entry;
	int err = 0;

	assert( NULL != bucket );
	assert( NULL != key );
	assert( NULL != existed );

	entry = bucket_find_entry( bucket, key, NULL );
	if( NULL != entry )
	{
		/* Key exists in this bucket, update the value. */
		entry->value = value;
		*existed = 1;
	}
	else
	{
		/* Key doesn't exist in this bucket, add it. */
		entry_t *new_entry = entry_create( key, value );

		if( NULL != new_entry )
		{
			new_entry->next = bucket->entries;
			bucket->entries = new_entry;

			++bucket->stats.num_entries;
			*existed = 0;
		}
		else
		{
			err = -1;
		}
	}

	return err;
}
コード例 #15
0
ファイル: test_message.c プロジェクト: Gratski/SD_Projecto_2
int testEntry() {
	int result, size, keysize, datasize, datasize_conv;
	short opcode, c_type, keysize_conv;
	char *msg_str = NULL;
	char *datastr = strdup("abc");
	struct message_t *msg;
	struct data_t *d;

	printf("Módulo mensagem -> teste - Entry");

	d = data_create2(strlen(datastr) + 1, datastr);

	msg = (struct message_t *) malloc(sizeof(struct message_t));
	msg->opcode = OC_PUT;
	msg->c_type = CT_ENTRY;
	msg->content.entry = entry_create(datastr, d);
	data_destroy(d);

	size = message_to_buffer(msg, &msg_str);

	opcode = htons(msg->opcode);
	c_type = htons(msg->c_type);
	keysize = strlen(msg->content.entry->key);
	keysize_conv = htons(keysize);

	char comp_key[keysize];

	memcpy(comp_key, msg_str + 6, keysize);
	datasize = msg->content.entry->value->datasize;
	datasize_conv = htonl(datasize);

	char comp_data[datasize];

	memcpy(comp_data, msg_str + 4 + 2 + keysize + 4, datasize);

	result = memcmp(msg_str, &opcode, 2) == 0 &&
		 memcmp(msg_str + 2, &c_type, 2) == 0 &&
		 memcmp(msg_str + 4, &keysize_conv, 2) == 0 &&
		 memcmp(msg_str + 6, &comp_key, keysize) == 0 &&
		 memcmp(msg_str + 6 + keysize, &datasize_conv, 4) == 0 &&
		 memcmp(msg_str + 6 + keysize + 4, &comp_data, datasize) == 0;

	free_message(msg);

	msg = buffer_to_message(msg_str, size);

	result = result && msg->opcode == OC_PUT &&
			   msg->c_type == CT_ENTRY &&
			   strcmp(msg->content.entry->key, datastr) == 0 &&
			   msg->content.entry->value->datasize == strlen(datastr) + 1 &&
			   strcmp(msg->content.entry->value->data, datastr) == 0;

	free(msg_str);
	free(datastr);

	//print_message(msg);
	
	free_message(msg);

	printf(" %s\n", result ? "passou" : "não passou");
	return result;
}