prometheus-client-mmap 0.20.3-x86_64-linux-musl

Sign up to get free protection for your applications and to get access to all the features.
Files changed (92) hide show
  1. checksums.yaml +7 -0
  2. data/README.md +253 -0
  3. data/ext/fast_mmaped_file/extconf.rb +30 -0
  4. data/ext/fast_mmaped_file/fast_mmaped_file.c +122 -0
  5. data/ext/fast_mmaped_file/file_format.c +5 -0
  6. data/ext/fast_mmaped_file/file_format.h +11 -0
  7. data/ext/fast_mmaped_file/file_parsing.c +195 -0
  8. data/ext/fast_mmaped_file/file_parsing.h +27 -0
  9. data/ext/fast_mmaped_file/file_reading.c +102 -0
  10. data/ext/fast_mmaped_file/file_reading.h +30 -0
  11. data/ext/fast_mmaped_file/globals.h +14 -0
  12. data/ext/fast_mmaped_file/mmap.c +427 -0
  13. data/ext/fast_mmaped_file/mmap.h +61 -0
  14. data/ext/fast_mmaped_file/rendering.c +199 -0
  15. data/ext/fast_mmaped_file/rendering.h +8 -0
  16. data/ext/fast_mmaped_file/utils.c +56 -0
  17. data/ext/fast_mmaped_file/utils.h +22 -0
  18. data/ext/fast_mmaped_file/value_access.c +242 -0
  19. data/ext/fast_mmaped_file/value_access.h +15 -0
  20. data/ext/fast_mmaped_file_rs/.cargo/config.toml +23 -0
  21. data/ext/fast_mmaped_file_rs/Cargo.lock +790 -0
  22. data/ext/fast_mmaped_file_rs/Cargo.toml +30 -0
  23. data/ext/fast_mmaped_file_rs/README.md +52 -0
  24. data/ext/fast_mmaped_file_rs/extconf.rb +30 -0
  25. data/ext/fast_mmaped_file_rs/src/error.rs +174 -0
  26. data/ext/fast_mmaped_file_rs/src/file_entry.rs +579 -0
  27. data/ext/fast_mmaped_file_rs/src/file_info.rs +190 -0
  28. data/ext/fast_mmaped_file_rs/src/lib.rs +79 -0
  29. data/ext/fast_mmaped_file_rs/src/macros.rs +14 -0
  30. data/ext/fast_mmaped_file_rs/src/map.rs +492 -0
  31. data/ext/fast_mmaped_file_rs/src/mmap.rs +151 -0
  32. data/ext/fast_mmaped_file_rs/src/parser.rs +346 -0
  33. data/ext/fast_mmaped_file_rs/src/raw_entry.rs +473 -0
  34. data/ext/fast_mmaped_file_rs/src/testhelper.rs +222 -0
  35. data/ext/fast_mmaped_file_rs/src/util.rs +121 -0
  36. data/lib/2.7/fast_mmaped_file.so +0 -0
  37. data/lib/2.7/fast_mmaped_file_rs.so +0 -0
  38. data/lib/3.0/fast_mmaped_file.so +0 -0
  39. data/lib/3.0/fast_mmaped_file_rs.so +0 -0
  40. data/lib/3.1/fast_mmaped_file.so +0 -0
  41. data/lib/3.1/fast_mmaped_file_rs.so +0 -0
  42. data/lib/3.2/fast_mmaped_file.so +0 -0
  43. data/lib/3.2/fast_mmaped_file_rs.so +0 -0
  44. data/lib/prometheus/client/configuration.rb +23 -0
  45. data/lib/prometheus/client/counter.rb +27 -0
  46. data/lib/prometheus/client/formats/text.rb +118 -0
  47. data/lib/prometheus/client/gauge.rb +40 -0
  48. data/lib/prometheus/client/helper/entry_parser.rb +132 -0
  49. data/lib/prometheus/client/helper/file_locker.rb +50 -0
  50. data/lib/prometheus/client/helper/json_parser.rb +23 -0
  51. data/lib/prometheus/client/helper/metrics_processing.rb +45 -0
  52. data/lib/prometheus/client/helper/metrics_representation.rb +51 -0
  53. data/lib/prometheus/client/helper/mmaped_file.rb +64 -0
  54. data/lib/prometheus/client/helper/plain_file.rb +29 -0
  55. data/lib/prometheus/client/histogram.rb +80 -0
  56. data/lib/prometheus/client/label_set_validator.rb +86 -0
  57. data/lib/prometheus/client/metric.rb +80 -0
  58. data/lib/prometheus/client/mmaped_dict.rb +79 -0
  59. data/lib/prometheus/client/mmaped_value.rb +154 -0
  60. data/lib/prometheus/client/page_size.rb +17 -0
  61. data/lib/prometheus/client/push.rb +203 -0
  62. data/lib/prometheus/client/rack/collector.rb +88 -0
  63. data/lib/prometheus/client/rack/exporter.rb +96 -0
  64. data/lib/prometheus/client/registry.rb +65 -0
  65. data/lib/prometheus/client/simple_value.rb +31 -0
  66. data/lib/prometheus/client/summary.rb +69 -0
  67. data/lib/prometheus/client/support/unicorn.rb +35 -0
  68. data/lib/prometheus/client/uses_value_type.rb +20 -0
  69. data/lib/prometheus/client/version.rb +5 -0
  70. data/lib/prometheus/client.rb +58 -0
  71. data/lib/prometheus.rb +3 -0
  72. data/vendor/c/hashmap/.gitignore +52 -0
  73. data/vendor/c/hashmap/LICENSE +21 -0
  74. data/vendor/c/hashmap/README.md +90 -0
  75. data/vendor/c/hashmap/_config.yml +1 -0
  76. data/vendor/c/hashmap/src/hashmap.c +692 -0
  77. data/vendor/c/hashmap/src/hashmap.h +267 -0
  78. data/vendor/c/hashmap/test/Makefile +22 -0
  79. data/vendor/c/hashmap/test/hashmap_test.c +608 -0
  80. data/vendor/c/jsmn/.travis.yml +4 -0
  81. data/vendor/c/jsmn/LICENSE +20 -0
  82. data/vendor/c/jsmn/Makefile +41 -0
  83. data/vendor/c/jsmn/README.md +168 -0
  84. data/vendor/c/jsmn/example/jsondump.c +126 -0
  85. data/vendor/c/jsmn/example/simple.c +76 -0
  86. data/vendor/c/jsmn/jsmn.c +314 -0
  87. data/vendor/c/jsmn/jsmn.h +76 -0
  88. data/vendor/c/jsmn/library.json +16 -0
  89. data/vendor/c/jsmn/test/test.h +27 -0
  90. data/vendor/c/jsmn/test/tests.c +407 -0
  91. data/vendor/c/jsmn/test/testutil.h +94 -0
  92. metadata +243 -0
@@ -0,0 +1,608 @@
1
+ /*
2
+ * Copyright (c) 2016-2017 David Leeds <davidesleeds@gmail.com>
3
+ *
4
+ * Hashmap is free software; you can redistribute it and/or modify
5
+ * it under the terms of the MIT license. See LICENSE for details.
6
+ */
7
+
8
+ #include <stdio.h>
9
+ #include <stdlib.h>
10
+ #include <stdint.h>
11
+ #include <stdbool.h>
12
+ #include <string.h>
13
+ #include <time.h>
14
+ #include <assert.h>
15
+
16
+ #include <hashmap.h>
17
+
18
+ #define ARRAY_LEN(array) (sizeof(array) / sizeof(array[0]))
19
+
20
+ #define TEST_NUM_KEYS 196607 /* Results in max load factor */
21
+ #define TEST_KEY_STR_LEN 32
22
+
23
+ void **keys_str_random;
24
+ void **keys_str_sequential;
25
+ void **keys_int_random;
26
+ void **keys_int_sequential;
27
+
28
+ struct hashmap str_map;
29
+ struct hashmap int_map;
30
+
31
+ struct test {
32
+ const char *name;
33
+ const char *description;
34
+ bool (*run)(struct hashmap *map, void **keys);
35
+ bool pre_load;
36
+ };
37
+
38
+ /*
39
+ * Test type-specific generation macros
40
+ */
41
+ HASHMAP_FUNCS_DECLARE(test, const void, void)
42
+ HASHMAP_FUNCS_CREATE(test, const void, void)
43
+
44
+
45
+ uint64_t test_time_us(void)
46
+ {
47
+ struct timespec now;
48
+
49
+ if (clock_gettime(CLOCK_MONOTONIC, &now)) {
50
+ assert(0);
51
+ }
52
+ return ((uint64_t)now.tv_sec) * 1000000 + (uint64_t)(now.tv_nsec / 1000);
53
+ }
54
+
55
+ void **test_keys_alloc(size_t num)
56
+ {
57
+ void **keys;
58
+
59
+ keys = (void **)calloc(num, sizeof(void *));
60
+ if (!keys) {
61
+ printf("malloc failed\n");
62
+ exit(1);
63
+ }
64
+ return keys;
65
+ }
66
+
67
+ void *test_key_alloc_random_str(void)
68
+ {
69
+ size_t i;
70
+ unsigned num;
71
+ char *key;
72
+
73
+ key = (char *)malloc(TEST_KEY_STR_LEN + 1);
74
+ if (!key) {
75
+ printf("malloc failed\n");
76
+ exit(1);
77
+ }
78
+ for (i = 0; i < TEST_KEY_STR_LEN; ++i) {
79
+ num = random();
80
+ num = (num % 96) + 32; /* ASCII printable only */
81
+ key[i] = (char)num;
82
+ }
83
+ key[TEST_KEY_STR_LEN] = '\0';
84
+ return key;
85
+ }
86
+ void *test_key_alloc_random_int(void)
87
+ {
88
+ uint64_t *key;
89
+
90
+ key = (uint64_t *)malloc(sizeof(*key));
91
+ if (!key) {
92
+ printf("malloc failed\n");
93
+ exit(1);
94
+ }
95
+ /* RAND_MAX is not guaranteed to be more than 32K */
96
+ *key = (uint64_t)(random() & 0xffff) << 48 |
97
+ (uint64_t)(random() & 0xffff) << 32 |
98
+ (uint64_t)(random() & 0xffff) << 16 |
99
+ (uint64_t)(random() & 0xffff);
100
+ return key;
101
+ }
102
+
103
+ void *test_key_alloc_sequential_str(size_t index)
104
+ {
105
+ char *key;
106
+
107
+ key = (char *)malloc(TEST_KEY_STR_LEN + 1);
108
+ if (!key) {
109
+ printf("malloc failed\n");
110
+ exit(1);
111
+ }
112
+ snprintf(key, TEST_KEY_STR_LEN + 1, "sequential key! %010zu", index);
113
+ return key;
114
+ }
115
+
116
+ void *test_key_alloc_sequential_int(size_t index)
117
+ {
118
+ uint64_t *key;
119
+
120
+ key = (uint64_t *)malloc(sizeof(*key));
121
+ if (!key) {
122
+ printf("malloc failed\n");
123
+ exit(1);
124
+ }
125
+ *key = index;
126
+ return key;
127
+ }
128
+
129
+ void test_keys_generate(void)
130
+ {
131
+ size_t i;
132
+
133
+ srandom(99); /* Use reproducible random sequences */
134
+
135
+ keys_str_random = test_keys_alloc(TEST_NUM_KEYS + 1);
136
+ keys_str_sequential = test_keys_alloc(TEST_NUM_KEYS + 1);
137
+ keys_int_random = test_keys_alloc(TEST_NUM_KEYS + 1);
138
+ keys_int_sequential = test_keys_alloc(TEST_NUM_KEYS + 1);
139
+ for (i = 0; i < TEST_NUM_KEYS; ++i) {
140
+ keys_str_random[i] = test_key_alloc_random_str();
141
+ keys_str_sequential[i] = test_key_alloc_sequential_str(i);
142
+ keys_int_random[i] = test_key_alloc_random_int();
143
+ keys_int_sequential[i] = test_key_alloc_sequential_int(i);
144
+ }
145
+ keys_str_random[i] = NULL;
146
+ keys_str_sequential[i] = NULL;
147
+ keys_int_random[i] = NULL;
148
+ keys_int_sequential[i] = NULL;
149
+ }
150
+
151
+ void test_load_keys(struct hashmap *map, void **keys)
152
+ {
153
+ void **key;
154
+
155
+ for (key = keys; *key; ++key) {
156
+ if (!test_hashmap_put(map, *key, *key)) {
157
+ printf("hashmap_put() failed");
158
+ exit(1);
159
+ }
160
+ }
161
+ }
162
+
163
+ void test_reset_map(struct hashmap *map)
164
+ {
165
+ hashmap_reset(map);
166
+ }
167
+
168
+ void test_print_stats(struct hashmap *map, const char *label)
169
+ {
170
+ printf("Hashmap stats: %s\n", label);
171
+ printf(" # entries: %zu\n", hashmap_size(map));
172
+ printf(" Table size: %zu\n", map->table_size);
173
+ printf(" Load factor: %.4f\n", hashmap_load_factor(map));
174
+ printf(" Collisions mean: %.4f\n", hashmap_collisions_mean(map));
175
+ printf(" Collisions variance: %.4f\n",
176
+ hashmap_collisions_variance(map));
177
+
178
+ }
179
+
180
+ bool test_run(struct hashmap *map, void **keys, const struct test *t)
181
+ {
182
+ bool success;
183
+ uint64_t time_us;
184
+
185
+ assert(t != NULL);
186
+ assert(t->name != NULL);
187
+ assert(t->run != NULL);
188
+
189
+ if (t->pre_load) {
190
+ printf("Pre-loading keys...");
191
+ test_load_keys(map, keys);
192
+ printf("done\n");
193
+ }
194
+ printf("Running...\n");
195
+ time_us = test_time_us();
196
+ success = t->run(map, keys);
197
+ time_us = test_time_us() - time_us;
198
+ if (success) {
199
+ printf("Completed successfully\n");
200
+ } else {
201
+ printf("Failed\n");
202
+ }
203
+ printf("Run time: %llu microseconds\n", (long long unsigned)time_us);
204
+ test_print_stats(map, t->name);
205
+ test_reset_map(map);
206
+ return success;
207
+ }
208
+
209
+ bool test_run_all(struct hashmap *map, void **keys,
210
+ const struct test *tests, size_t num_tests, const char *env)
211
+ {
212
+ const struct test *t;
213
+ size_t num_failed = 0;
214
+
215
+ printf("\n**************************************************\n");
216
+ printf("Starting test series:\n");
217
+ printf(" %s\n", env);
218
+ printf("**************************************************\n\n");
219
+ for (t = tests; t < &tests[num_tests]; ++t) {
220
+ printf("\n**************************************************"
221
+ "\n");
222
+ printf("Test %02u: %s\n", (unsigned)(t - tests) + 1, t->name);
223
+ if (t->description) {
224
+ printf(" Description: %s\n", t->description);
225
+ }
226
+ printf("\n");
227
+ if (!test_run(map, keys, t)) {
228
+ ++num_failed;
229
+ }
230
+ }
231
+ printf("\n**************************************************\n");
232
+ printf("Test results:\n");
233
+ printf(" Passed: %zu\n", num_tests - num_failed);
234
+ printf(" Failed: %zu\n", num_failed);
235
+ printf("**************************************************\n");
236
+ return (num_failed == 0);
237
+ }
238
+
239
+ size_t test_hash_uint64(const void *key)
240
+ {
241
+ const uint8_t *byte = (const uint8_t *)key;
242
+ uint8_t i;
243
+ size_t hash = 0;
244
+
245
+ for (i = 0; i < sizeof(uint64_t); ++i, ++byte) {
246
+ hash += *byte;
247
+ hash += (hash << 10);
248
+ hash ^= (hash >> 6);
249
+ }
250
+ hash += (hash << 3);
251
+ hash ^= (hash >> 11);
252
+ hash += (hash << 15);
253
+ return hash;
254
+ }
255
+
256
+ int test_compare_uint64(const void *a, const void *b)
257
+ {
258
+ return *(int64_t *)a - *(int64_t *)b;
259
+ }
260
+
261
+ bool test_put(struct hashmap *map, void **keys)
262
+ {
263
+ void **key;
264
+ void *data;
265
+
266
+ for (key = keys; *key; ++key) {
267
+ data = test_hashmap_put(map, *key, *key);
268
+ if (!data) {
269
+ printf("malloc failed\n");
270
+ exit(1);
271
+ }
272
+ if (data != *key) {
273
+ printf("duplicate key found\n");
274
+ return false;
275
+ }
276
+ }
277
+ return true;
278
+ }
279
+
280
+ bool test_put_existing(struct hashmap *map, void **keys)
281
+ {
282
+ void **key;
283
+ void *data;
284
+ int temp_data = 99;
285
+
286
+ for (key = keys; *key; ++key) {
287
+ data = hashmap_put(map, *key, &temp_data);
288
+ if (!data) {
289
+ printf("malloc failed\n");
290
+ exit(1);
291
+ }
292
+ if (data != *key) {
293
+ printf("did not return existing data\n");
294
+ return false;
295
+ }
296
+ }
297
+ return true;
298
+ }
299
+
300
+ bool test_get(struct hashmap *map, void **keys)
301
+ {
302
+ void **key;
303
+ void *data;
304
+
305
+ for (key = keys; *key; ++key) {
306
+ data = test_hashmap_get(map, *key);
307
+ if (!data) {
308
+ printf("entry not found\n");
309
+ return false;
310
+ }
311
+ if (data != *key) {
312
+ printf("got wrong entry\n");
313
+ return false;
314
+ }
315
+ }
316
+ return true;
317
+ }
318
+
319
+ bool test_get_nonexisting(struct hashmap *map, void **keys)
320
+ {
321
+ void **key;
322
+ void *data;
323
+ const char *fake_key = "test_get_nonexisting fake key!";
324
+
325
+ for (key = keys; *key; ++key) {
326
+ data = hashmap_get(map, fake_key);
327
+ if (data) {
328
+ printf("unexpected entry found\n");
329
+ return false;
330
+ }
331
+ }
332
+ return true;
333
+ }
334
+
335
+ bool test_remove(struct hashmap *map, void **keys)
336
+ {
337
+ void **key;
338
+ void *data;
339
+
340
+ for (key = keys; *key; ++key) {
341
+ data = test_hashmap_remove(map, *key);
342
+ if (!data) {
343
+ printf("entry not found\n");
344
+ return false;
345
+ }
346
+ if (data != *key) {
347
+ printf("removed wrong entry\n");
348
+ return false;
349
+ }
350
+ }
351
+ return true;
352
+ }
353
+
354
+ bool test_put_remove(struct hashmap *map, void **keys)
355
+ {
356
+ size_t i = 0;
357
+ void **key;
358
+ void *data;
359
+
360
+ if (!test_put(map, keys)) {
361
+ return false;
362
+ }
363
+ for (key = keys; *key; ++key) {
364
+ if (i++ >= TEST_NUM_KEYS / 2) {
365
+ break;
366
+ }
367
+ data = test_hashmap_remove(map, *key);
368
+ if (!data) {
369
+ printf("key not found\n");
370
+ return false;
371
+ }
372
+ if (data != *key) {
373
+ printf("removed wrong entry\n");
374
+ return false;
375
+ }
376
+ }
377
+ test_print_stats(map, "test_put_remove done");
378
+ i = 0;
379
+ for (key = keys; *key; ++key) {
380
+ if (i++ >= TEST_NUM_KEYS / 2) {
381
+ break;
382
+ }
383
+ data = test_hashmap_put(map, *key, *key);
384
+ if (!data) {
385
+ printf("malloc failed\n");
386
+ exit(1);
387
+ }
388
+ if (data != *key) {
389
+ printf("duplicate key found\n");
390
+ return false;
391
+ }
392
+ }
393
+ return true;
394
+ }
395
+
396
+ bool test_iterate(struct hashmap *map, void **keys)
397
+ {
398
+ size_t i = 0;
399
+ struct hashmap_iter *iter = hashmap_iter(map);
400
+
401
+ for (; iter; iter = hashmap_iter_next(map, iter)) {
402
+ ++i;
403
+ }
404
+ if (i != TEST_NUM_KEYS) {
405
+ printf("did not iterate through all entries: "
406
+ "observed %zu, expected %u\n", i, TEST_NUM_KEYS);
407
+ return false;
408
+ }
409
+ return true;
410
+ }
411
+
412
+ bool test_iterate_remove(struct hashmap *map, void **keys)
413
+ {
414
+ size_t i = 0;
415
+ struct hashmap_iter *iter = hashmap_iter(map);
416
+ const void *key;
417
+
418
+ while (iter) {
419
+ ++i;
420
+ key = test_hashmap_iter_get_key(iter);
421
+ if (test_hashmap_get(map, key) != key) {
422
+ printf("invalid iterator on entry #%zu\n", i);
423
+ return false;
424
+ }
425
+ iter = hashmap_iter_remove(map, iter);
426
+ if (test_hashmap_get(map, key) != NULL) {
427
+ printf("iter_remove failed on entry #%zu\n", i);
428
+ return false;
429
+ }
430
+ }
431
+ if (i != TEST_NUM_KEYS) {
432
+ printf("did not iterate through all entries: "
433
+ "observed %zu, expected %u\n", i, TEST_NUM_KEYS);
434
+ return false;
435
+ }
436
+ return true;
437
+ }
438
+
439
+ struct test_foreach_arg {
440
+ struct hashmap *map;
441
+ size_t i;
442
+ };
443
+
444
+ int test_foreach_callback(const void *key, void *data, void *arg)
445
+ {
446
+ struct test_foreach_arg *state = (struct test_foreach_arg *)arg;
447
+
448
+ if (state->i & 1) {
449
+ /* Remove every other key */
450
+ if (!test_hashmap_remove(state->map, key)) {
451
+ printf("could not remove expected key\n");
452
+ return -1;
453
+ }
454
+ }
455
+ ++state->i;
456
+ return 0;
457
+ }
458
+
459
+ bool test_foreach(struct hashmap *map, void **keys)
460
+ {
461
+ struct test_foreach_arg arg = { map, 1 };
462
+ size_t size = hashmap_size(map);
463
+
464
+ if (test_hashmap_foreach(map, test_foreach_callback, &arg) < 0) {
465
+ return false;
466
+ }
467
+ if (hashmap_size(map) != size / 2) {
468
+ printf("foreach delete did not remove expected # of entries: "
469
+ "contains %zu vs. expected %zu\n", hashmap_size(map),
470
+ size / 2);
471
+ return false;
472
+ }
473
+ return true;
474
+ }
475
+
476
+ bool test_clear(struct hashmap *map, void **keys)
477
+ {
478
+ hashmap_clear(map);
479
+ return true;
480
+ }
481
+
482
+ bool test_reset(struct hashmap *map, void **keys)
483
+ {
484
+ hashmap_reset(map);
485
+ return true;
486
+ }
487
+
488
+ const struct test const tests[] = {
489
+ {
490
+ .name = "put performance",
491
+ .description = "put new hash keys",
492
+ .run = test_put
493
+ },
494
+ {
495
+ .name = "put existing performance",
496
+ .description = "attempt to put existing hash keys",
497
+ .run = test_put_existing,
498
+ .pre_load = true
499
+ },
500
+ {
501
+ .name = "get existing performance",
502
+ .description = "get existing hash keys",
503
+ .run = test_get,
504
+ .pre_load = true
505
+ },
506
+ {
507
+ .name = "get non-existing performance",
508
+ .description = "get nonexistent hash keys",
509
+ .run = test_get_nonexisting,
510
+ .pre_load = true
511
+ },
512
+ {
513
+ .name = "remove performance",
514
+ .description = "remove hash keys",
515
+ .run = test_remove,
516
+ .pre_load = true
517
+ },
518
+ {
519
+ .name = "mixed put/remove performance",
520
+ .description = "put, remove 1/2, then put them back",
521
+ .run = test_put_remove
522
+ },
523
+ {
524
+ .name = "iterate performance",
525
+ .description = "iterate through entries",
526
+ .run = test_iterate,
527
+ .pre_load = true
528
+ },
529
+ {
530
+ .name = "iterate remove all",
531
+ .description = "iterate and remove all entries",
532
+ .run = test_iterate_remove,
533
+ .pre_load = true
534
+ },
535
+ {
536
+ .name = "removal in foreach",
537
+ .description = "iterate and delete 1/2 using hashmap_foreach",
538
+ .run = test_foreach,
539
+ .pre_load = true
540
+ },
541
+ {
542
+ .name = "clear performance",
543
+ .description = "clear entries",
544
+ .run = test_clear,
545
+ .pre_load = true
546
+ },
547
+ {
548
+ .name = "reset performance",
549
+ .description = "reset entries",
550
+ .run = test_reset,
551
+ .pre_load = true
552
+ }
553
+ };
554
+
555
+ /*
556
+ * Main function
557
+ */
558
+ int main(int argc, char **argv)
559
+ {
560
+ bool success = true;
561
+
562
+ /* Initialize */
563
+ printf("Initializing hash maps...");
564
+ if (hashmap_init(&str_map, hashmap_hash_string, hashmap_compare_string,
565
+ 0) < 0) {
566
+ success = false;
567
+ }
568
+ /*
569
+ hashmap_set_key_alloc_funcs(&str_map, hashmap_alloc_key_string, free);
570
+ */
571
+ if (hashmap_init(&int_map, test_hash_uint64, test_compare_uint64,
572
+ 0) < 0) {
573
+ success = false;
574
+ }
575
+ printf("done\n");
576
+
577
+ if (!success) {
578
+ printf("Hashmap init failed");
579
+ return 1;
580
+ }
581
+
582
+ printf("Generating test %u test keys...", TEST_NUM_KEYS);
583
+ test_keys_generate();
584
+ printf("done\n");
585
+
586
+ printf("Running tests\n\n");
587
+ success &= test_run_all(&str_map, keys_str_random, tests,
588
+ ARRAY_LEN(tests), "Hashmap w/randomized string keys");
589
+ success &= test_run_all(&str_map, keys_str_sequential, tests,
590
+ ARRAY_LEN(tests), "Hashmap w/sequential string keys");
591
+
592
+ success &= test_run_all(&int_map, keys_int_random, tests,
593
+ ARRAY_LEN(tests), "Hashmap w/randomized integer keys");
594
+
595
+ success &= test_run_all(&int_map, keys_int_sequential, tests,
596
+ ARRAY_LEN(tests), "Hashmap w/sequential integer keys");
597
+
598
+ printf("\nTests finished\n");
599
+
600
+ hashmap_destroy(&str_map);
601
+ hashmap_destroy(&int_map);
602
+
603
+ if (!success) {
604
+ printf("Tests FAILED\n");
605
+ exit(1);
606
+ }
607
+ return 0;
608
+ }
@@ -0,0 +1,4 @@
1
+ language: c
2
+ sudo: false
3
+ script:
4
+ - make test
@@ -0,0 +1,20 @@
1
+ Copyright (c) 2010 Serge A. Zaitsev
2
+
3
+ Permission is hereby granted, free of charge, to any person obtaining a copy
4
+ of this software and associated documentation files (the "Software"), to deal
5
+ in the Software without restriction, including without limitation the rights
6
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7
+ copies of the Software, and to permit persons to whom the Software is
8
+ furnished to do so, subject to the following conditions:
9
+
10
+ The above copyright notice and this permission notice shall be included in
11
+ all copies or substantial portions of the Software.
12
+
13
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19
+ THE SOFTWARE.
20
+
@@ -0,0 +1,41 @@
1
+ # You can put your build options here
2
+ -include config.mk
3
+
4
+ all: libjsmn.a
5
+
6
+ libjsmn.a: jsmn.o
7
+ $(AR) rc $@ $^
8
+
9
+ %.o: %.c jsmn.h
10
+ $(CC) -c $(CFLAGS) $< -o $@
11
+
12
+ test: test_default test_strict test_links test_strict_links
13
+ test_default: test/tests.c
14
+ $(CC) $(CFLAGS) $(LDFLAGS) $< -o test/$@
15
+ ./test/$@
16
+ test_strict: test/tests.c
17
+ $(CC) -DJSMN_STRICT=1 $(CFLAGS) $(LDFLAGS) $< -o test/$@
18
+ ./test/$@
19
+ test_links: test/tests.c
20
+ $(CC) -DJSMN_PARENT_LINKS=1 $(CFLAGS) $(LDFLAGS) $< -o test/$@
21
+ ./test/$@
22
+ test_strict_links: test/tests.c
23
+ $(CC) -DJSMN_STRICT=1 -DJSMN_PARENT_LINKS=1 $(CFLAGS) $(LDFLAGS) $< -o test/$@
24
+ ./test/$@
25
+
26
+ jsmn_test.o: jsmn_test.c libjsmn.a
27
+
28
+ simple_example: example/simple.o libjsmn.a
29
+ $(CC) $(LDFLAGS) $^ -o $@
30
+
31
+ jsondump: example/jsondump.o libjsmn.a
32
+ $(CC) $(LDFLAGS) $^ -o $@
33
+
34
+ clean:
35
+ rm -f *.o example/*.o
36
+ rm -f *.a *.so
37
+ rm -f simple_example
38
+ rm -f jsondump
39
+
40
+ .PHONY: all clean test
41
+