]>
git.datanom.net - hashtable.git/blob - test.c
8cf65c47d6f8d355bfbe7b806dde811b45d246d0
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
);
193 void* key
/* = malloc(sizeof(void*))*/;
194 void* value
/* = malloc(sizeof(void*))*/;
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
);
204 hash_table_destroy(table
);
This page took 0.101213 seconds and 4 git commands to generate.