test.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <inttypes.h>
   5 #include <stdbool.h>
   6 #include "hashtable.h"
   7
   8 #define MAX_LINE 4096
   9
  10 typedef struct _Node {
  11         char* name;
  12 } Node;
  13
  14 uint64_t word_hash_func(const void* o) {
  15         uint64_t hash_value = 0;
  16         const char* name = o;
  17         for (size_t i = 0; i < strlen(name); i++) {
  18                 hash_value += name[i];
  19                 hash_value = hash_value * name[i];
  20         }
  21         return hash_value;
  22 }
  23
  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);
  27         }
  28         buffer[length - 1] = 0;
  29 }
  30
  31 void my_str_free(void* o) {
  32         printf("Freeing %p\n", o);
  33         free(o);
  34 }
  35
  36 void my_ptr_free(void* o) {
  37         Node* node = o;
  38         //printf("Freeing %p\n", node);
  39         free(node->name);
  40         free(node);
  41 }
  42
  43 bool my_ptr_equal(const void* a, const void* b) {
  44         const Node* nodea = a;
  45         const Node* nodeb = b;
  46
  47         if (nodea == NULL || nodeb == NULL) return false;
  48         if (nodea->name == NULL || nodeb->name == NULL) return false;
  49
  50         printf("Comparing %s to %s\n", nodea->name, nodeb->name);
  51         if (strcmp(nodea->name, nodeb->name) == 0)
  52                 return true;
  53         return false;
  54 }
  55
  56 void count_good_guesses(void* key, void* value, void* userdata) {
  57         uint32_t* good_guesses = userdata;
  58         Node* node = value;
  59
  60         (*good_guesses)++;
  61         char* s1 = node->name;
  62         printf("%u: Found: %p - %s\n", *good_guesses, key, s1);
  63 }
  64
  65 int main(int argc, char** argv) {
  66         if (argc != 3) {
  67                 printf("usage: %s <wordlist filename> <num guesses>\n", argv[0]);
  68                 return EXIT_FAILURE;
  69         }
  70
  71         char* filename = argv[1];
  72         uint32_t num_guesses = atol(argv[2]);
  73
  74         Hashtable* table = /*hash_table_create(str_hash, str_equal)*/ hash_table_create_notify(ptr_hash, my_ptr_equal, my_ptr_free);
  75
  76         FILE* fp = fopen(filename, "r");
  77         char* buffer = calloc(sizeof(char), MAX_LINE);
  78         uint32_t numwords = 0;
  79         uint32_t failed = 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);
  86                         free(newentry);
  87                 } else
  88                         numwords++;
  89 */
  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);
  95                         free(node->name);
  96                         free(node);
  97                 } else
  98                         numwords++;
  99         }
 100         fclose(fp);
 101
 102         printf("Loaded %d words into the table.\n", numwords);
 103
 104 /*
 105         uint32_t good_guesses = 0;
 106         fp = fopen(filename, "r");
 107         void* data = NULL;
 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);
 116                         good_guesses++;
 117                 }
 118                 free(node->name);
 119         }
 120         free(node);
 121
 122         fclose(fp);
 123 */
 124 /*
 125         //hash_table_print(table);
 126         uint32_t good_guesses = 0;
 127         const int shortest_guess = 2;
 128         const int longest_guess = 15;
 129         void* data = NULL;
 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);
 139                         good_guesses++;
 140                 }
 141                 free(lookup->name);
 142         }
 143         free(lookup);
 144
 145         printf("%u out of %u guesses were in the table\n", good_guesses, num_guesses);
 146 */
 147         free(buffer);
 148
 149         printf("---------------------------------------\n");
 150         List* values = hash_table_values(table);
 151         List* head = values;
 152         size_t i = 1;
 153         void* data = NULL;
 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);
 161                         good_guesses++;
 162                 }
 163                 head = head->next;
 164         }
 165         hash_table_list_free(values);
 166
 167         printf("%u out of %u inserted words in table were in the table\n", good_guesses, numwords);
 168
 169 /*
 170         List* keys = hash_table_keys(table);
 171         head = keys;
 172         data = NULL;
 173         good_guesses = 0;
 174         i = 1;
 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);
 181                         good_guesses++;
 182                 }
 183                 head = head->next;
 184         }
 185         hash_table_list_free(keys);
 186 */
 187         good_guesses = 0;
 188         hash_table_foreach(table, count_good_guesses, &good_guesses);
 189
 190         printf("%u out of %u inserted words in table were in the table\n", good_guesses, numwords);
 191
 192         HashtableIter iter;
 193         void* key/* = malloc(sizeof(void*))*/;
 194         void* value/* = malloc(sizeof(void*))*/;
 195
 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);
 200         }
 201         //free(key);
 202         //free(value);
 203
 204         hash_table_destroy(table);
 205 }