void test_hash_table_maybe_grow(void)
{
    // It should be possible for the table to grow, preserving all previous values
    hash_table_t table;
    create_hash_table(10, &table);

    hash_table_set("Pottery_clay0", 0, &table);
    hash_table_set("Dark_smoked_gla0", 1, &table);
    hash_table_set("Pottery_clay1", 2, &table);
    hash_table_set("Dark_smoked_gla1", 3, &table);
    hash_table_set("Metallic_Varni0", 4, &table);
    hash_table_set("Body0", 5, &table);
    hash_table_set("Pottery_clay2", 6, &table);
    hash_table_set("850matri0", 7, &table);
    hash_table_set("850matri1", 8, &table);
    hash_table_set("Pottery_clay3", 9, &table);
    hash_table_set("Pottery_clay4", 10, &table);

    TEST_CHECK(table.capacity > 10);
    TEST_CHECK(table.n == 11);

    TEST_CHECK(hash_table_get("Pottery_clay0", &table) == 0);
    TEST_CHECK(hash_table_get("Dark_smoked_gla0", &table) == 1);
    TEST_CHECK(hash_table_get("Pottery_clay1", &table) == 2);
    TEST_CHECK(hash_table_get("Dark_smoked_gla1", &table) == 3);
    TEST_CHECK(hash_table_get("Metallic_Varni0", &table) == 4);
    TEST_CHECK(hash_table_get("Body0", &table) == 5);
    TEST_CHECK(hash_table_get("Pottery_clay2", &table) == 6);
    TEST_CHECK(hash_table_get("850matri0", &table) == 7);
    TEST_CHECK(hash_table_get("850matri1", &table) == 8);
    TEST_CHECK(hash_table_get("Pottery_clay3", &table) == 9);
    TEST_CHECK(hash_table_get("Pottery_clay4", &table) == 10);

    destroy_hash_table(&table);
}
Exemplo n.º 2
0
/** Creates the hash table for speeding up file finding.
 *
 *  @size the size we want to make this hash table
 *  @head the first gd_fs_entry_t in the list of files
 *
 *  @returns 0 on success, 1 on failure
 */
int create_hash_table(size_t size, const struct gd_fs_entry_t* head)
{
	int ret = hcreate(size);
	if(!ret)
	{
		fprintf(stderr, "hcreate failed\n");
		return 1;
	}

	ENTRY entry;
	struct gd_fs_entry_t *iter = head;
	while(iter != NULL)
	{
		entry.key = iter->filename.str;
		entry.data = iter;

		ENTRY* entered = hsearch(entry, ENTER);
		if(0 && !entered)
		{
			fprintf(stderr, "hsearch: %s\n", strerror(errno));
			destroy_hash_table();
			return 1;
		}

		iter = iter->next;
	}

	return 0;
}
Exemplo n.º 3
0
// Destroy all resource connected to a cache object
void destroy_cache(cache_t cache){
    //Destroy double linked list and hash table
    destroy_linked_list(cache->linked_list);
    destroy_hash_table(cache->hash_table);
    free(cache->hash_table);
    free(cache->linked_list);
}
Exemplo n.º 4
0
int main()
{

	hash_table_t * table = NULL;
	init_hash_table(&table,10,10);
	int * num = NULL;
	int i = 0;
	char iNum[40];
	bzero(iNum,40);
	for (i=0;i<64;i++) {
		sprintf(iNum,"%d",i);
		num = (int *) malloc(sizeof(int));
		*num = i;
		insert_hash_elem(*table,iNum,num);
	}

	void * element  = NULL;

	sprintf(iNum,"%d",20);	
	get_value(*table,iNum,&element);
	if (element) {
		printf("%d\n", *((int*)element));
	}

	destroy_hash_table(&table,10);
	return 0;
}
Exemplo n.º 5
0
void destroy_http_conn(http_conn_t *http_conn)
{
	if( http_conn->tcp_conn ) {
		destroy_tcp_conn(http_conn->tcp_conn);
		http_conn->tcp_conn = NULL;
	}
	if( http_conn->http_header ) {
		destroy_hash_table(http_conn->http_header);
		http_conn->http_header = NULL;
	}
	http_conn->session = NULL;
	free(http_conn);
}
Exemplo n.º 6
0
int main(int argc, char* argv[])
{
    if (argc < 2) {
        usage();
        exit(1);
    }

    hash_table* T = hash_ids(argv[1]);
    filter_by_id(argv[1], T);

    destroy_hash_table(T);

    return 0;
}
void test_hash_table_exists(void)
{
    // It should be possible to test for the presence of items in the hash table.
    hash_table_t table;
    create_hash_table(20, &table);

    hash_table_set("potato", 3, &table);
    hash_table_set("monkey", 8, &table);

    TEST_CHECK(hash_table_exists("potato", &table));
    TEST_CHECK(hash_table_exists("monkey", &table));
    TEST_CHECK(!hash_table_exists("radio", &table));

    destroy_hash_table(&table);
}
void test_create_hash_table(void)
{
    {
        // Initialised hash table should be initialised with a default capacity.
        hash_table_t table;
        create_hash_table(0, &table);
        TEST_CHECK(table.hashes != NULL);
        TEST_CHECK(table.entries != NULL);
        TEST_CHECK(table.capacity == HASH_TABLE_DEFAULT_SIZE);
        TEST_CHECK(table.n == 0);
        destroy_hash_table(&table);
    }

    {
        // Initialised hash table should be initialised with supplied capacity.
        hash_table_t table;
        create_hash_table(20, &table);
        TEST_CHECK(table.hashes != NULL);
        TEST_CHECK(table.entries != NULL);
        TEST_CHECK(table.capacity == 20);
        TEST_CHECK(table.n == 0);
        destroy_hash_table(&table);
    }
}
Exemplo n.º 9
0
void cleanup_mem(void)
{
	int i;

	destroy_url_list();
	history_destroy();
	command_cleanup();
	queue_destroy(buddy_request_queue);
	cleanup_manufacture();
	cleanup_text_buffers();
	cleanup_fonts();
	destroy_all_actors();
	end_actors_lists();
	cleanup_lights();
	/* 2d objects */
	destroy_all_2d_objects();
	destroy_all_2d_object_defs();
	/* 3d objects */
	destroy_all_3d_objects();
	/* caches */
	cache_e3d->free_item = &destroy_e3d;
	cache_delete(cache_e3d);
	cache_e3d = NULL;
#ifdef NEW_TEXTURES
	free_texture_cache();
#endif
	// This should be fixed now  Sir_Odie
	cache_delete(cache_system);
	cache_system = NULL;
	/* map location information */
	for (i = 0; continent_maps[i].name; i++)
	{
	    free(continent_maps[i].name);
	}
	free (continent_maps);

	destroy_hash_table(server_marks);
	
	for (i = 0; i < video_modes_count; i++)
	{
		if (video_modes[i].name)
			free(video_modes[i].name);
	}
	free_shaders();
}
Exemplo n.º 10
0
void test_hash_table_get(void)
{
    // It should be possible to retrieve item values from the hash table.
    hash_table_t table;
    create_hash_table(20, &table);

    hash_table_set("potato", 3, &table);
    hash_table_set("monkey", 8, &table);

    TEST_CHECK(hash_table_get("potato", &table) == 3);
    TEST_CHECK(hash_table_get("monkey", &table) == 8);

    // TODO: the value returned by hash_table_get can be from a null pointer.
    // A default sentinel value could be returned instead e.g. -(2^30)
    // TEST_CHECK(hash_table_get("radio", &table) == -(2 << 30));

    destroy_hash_table(&table);
}
Exemplo n.º 11
0
int find_path( int in_room_vnum, int out_room_vnum, CHAR_DATA *ch, 
	       int depth, int in_zone )
{
  struct room_q		*tmp_q, *q_head, *q_tail;
  struct hash_header	x_room;
  int			i, tmp_room, count=0, thru_doors;
  ROOM_INDEX_DATA	*herep;
  ROOM_INDEX_DATA	*startp;
  EXIT_DATA		*exitp;

  if ( depth <0 )
    {
      thru_doors = TRUE;
      depth = -depth;
    }
  else
    {
      thru_doors = FALSE;
    }

  startp = get_room_index( in_room_vnum );

  init_hash_table( &x_room, sizeof(int), 2048 );
  hash_enter( &x_room, in_room_vnum, (void *) - 1 );

  /* initialize queue */
  q_head = (struct room_q *) malloc(sizeof(struct room_q));
  q_tail = q_head;
  q_tail->room_nr = in_room_vnum;
  q_tail->next_q = 0;

  while(q_head)
    {
      herep = get_room_index( q_head->room_nr );
      /* for each room test all directions */
      if( herep->area == startp->area || !in_zone )
	{
	  /* only look in this zone...
	     saves cpu time and  makes world safer for players  */
	  for( i = 0; i <= 5; i++ )
	    {
	      exitp = herep->exit[i];
	      if( exit_ok(exitp) && ( thru_doors ? GO_OK_SMARTER : GO_OK ) )
		{
		  /* next room */
		  tmp_room = herep->exit[i]->to_room->vnum;
		  if( tmp_room != out_room_vnum )
		    {
		      /* shall we add room to queue ?
			 count determines total breadth and depth */
		      if( !hash_find( &x_room, tmp_room )
			 && ( count < depth ) )
			/* && !IS_SET( RM_FLAGS(tmp_room), DEATH ) ) */
			{
			  count++;
			  /* mark room as visted and put on queue */
			  
			  tmp_q = (struct room_q *)
			    malloc(sizeof(struct room_q));
			  tmp_q->room_nr = tmp_room;
			  tmp_q->next_q = 0;
			  q_tail->next_q = tmp_q;
			  q_tail = tmp_q;
	      
			  /* ancestor for first layer is the direction */
			  hash_enter( &x_room, tmp_room,
				     ((int)hash_find(&x_room,q_head->room_nr)
				      == -1) ? (void*)(i+1)
				     : hash_find(&x_room,q_head->room_nr));
			}
		    }
		  else
		    {
		      /* have reached our goal so free queue */
		      tmp_room = q_head->room_nr;
		      for(;q_head;q_head = tmp_q)
			{
			  tmp_q = q_head->next_q;
			  free(q_head);
			}
		      /* return direction if first layer */
		      if ((int)hash_find(&x_room,tmp_room)==-1)
			{
			  if (x_room.buckets)
			    {
			      /* junk left over from a previous track */
			      destroy_hash_table(&x_room, donothing);
			    }
			  return(i);
			}
		      else
			{
			  /* else return the ancestor */
			  int i;
			  
			  i = (int)hash_find(&x_room,tmp_room);
			  if (x_room.buckets)
			    {
			      /* junk left over from a previous track */
			      destroy_hash_table(&x_room, donothing);
			    }
			  return( -1+i);
			}
		    }
		}
	    }
	}
      
      /* free queue head and point to next entry */
      tmp_q = q_head->next_q;
      free(q_head);
      q_head = tmp_q;
    }

  /* couldn't find path */
  if( x_room.buckets )
    {
      /* junk left over from a previous track */
      destroy_hash_table( &x_room, donothing );
    }
  return -1;
}
Exemplo n.º 12
0
void init_server_markers(){
	//init hash table
	destroy_hash_table(server_marks);
	server_marks= create_hash_table(50,hash_fn_int,cmp_fn_int,free);
}
Exemplo n.º 13
0
void test_hash_table_set(void)
{
    {
        // Values should be stored in the hash table.
        hash_table_t table;
        int foundFirst = 0;
        int foundSecond = 0;
        int foundOther = 0;
        int i;

        create_hash_table(20, &table);

        TEST_CHECK(table.hashes != NULL);
        TEST_CHECK(table.entries != NULL);
        TEST_CHECK(table.capacity == 20);
        TEST_CHECK(table.n == 0);

        hash_table_set("potato", 3, &table);
        hash_table_set("monkey", 8, &table);

        TEST_CHECK(table.n == 2);

        for (i = 0; i < table.capacity; ++i) {
            hash_table_entry_t n = table.entries[i];
            if (n.value == 3) {
                foundFirst++;
            } else if (n.value == 8) {
                foundSecond++;
            } else {
                foundOther++;
            }
        }

        TEST_CHECK(foundFirst == 1);
        TEST_CHECK(foundSecond == 1);
        TEST_CHECK(foundOther == 18);

        destroy_hash_table(&table);
    }

    {
        // Values with different hashes but same % capacity value should exist in the
        // the same hash table.
        hash_table_t table;
        int foundFirst = 0;
        int foundSecond = 0;
        int foundOther = 0;
        int i;

        create_hash_table(20, &table);

        TEST_CHECK(table.hashes != NULL);
        TEST_CHECK(table.entries != NULL);
        TEST_CHECK(table.capacity == 20);
        TEST_CHECK(table.n == 0);

        // hashes are different but % 20 value is the same - they will end up in the same bucket
        hash_table_set("potato", 3, &table); // hash 356168476
        hash_table_set("potat[", 3, &table); // hash 356168456

        // hashes are different but % 20 value is the same - they will end up in the same bucket
        hash_table_set("monkey", 8, &table); // hash 238557080
        hash_table_set("monkee", 8, &table); // hash 238557060

        TEST_CHECK(table.n == 4);

        for (i = 0; i < table.capacity; ++i) {
            if ((table.entries + i)->value == 3) {
                foundFirst++;
            } else if ((table.entries + i)->value == 8) {
                foundSecond++;
            } else {
                foundOther++;
            }
        }

        TEST_CHECK(foundFirst == 2);
        TEST_CHECK(foundSecond == 2);
        TEST_CHECK(foundOther == 16);

        destroy_hash_table(&table);
    }

    {
        // TODO: This fails. Should the key also be stored in the entry so it can be compared
        // with the key being inserted?
        // Values with identical hashes but different keys should exist in the same hash table.
        hash_table_t table;
        int foundFirst = 0;
        int foundSecond = 0;
        int foundOther = 0;
        int i;

        create_hash_table(20, &table);

        TEST_CHECK(table.hashes != NULL);
        TEST_CHECK(table.entries != NULL);
        TEST_CHECK(table.capacity == 20);
        TEST_CHECK(table.n == 0);

        hash_table_set("potato", 3, &table); // hash 356168476
        hash_table_set("potbSo", 3, &table); // hash 356168476 (identical)

        hash_table_set("monkey", 8, &table); // hash 238557080
        hash_table_set("monkfX", 8, &table); // hash 238557080 (identical)

        // TEST_CHECK(table.n == 4);

        for (i = 0; i < table.capacity; ++i) {
            hash_table_entry_t n = table.entries[i];
            if (n.value == 3) {
                foundFirst++;
            } else if (n.value == 8) {
                foundSecond++;
            } else {
                foundOther++;
            }
        }

        // TEST_CHECK(foundFirst == 2);
        // TEST_CHECK(foundSecond == 2);
        // TEST_CHECK(foundOther == 16);

        destroy_hash_table(&table);
    }
}