]>
git.datanom.net - hashtable.git/blob - test.c
49a33a9b3543a6bcf8af6fd9e1fc2194eedb6a82
10 typedef struct _Node
{
14 uint64_t word_hash_func(const void* o
) {
15 uint64_t hash_value
= 0;
17 for (size_t i
= 0; i
< strlen(name
); i
++) {
18 hash_value
+= name
[i
];
19 hash_value
= hash_value
* name
[i
];
24 void generate_random_word(char* buffer
, size_t length
) {
25 for (size_t i
= 0; i
< length
- 1; i
++) {
26 buffer
[i
] = 'a' + (rand() % 26);
28 buffer
[length
- 1] = 0;
31 void my_str_free(void* o
) {
32 printf("Freeing %p\n", o
);
36 void my_ptr_free(void* o
) {
38 //printf("Freeing %p\n", node);
43 bool my_ptr_equal(const void* a
, const void* b
) {
44 const Node
* nodea
= a
;
45 const Node
* nodeb
= b
;
47 if (nodea
== NULL
|| nodeb
== NULL
) return false;
48 if (nodea
->name
== NULL
|| nodeb
->name
== NULL
) return false;
50 printf("Comparing %s to %s\n", nodea
->name
, nodeb
->name
);
51 if (strcmp(nodea
->name
, nodeb
->name
) == 0)
56 void count_good_guesses(void* key
, void* value
, void* userdata
) {
57 uint32_t* good_guesses
= userdata
;
61 char* s1
= node
->name
;
62 printf("%u: Found: %p - %s\n", *good_guesses
, key
, s1
);
65 int main(int argc
, char** argv
) {
67 printf("usage: %s <wordlist filename> <num guesses>\n", argv
[0]);
71 char* filename
= argv
[1];
72 uint32_t num_guesses
= atol(argv
[2]);
74 Hashtable
* table
= /*hash_table_create(str_hash, str_equal)*/ hash_table_create_notify(ptr_hash
, my_ptr_equal
, my_ptr_free
);
76 FILE* fp
= fopen(filename
, "r");
77 char* buffer
= calloc(sizeof(char), MAX_LINE
);
78 uint32_t numwords
= 0;
80 while (!feof(fp
) && fgets(buffer
, MAX_LINE
, fp
) != NULL
) {
81 buffer
[strcspn(buffer
, "\r\n")] = 0;
82 /* char* newentry = strdup(buffer);
83 bool result = hash_table_insert(table, newentry, newentry);
84 if (result == false) {
85 printf("Failed [%u] storing %s\n", ++failed, newentry);
90 Node
* node
= calloc(sizeof(Node
*), 1);
91 node
->name
= strdup(buffer
);
92 bool result
= hash_table_insert(table
, node
, node
);
93 if (result
== false) {
94 printf("Failed [%u] storing %s\n", ++failed
, node
->name
);
102 printf("Loaded %d words into the table.\n", numwords
);
105 uint32_t good_guesses = 0;
106 fp = fopen(filename, "r");
108 Node* node = calloc(sizeof(Node*), 1);
109 while (!feof(fp) && fgets(buffer, MAX_LINE, fp) != NULL) {
110 buffer[strcspn(buffer, "\r\n")] = 0;
111 node->name = strdup(buffer);
112 //printf("Buffer: %s\n", node->name);
113 if ((data = hash_table_lookup(table, node)) != NULL) {
114 char* s1 = ((Node*) data)->name;
115 printf("Lookup: %s - Found: %s\n", node->name, s1);
125 //hash_table_print(table);
126 uint32_t good_guesses = 0;
127 const int shortest_guess = 2;
128 const int longest_guess = 15;
130 Node* lookup = calloc(sizeof(Node*), 1);
131 for (uint32_t i = 0; i < num_guesses; i++) {
132 generate_random_word(buffer, shortest_guess +
133 (rand() % (longest_guess - shortest_guess)));
134 lookup->name = strdup(buffer);
135 printf("Buffer: %s\n", lookup->name);
136 if ((data = hash_table_lookup(table, lookup)) != NULL) {
137 char* s1 = ((Node*) data)->name;
138 printf("Lookup: %s - Found: %s\n", lookup->name, s1);
145 printf("%u out of %u guesses were in the table\n", good_guesses, num_guesses);
149 printf("---------------------------------------\n");
150 List
* values
= hash_table_values(table
);
154 uint32_t good_guesses
= 0;
155 while (head
!= NULL
) {
156 Node
* d
= head
->data
;
157 printf("%lu: %s\n", i
++, (char *) d
->name
);
158 if ((data
= hash_table_lookup(table
, d
)) != NULL
) {
159 char* s1
= ((Node
*) data
)->name
;
160 printf("Lookup: %s - Found: %s\n", d
->name
, s1
);
165 hash_table_list_free(values
);
167 printf("%u out of %u inserted words in table were in the table\n", good_guesses
, numwords
);
170 List* keys = hash_table_keys(table);
175 while (head != NULL) {
176 Node* d = head->data;
177 printf("%lu: %p\n", i++, d->name);
178 if ((data = hash_table_lookup(table, d)) != NULL) {
179 char* s1 = ((Node*) data)->name;
180 printf("Lookup: %s - Found: %s\n", d->name, s1);
185 hash_table_list_free(keys);
188 hash_table_foreach(table
, count_good_guesses
, &good_guesses
);
190 printf("%u out of %u inserted words in table were in the table\n", good_guesses
, numwords
);
196 hash_table_iter_init(&iter
, table
);
197 while (hash_table_iter_next(&iter
, &key
, &value
)) {
198 char* s1
= ((Node
*) value
)->name
;
199 printf("Key: %p value: %s\n", key
, s1
);
202 Node
* node1
= calloc(sizeof(Node
*), 1);
203 node1
->name
= strdup("Dummy Test Name");
204 if (hash_table_insert(table
, node1
, node1
) == true) {
205 hash_table_iter_init(&iter
, table
);
206 printf("Hashtable size: %lu. Key found: %d\n", hash_table_size(table
), hash_table_contains(table
, node1
));
207 void* data
= hash_table_delete(table
, node1
);
208 printf("Deleted: [%p] %s\n", node1
, ((Node
*) data
)->name
);
209 free(((Node
*) data
)->name
);
211 printf("Hashtable size: %lu. Key found: %d\n", hash_table_size(table
), hash_table_contains(table
, node1
));
212 Node
* node2
= calloc(sizeof(Node
*), 1);
213 node2
->name
= strdup("Test Name");
214 hash_table_replace(table
, node2
, node2
);
215 printf("Hashtable size: %lu. Key found: %d\n", hash_table_size(table
), hash_table_contains(table
, node2
));
218 hash_table_destroy(table
);
This page took 0.074152 seconds and 4 git commands to generate.