git.oblomov.eu Git - ohcount/blob - test/unit/loc_test.h

   1 // loc_test.h written by Mitchell Foral. mitchell<att>caladbolg.net.
   2 // See COPYING for license information.
   3
   4 #include <assert.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7
   8 #include "../../src/loc.h"
   9
  10 void test_loc_default() {
  11   Loc *loc = ohcount_loc_new("c", 0, 0, 0, 0);
  12   assert(strcmp("c", loc->language) == 0);
  13   assert(loc->code == 0);
  14   assert(loc->comments == 0);
  15   assert(loc->blanks == 0);
  16   assert(loc->filecount == 0);
  17   ohcount_loc_free(loc);
  18 }
  19
  20 void test_loc_initializer() {
  21   Loc *loc = ohcount_loc_new("c", 1, 2, 3, 4);
  22   assert(strcmp("c", loc->language) == 0);
  23   assert(loc->code == 1);
  24   assert(loc->comments == 2);
  25   assert(loc->blanks == 3);
  26   assert(loc->filecount == 4);
  27   ohcount_loc_free(loc);
  28 }
  29
  30 void test_loc_add() {
  31   Loc *loc = ohcount_loc_new("c", 1, 2, 3, 4);
  32   Loc *loc2 = ohcount_loc_new("c", 10, 20, 30, 40);
  33   ohcount_loc_add_loc(loc, loc2);
  34   assert(strcmp("c", loc->language) == 0);
  35   assert(loc->code == 11);
  36   assert(loc->comments == 22);
  37   assert(loc->blanks == 33);
  38   assert(ohcount_loc_total(loc) == 66);
  39   assert(loc->filecount == 44);
  40   ohcount_loc_free(loc);
  41   ohcount_loc_free(loc2);
  42 }
  43
  44 void test_loc_add_requires_same_language() {
  45   Loc *loc = ohcount_loc_new("c", 1, 2, 3, 4);
  46   Loc *loc2 = ohcount_loc_new("java", 10, 20, 30, 40);
  47   ohcount_loc_add_loc(loc, loc2);
  48   assert(strcmp("c", loc->language) == 0);
  49   assert(loc->code == 1);
  50   assert(loc->comments == 2);
  51   assert(loc->blanks == 3);
  52   assert(loc->filecount == 4);
  53   ohcount_loc_free(loc);
  54   ohcount_loc_free(loc2);
  55 }
  56
  57 void test_loc_list_default() {
  58   LocList *list = ohcount_loc_list_new();
  59   assert(list->loc == NULL);
  60   ohcount_loc_list_free(list);
  61 }
  62
  63 void test_loc_list_selector() {
  64   LocList *list = ohcount_loc_list_new();
  65   Loc *c = ohcount_loc_new("c", 1, 2, 3, 4);
  66   Loc *java = ohcount_loc_new("java", 10, 20, 30, 40);
  67   ohcount_loc_list_add_loc(list, c);
  68   ohcount_loc_list_add_loc(list, java);
  69   assert(strcmp(list->head->loc->language, "c") == 0);
  70   assert(strcmp(list->head->next->loc->language, "java") == 0);
  71   assert(ohcount_loc_is_equal(ohcount_loc_list_get_loc(list, "c"), c));
  72   assert(ohcount_loc_is_equal(ohcount_loc_list_get_loc(list, "java"), java));
  73   ohcount_loc_free(c);
  74   ohcount_loc_free(java);
  75   ohcount_loc_list_free(list);
  76 }
  77
  78 void test_loc_list_first_add() {
  79   LocList *list = ohcount_loc_list_new();
  80   Loc *c = ohcount_loc_new("c", 1, 2, 3, 4);
  81   ohcount_loc_list_add_loc(list, c);
  82   assert(ohcount_loc_is_equal(list->head->loc, c));
  83   assert(strcmp(list->head->loc->language, "c") == 0);
  84   assert(ohcount_loc_list_code(list) == 1);
  85   assert(ohcount_loc_list_comments(list) == 2);
  86   assert(ohcount_loc_list_blanks(list) == 3);
  87   assert(ohcount_loc_list_total(list) == 6);
  88   assert(ohcount_loc_list_filecount(list) == 4);
  89   ohcount_loc_free(c);
  90   ohcount_loc_list_free(list);
  91 }
  92
  93 void test_loc_list_add_two_languages() {
  94   LocList *list = ohcount_loc_list_new();
  95   Loc *c = ohcount_loc_new("c", 1, 2, 3, 4);
  96   Loc *java = ohcount_loc_new("java", 10, 20, 30, 40);
  97   ohcount_loc_list_add_loc(list, c);
  98   ohcount_loc_list_add_loc(list, java);
  99   assert(strcmp(list->head->loc->language, "c") == 0);
 100   assert(strcmp(list->head->next->loc->language, "java") == 0);
 101   assert(ohcount_loc_is_equal(ohcount_loc_list_get_loc(list, "c"), c));
 102   assert(ohcount_loc_is_equal(ohcount_loc_list_get_loc(list, "java"), java));
 103   assert(ohcount_loc_list_code(list) == 11);
 104   assert(ohcount_loc_list_comments(list) == 22);
 105   assert(ohcount_loc_list_blanks(list) == 33);
 106   assert(ohcount_loc_list_total(list) == 66);
 107   assert(ohcount_loc_list_filecount(list) == 44);
 108   ohcount_loc_free(c);
 109   ohcount_loc_free(java);
 110   ohcount_loc_list_free(list);
 111 }
 112
 113 void test_loc_list_add_same_language_twice() {
 114   LocList *list = ohcount_loc_list_new();
 115   Loc *c1 = ohcount_loc_new("c", 1, 2, 3, 4);
 116   Loc *c2 = ohcount_loc_new("c", 10, 20, 30, 40);
 117   ohcount_loc_list_add_loc(list, c1);
 118   ohcount_loc_list_add_loc(list, c2);
 119   assert(strcmp(list->head->loc->language, "c") == 0);
 120   assert(list->head->next == NULL);
 121   assert(ohcount_loc_list_code(list) == 11);
 122   assert(ohcount_loc_list_comments(list) == 22);
 123   assert(ohcount_loc_list_blanks(list) == 33);
 124   assert(ohcount_loc_list_total(list) == 66);
 125   assert(ohcount_loc_list_filecount(list) == 44);
 126   ohcount_loc_free(c1);
 127   ohcount_loc_free(c2);
 128   ohcount_loc_list_free(list);
 129 }
 130
 131 void test_loc_list_add_loc_lists() {
 132   LocList *list1 = ohcount_loc_list_new();
 133   LocList *list2 = ohcount_loc_list_new();
 134   Loc *c1 = ohcount_loc_new("c", 1, 0, 0, 0);
 135   Loc *java = ohcount_loc_new("java", 2, 0, 0, 0);
 136   Loc *c2 = ohcount_loc_new("c", 10, 0, 0, 0);
 137   Loc *ruby = ohcount_loc_new("ruby", 3, 0, 0, 0);
 138   ohcount_loc_list_add_loc(list1, c1);
 139   ohcount_loc_list_add_loc(list1, java);
 140   ohcount_loc_list_add_loc(list2, c2);
 141   ohcount_loc_list_add_loc(list2, ruby);
 142   ohcount_loc_list_add_loc_list(list1, list2);
 143   assert(strcmp(list1->head->loc->language, "c") == 0);
 144   assert(strcmp(list1->head->next->loc->language, "java") == 0);
 145   assert(strcmp(list1->head->next->next->loc->language, "ruby") == 0);
 146   assert(list1->head->next->next->next == NULL);
 147   assert(ohcount_loc_list_get_loc(list1, "c")->code == 11);
 148   assert(ohcount_loc_list_get_loc(list1, "java")->code == 2);
 149   assert(ohcount_loc_list_get_loc(list1, "ruby")->code == 3);
 150   assert(ohcount_loc_list_code(list1) == 16);
 151   ohcount_loc_free(c1);
 152   ohcount_loc_free(java);
 153   ohcount_loc_free(c2);
 154   ohcount_loc_free(ruby);
 155   ohcount_loc_list_free(list1);
 156   ohcount_loc_list_free(list2);
 157 }
 158
 159 void test_loc_list_compact() {
 160   LocList *list = ohcount_loc_list_new();
 161   Loc *c = ohcount_loc_new("c", 1, 2, 3, 4);
 162   Loc *java = ohcount_loc_new("java", 0, 0, 0, 0);
 163   ohcount_loc_list_add_loc(list, c);
 164   ohcount_loc_list_add_loc(list, java);
 165   LocList *compacted = ohcount_loc_list_new_compact(list);
 166   assert(ohcount_loc_is_equal(ohcount_loc_list_get_loc(compacted, "c"), c));
 167   assert(compacted->head->next == NULL);
 168   ohcount_loc_free(c);
 169   ohcount_loc_free(java);
 170   ohcount_loc_list_free(list);
 171   ohcount_loc_list_free(compacted);
 172 }
 173
 174 void test_loc_delta_default() {
 175   LocDelta *delta = ohcount_loc_delta_new("c", 0, 0, 0, 0, 0, 0);
 176   assert(delta->code_added == 0);
 177   assert(delta->code_removed == 0);
 178   assert(delta->comments_added == 0);
 179   assert(delta->comments_removed == 0);
 180   assert(delta->blanks_added == 0);
 181   assert(delta->blanks_removed == 0);
 182   ohcount_loc_delta_free(delta);
 183 }
 184
 185 void test_loc_delta_initializer() {
 186   LocDelta *delta = ohcount_loc_delta_new("c", 1, 10, 2, 20, 3, 30);
 187   assert(strcmp(delta->language, "c") == 0);
 188   assert(delta->code_added == 1);
 189   assert(delta->code_removed == 10);
 190   assert(delta->comments_added == 2);
 191   assert(delta->comments_removed == 20);
 192   assert(delta->blanks_added == 3);
 193   assert(delta->blanks_removed == 30);
 194   ohcount_loc_delta_free(delta);
 195 }
 196
 197 void test_loc_delta_net_total() {
 198   LocDelta *delta = ohcount_loc_delta_new("c", 1, 10, 2, 20, 3, 30);
 199   assert(ohcount_loc_delta_net_code(delta) == -9);
 200   assert(ohcount_loc_delta_net_comments(delta) == -18);
 201   assert(ohcount_loc_delta_net_blanks(delta) == -27);
 202   assert(ohcount_loc_delta_net_total(delta) == -54);
 203   ohcount_loc_delta_free(delta);
 204 }
 205
 206 void test_loc_delta_addition() {
 207   LocDelta *delta1 = ohcount_loc_delta_new("c", 1, 10, 2, 20, 3, 30);
 208   LocDelta *delta2 = ohcount_loc_delta_new("c", 100, 1000, 200, 2000, 300,
 209                                            3000);
 210   ohcount_loc_delta_add_loc_delta(delta1, delta2);
 211   assert(delta1->code_added == 101);
 212   assert(delta1->code_removed == 1010);
 213   assert(delta1->comments_added == 202);
 214   assert(delta1->comments_removed == 2020);
 215   assert(delta1->blanks_added == 303);
 216   assert(delta1->blanks_removed == 3030);
 217   ohcount_loc_delta_free(delta1);
 218   ohcount_loc_delta_free(delta2);
 219 }
 220
 221 void test_loc_delta_addition_requires_matching_language() {
 222   LocDelta *delta1 = ohcount_loc_delta_new("c", 0, 0, 0, 0, 0, 0);
 223   LocDelta *delta2 = ohcount_loc_delta_new("java", 1, 10, 2, 20, 3, 30);
 224   ohcount_loc_delta_add_loc_delta(delta1, delta2);
 225   assert(strcmp(delta1->language, "c") == 0);
 226   assert(delta1->code_added == 0);
 227   assert(delta1->code_removed == 0);
 228   assert(delta1->comments_added == 0);
 229   assert(delta1->comments_removed == 0);
 230   assert(delta1->blanks_added == 0);
 231   assert(delta1->blanks_removed == 0);
 232   ohcount_loc_delta_free(delta1);
 233   ohcount_loc_delta_free(delta2);
 234 }
 235
 236 void test_loc_delta_equals() {
 237   LocDelta *delta1 = ohcount_loc_delta_new("c", 1, 10, 2, 20, 3, 30);
 238   LocDelta *delta2 = ohcount_loc_delta_new("c", 1, 10, 2, 20, 3, 30);
 239   assert(ohcount_loc_delta_is_equal(delta1, delta2));
 240   ohcount_loc_delta_free(delta1);
 241   ohcount_loc_delta_free(delta2);
 242 }
 243
 244 void test_loc_delta_list_default() {
 245   LocDeltaList *list = ohcount_loc_delta_list_new();
 246   assert(list->delta == NULL);
 247   ohcount_loc_delta_list_free(list);
 248 }
 249
 250 void test_loc_delta_list_selector() {
 251   LocDeltaList *list = ohcount_loc_delta_list_new();
 252   LocDelta *c = ohcount_loc_delta_new("c", 0, 0, 0, 0, 0, 0);
 253   LocDelta *java = ohcount_loc_delta_new("java", 0, 0, 0, 0, 0, 0);
 254   ohcount_loc_delta_list_add_loc_delta(list, c);
 255   ohcount_loc_delta_list_add_loc_delta(list, java);
 256   assert(ohcount_loc_delta_is_equal(
 257          ohcount_loc_delta_list_get_loc_delta(list, "c"), c));
 258   assert(ohcount_loc_delta_is_equal(
 259          ohcount_loc_delta_list_get_loc_delta(list, "java"), java));
 260   ohcount_loc_delta_free(c);
 261   ohcount_loc_delta_free(java);
 262   ohcount_loc_delta_list_free(list);
 263 }
 264
 265 void test_loc_delta_list_first_add() {
 266   LocDeltaList *list = ohcount_loc_delta_list_new();
 267   LocDelta *c = ohcount_loc_delta_new("c", 1, 10, 2, 20, 3, 30);
 268   ohcount_loc_delta_list_add_loc_delta(list, c);
 269   assert(strcmp(list->head->delta->language, "c") == 0);
 270   assert(ohcount_loc_delta_list_code_added(list) == 1);
 271   assert(ohcount_loc_delta_list_code_removed(list) == 10);
 272   assert(ohcount_loc_delta_list_comments_added(list) == 2);
 273   assert(ohcount_loc_delta_list_comments_removed(list) == 20);
 274   assert(ohcount_loc_delta_list_blanks_added(list) == 3);
 275   assert(ohcount_loc_delta_list_blanks_removed(list) == 30);
 276   ohcount_loc_delta_free(c);
 277   ohcount_loc_delta_list_free(list);
 278 }
 279
 280 void test_loc_delta_list_add_two_languages() {
 281   LocDeltaList *list = ohcount_loc_delta_list_new();
 282   LocDelta *c = ohcount_loc_delta_new("c", 1, 10, 2, 20, 3, 30);
 283   LocDelta *java = ohcount_loc_delta_new("java", 100, 1000, 200, 2000, 300,
 284                                          3000);
 285   ohcount_loc_delta_list_add_loc_delta(list, c);
 286   ohcount_loc_delta_list_add_loc_delta(list, java);
 287   assert(ohcount_loc_delta_is_equal(
 288          ohcount_loc_delta_list_get_loc_delta(list, "c"), c));
 289   assert(ohcount_loc_delta_is_equal(
 290          ohcount_loc_delta_list_get_loc_delta(list, "java"), java));
 291   assert(strcmp(list->head->delta->language, "c") == 0);
 292   assert(strcmp(list->head->next->delta->language, "java") == 0);
 293   assert(ohcount_loc_delta_list_code_added(list) == 101);
 294   assert(ohcount_loc_delta_list_code_removed(list) == 1010);
 295   assert(ohcount_loc_delta_list_comments_added(list) == 202);
 296   assert(ohcount_loc_delta_list_comments_removed(list) == 2020);
 297   assert(ohcount_loc_delta_list_blanks_added(list) == 303);
 298   assert(ohcount_loc_delta_list_blanks_removed(list) == 3030);
 299   ohcount_loc_delta_free(c);
 300   ohcount_loc_delta_free(java);
 301   ohcount_loc_delta_list_free(list);
 302 }
 303
 304 void test_loc_delta_list_add_same_language_twice() {
 305   LocDeltaList *list = ohcount_loc_delta_list_new();
 306   LocDelta *c1 = ohcount_loc_delta_new("c", 1, 10, 2, 20, 3, 30);
 307   LocDelta *c2 = ohcount_loc_delta_new("c", 100, 1000, 200, 2000, 300, 3000);
 308   ohcount_loc_delta_list_add_loc_delta(list, c1);
 309   ohcount_loc_delta_list_add_loc_delta(list, c2);
 310   assert(list->head->next == NULL);
 311   assert(strcmp(list->head->delta->language, "c") == 0);
 312   assert(ohcount_loc_delta_list_code_added(list) == 101);
 313   assert(ohcount_loc_delta_list_code_removed(list) == 1010);
 314   assert(ohcount_loc_delta_list_comments_added(list) == 202);
 315   assert(ohcount_loc_delta_list_comments_removed(list) == 2020);
 316   assert(ohcount_loc_delta_list_blanks_added(list) == 303);
 317   assert(ohcount_loc_delta_list_blanks_removed(list) == 3030);
 318   ohcount_loc_delta_free(c1);
 319   ohcount_loc_delta_free(c2);
 320   ohcount_loc_delta_list_free(list);
 321 }
 322
 323 void test_loc_delta_list_add_two_lists() {
 324   LocDeltaList *list1 = ohcount_loc_delta_list_new();
 325   LocDeltaList *list2 = ohcount_loc_delta_list_new();
 326   LocDelta *c1 = ohcount_loc_delta_new("c", 0, 0, 0, 0, 0, 0);
 327   LocDelta *c2 = ohcount_loc_delta_new("c", 1, 10, 2, 20, 3, 30);
 328   ohcount_loc_delta_list_add_loc_delta(list1, c1);
 329   ohcount_loc_delta_list_add_loc_delta(list2, c2);
 330   ohcount_loc_delta_list_add_loc_delta_list(list1, list2);
 331   assert(ohcount_loc_delta_list_code_added(list1) == 1);
 332   assert(ohcount_loc_delta_list_code_removed(list1) == 10);
 333   assert(ohcount_loc_delta_list_comments_added(list1) == 2);
 334   assert(ohcount_loc_delta_list_comments_removed(list1) == 20);
 335   assert(ohcount_loc_delta_list_blanks_added(list1) == 3);
 336   assert(ohcount_loc_delta_list_blanks_removed(list1) == 30);
 337   ohcount_loc_delta_free(c1);
 338   ohcount_loc_delta_free(c2);
 339   ohcount_loc_delta_list_free(list1);
 340   ohcount_loc_delta_list_free(list2);
 341 }
 342
 343 void test_loc_delta_list_net_total() {
 344   LocDeltaList *list = ohcount_loc_delta_list_new();
 345   LocDelta *c = ohcount_loc_delta_new("c", 1, 10, 2, 20, 3, 30);
 346   LocDelta *java = ohcount_loc_delta_new("java", 100, 1000, 200, 2000, 300,
 347                                          3000);
 348   ohcount_loc_delta_list_add_loc_delta(list, c);
 349   ohcount_loc_delta_list_add_loc_delta(list, java);
 350   assert(ohcount_loc_delta_list_net_code(list) == 1 - 10 + 100 - 1000);
 351   assert(ohcount_loc_delta_list_net_comments(list) == 2 - 20 + 200 - 2000);
 352   assert(ohcount_loc_delta_list_net_blanks(list) == 3 - 30 + 300 - 3000);
 353   assert(ohcount_loc_delta_list_net_total(list) == 6 - 60 + 600 - 6000);
 354   ohcount_loc_delta_free(c);
 355   ohcount_loc_delta_free(java);
 356   ohcount_loc_delta_list_free(list);
 357 }
 358
 359 void test_loc_delta_list_compact() {
 360   LocDeltaList *list = ohcount_loc_delta_list_new();
 361   LocDelta *c = ohcount_loc_delta_new("c", 1, 10, 2, 20, 3, 30);
 362   LocDelta *ruby = ohcount_loc_delta_new("ruby", 1, 1, 0, 0, 0, 0);
 363   LocDelta *java = ohcount_loc_delta_new("java", 0, 0, 0, 0, 0, 0);
 364   ohcount_loc_delta_list_add_loc_delta(list, c);
 365   ohcount_loc_delta_list_add_loc_delta(list, ruby);
 366   ohcount_loc_delta_list_add_loc_delta(list, java);
 367   LocDeltaList *compacted = ohcount_loc_delta_list_new_compact(list);
 368   assert(ohcount_loc_delta_is_equal(ohcount_loc_delta_list_get_loc_delta(compacted, "c"), c));
 369   assert(ohcount_loc_delta_is_equal(ohcount_loc_delta_list_get_loc_delta(compacted, "ruby"), ruby));
 370   assert(compacted->head->next->next == NULL);
 371   ohcount_loc_delta_free(c);
 372   ohcount_loc_delta_free(ruby);
 373   ohcount_loc_delta_free(java);
 374   ohcount_loc_delta_list_free(list);
 375   ohcount_loc_delta_list_free(compacted);
 376 }
 377
 378 void all_loc_tests() {
 379   test_loc_default();
 380   test_loc_initializer();
 381   test_loc_add();
 382   test_loc_add_requires_same_language();
 383
 384   test_loc_list_default();
 385   test_loc_list_selector();
 386   test_loc_list_first_add();
 387   test_loc_list_add_two_languages();
 388   test_loc_list_add_same_language_twice();
 389   test_loc_list_add_loc_lists();
 390   test_loc_list_compact();
 391
 392   test_loc_delta_default();
 393   test_loc_delta_initializer();
 394   test_loc_delta_net_total();
 395   test_loc_delta_addition();
 396   test_loc_delta_addition_requires_matching_language();
 397   test_loc_delta_equals();
 398
 399   test_loc_delta_list_default();
 400   test_loc_delta_list_selector();
 401   test_loc_delta_list_first_add();
 402   test_loc_delta_list_add_two_languages();
 403   test_loc_delta_list_add_same_language_twice();
 404   test_loc_delta_list_add_two_lists();
 405   test_loc_delta_list_net_total();
 406   test_loc_delta_list_compact();
 407 }