source: trunk/libtransmission/utils-test.c

Last change on this file was 14721, checked in by jordan, 5 years ago

fix a handful of minor compiler warnings, mostly in the unit tests, eg field width shortening or implicit signed/unsigned conversions

  • Property svn:keywords set to Date Rev Author Id
File size: 12.0 KB
Line 
1/*
2 * This file Copyright (C) 2013-2014 Mnemosyne LLC
3 *
4 * It may be used under the GNU GPL versions 2 or 3
5 * or any future license endorsed by Mnemosyne LLC.
6 *
7 * $Id: utils-test.c 14721 2016-03-29 03:04:54Z mikedld $
8 */
9
10#include <limits.h> /* INT_MAX */
11#include <math.h> /* sqrt () */
12#include <string.h> /* strlen () */
13#include <stdlib.h> /* setenv (), unsetenv () */
14
15#ifdef _WIN32
16 #include <windows.h>
17 #define setenv(key, value, unused) SetEnvironmentVariableA (key, value)
18 #define unsetenv(key) SetEnvironmentVariableA (key, NULL)
19#endif
20
21#include "transmission.h"
22#include "ConvertUTF.h" /* tr_utf8_validate*/
23#include "platform.h"
24#include "crypto-utils.h" /* tr_rand_int_weak */
25#include "utils.h"
26#include "web.h"
27
28#define SPEED_TEST 0
29
30#if SPEED_TEST
31 #define VERBOSE
32#endif
33
34#include "libtransmission-test.h"
35
36static int
37test_strip_positional_args (void)
38{
39  const char * in;
40  const char * out;
41  const char * expected;
42
43  in = "Hello %1$s foo %2$.*f";
44  expected = "Hello %s foo %.*f";
45  out = tr_strip_positional_args (in);
46  check_streq (expected, out);
47
48  in = "Hello %1$'d foo %2$'f";
49  expected = "Hello %d foo %f";
50  out = tr_strip_positional_args (in);
51  check_streq (expected, out);
52
53  return 0;
54}
55
56static int
57test_strstrip (void)
58{
59  char *in, *out;
60
61  /* strstrip */
62  in = tr_strdup ("   test    ");
63  out = tr_strstrip (in);
64  check (in == out);
65  check_streq ("test", out);
66  tr_free (in);
67
68  /* strstrip */
69  in = tr_strdup (" test test ");
70  out = tr_strstrip (in);
71  check (in == out);
72  check_streq ("test test", out);
73  tr_free (in);
74
75  /* strstrip */
76  in = tr_strdup ("test");
77  out = tr_strstrip (in);
78  check (in == out);
79  check_streq ("test", out);
80  tr_free (in);
81
82  return 0;
83}
84
85static int
86test_buildpath (void)
87{
88  char * out;
89
90  out = tr_buildPath ("foo", "bar", NULL);
91  check_streq ("foo" TR_PATH_DELIMITER_STR "bar", out);
92  tr_free (out);
93
94  out = tr_buildPath ("", "foo", "bar", NULL);
95  check_streq (TR_PATH_DELIMITER_STR "foo" TR_PATH_DELIMITER_STR "bar", out);
96  tr_free (out);
97
98  return 0;
99}
100
101static int
102test_utf8 (void)
103{
104  const char * in;
105  char * out;
106
107  in = "hello world";
108  out = tr_utf8clean (in, TR_BAD_SIZE);
109  check_streq (in, out);
110  tr_free (out);
111
112  in = "hello world";
113  out = tr_utf8clean (in, 5);
114  check_streq ("hello", out);
115  tr_free (out);
116
117  /* this version is not utf-8 (but cp866) */
118  in = "\x92\xE0\xE3\xA4\xAD\xAE \xA1\xEB\xE2\xEC \x81\xAE\xA3\xAE\xAC";
119  out = tr_utf8clean (in, 17);
120  check (out != NULL);
121  check ((strlen (out) == 17) || (strlen (out) == 33));
122  check (tr_utf8_validate (out, TR_BAD_SIZE, NULL));
123  tr_free (out);
124
125  /* same string, but utf-8 clean */
126  in = "ТруЎМП быть БПгПЌ";
127  out = tr_utf8clean (in, TR_BAD_SIZE);
128  check (out != NULL);
129  check (tr_utf8_validate (out, TR_BAD_SIZE, NULL));
130  check_streq (in, out);
131  tr_free (out);
132
133  in = "\xF4\x00\x81\x82";
134  out = tr_utf8clean (in, 4);
135  check (out != NULL);
136  check ((strlen (out) == 1) || (strlen (out) == 2));
137  check (tr_utf8_validate (out, TR_BAD_SIZE, NULL));
138  tr_free (out);
139
140  in = "\xF4\x33\x81\x82";
141  out = tr_utf8clean (in, 4);
142  check (out != NULL);
143  check ((strlen (out) == 4) || (strlen (out) == 7));
144  check (tr_utf8_validate (out, TR_BAD_SIZE, NULL));
145  tr_free (out);
146
147  return 0;
148}
149
150static int
151test_numbers (void)
152{
153  int i;
154  int count;
155  int * numbers;
156
157  numbers = tr_parseNumberRange ("1-10,13,16-19", TR_BAD_SIZE, &count);
158  check_int_eq (15, count);
159  check_int_eq (1, numbers[0]);
160  check_int_eq (6, numbers[5]);
161  check_int_eq (10, numbers[9]);
162  check_int_eq (13, numbers[10]);
163  check_int_eq (16, numbers[11]);
164  check_int_eq (19, numbers[14]);
165  tr_free (numbers);
166
167  numbers = tr_parseNumberRange ("1-5,3-7,2-6", TR_BAD_SIZE, &count);
168  check (count == 7);
169  check (numbers != NULL);
170  for (i=0; i<count; ++i)
171    check_int_eq (i+1, numbers[i]);
172  tr_free (numbers);
173
174  numbers = tr_parseNumberRange ("1-Hello", TR_BAD_SIZE, &count);
175  check_int_eq (0, count);
176  check (numbers == NULL);
177
178  numbers = tr_parseNumberRange ("1-", TR_BAD_SIZE, &count);
179  check_int_eq (0, count);
180  check (numbers == NULL);
181
182  numbers = tr_parseNumberRange ("Hello", TR_BAD_SIZE, &count);
183  check_int_eq (0, count);
184  check (numbers == NULL);
185
186  return 0;
187}
188
189static int
190compareInts (const void * va, const void * vb)
191{
192  const int a = *(const int *)va;
193  const int b = *(const int *)vb;
194  return a - b;
195}
196
197static int
198test_lowerbound (void)
199{
200  int i;
201  const int A[] = { 1, 2, 3, 3, 3, 5, 8 };
202  const int expected_pos[] = { 0, 1, 2, 5, 5, 6, 6, 6, 7, 7 };
203  const bool expected_exact[] = { true, true, true, false, true, false, false, true, false, false };
204  const int N = sizeof (A) / sizeof (A[0]);
205
206  for (i=1; i<=10; i++)
207    {
208      bool exact;
209      const int pos = tr_lowerBound (&i, A, N, sizeof (int), compareInts, &exact);
210
211#if 0
212      fprintf (stderr, "searching for %d. ", i);
213      fprintf (stderr, "result: index = %d, ", pos);
214      if (pos != N)
215        fprintf (stderr, "A[%d] == %d\n", pos, A[pos]);
216      else
217        fprintf (stderr, "which is off the end.\n");
218#endif
219      check_int_eq (expected_pos[i-1], pos);
220      check_int_eq (expected_exact[i-1], exact);
221    }
222
223  return 0;
224}
225
226static int
227test_quickFindFirst_Iteration (const size_t k, const size_t n, int * buf, int range)
228{
229  size_t i;
230  int highest_low;
231  int lowest_high;
232
233  /* populate buf with random ints */
234  for (i=0; i<n; ++i)
235    buf[i] = tr_rand_int_weak (range);
236
237  /* find the best k */
238  tr_quickfindFirstK (buf, n, sizeof(int), compareInts, k);
239
240  /* confirm that the smallest K ints are in the first slots K slots in buf */
241
242  highest_low = INT_MIN;
243  for (i=0; i<k; ++i)
244    if (highest_low < buf[i])
245      highest_low = buf[i];
246
247  lowest_high = INT_MAX;
248  for (i=k; i<n; ++i)
249    if (lowest_high > buf[i])
250      lowest_high = buf[i];
251
252  check (highest_low <= lowest_high);
253
254  return 0;
255}
256
257static int
258test_quickfindFirst (void)
259{
260  size_t i;
261  const size_t k = 10;
262  const size_t n = 100;
263  const size_t n_trials = 1000;
264  int * buf = tr_new (int, n);
265
266  for (i=0; i<n_trials; ++i)
267    check_int_eq (0, test_quickFindFirst_Iteration (k, n, buf, 100));
268
269  tr_free (buf);
270  return 0;
271}
272
273static int
274test_memmem (void)
275{
276  char const haystack[12] = "abcabcabcabc";
277  char const needle[3] = "cab";
278
279  check (tr_memmem (haystack, sizeof haystack, haystack, sizeof haystack) == haystack);
280  check (tr_memmem (haystack, sizeof haystack, needle, sizeof needle) == haystack + 2);
281  check (tr_memmem (needle, sizeof needle, haystack, sizeof haystack) == NULL);
282
283  return 0;
284}
285
286static int
287test_hex (void)
288{
289  char hex1[41];
290  char hex2[41];
291  uint8_t binary[20];
292
293  memcpy (hex1, "fb5ef5507427b17e04b69cef31fa3379b456735a", 41);
294  tr_hex_to_binary (hex1, binary, 20);
295  tr_binary_to_hex (binary, hex2, 20);
296  check_streq (hex1, hex2);
297
298  return 0;
299}
300
301static int
302test_array (void)
303{
304  size_t i;
305  size_t array[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
306  size_t n = sizeof (array) / sizeof (array[0]);
307
308  tr_removeElementFromArray (array, 5u, sizeof (size_t), n--);
309  for (i=0; i<n; ++i)
310    check_int_eq ((i<5 ? i : i+1), array[i]);
311
312  tr_removeElementFromArray (array, 0u, sizeof (size_t), n--);
313  for (i=0; i<n; ++i)
314    check_int_eq ((i<4 ? i+1 : i+2), array[i]);
315
316  tr_removeElementFromArray (array, n-1, sizeof (size_t), n); n--;
317  for (i=0; i<n; ++i)
318    check_int_eq ((i<4 ? i+1 : i+2), array[i]);
319
320  return 0;
321}
322
323static int
324test_url (void)
325{
326  int port;
327  char * scheme;
328  char * host;
329  char * path;
330  char * str;
331  const char * url;
332
333  url = "http://1";
334  check (tr_urlParse (url, TR_BAD_SIZE, &scheme, &host, &port, &path));
335  check_streq ("http", scheme);
336  check_streq ("1", host);
337  check_streq ("/", path);
338  check_int_eq (80, port);
339  tr_free (scheme);
340  tr_free (path);
341  tr_free (host);
342
343  url = "http://www.some-tracker.org/some/path";
344  check (tr_urlParse (url, TR_BAD_SIZE, &scheme, &host, &port, &path));
345  check_streq ("http", scheme);
346  check_streq ("www.some-tracker.org", host);
347  check_streq ("/some/path", path);
348  check_int_eq (80, port);
349  tr_free (scheme);
350  tr_free (path);
351  tr_free (host);
352
353  url = "http://www.some-tracker.org:80/some/path";
354  check (tr_urlParse (url, TR_BAD_SIZE, &scheme, &host, &port, &path));
355  check_streq ("http", scheme);
356  check_streq ("www.some-tracker.org", host);
357  check_streq ("/some/path", path);
358  check_int_eq (80, port);
359  tr_free (scheme);
360  tr_free (path);
361  tr_free (host);
362
363  url = "http%3A%2F%2Fwww.example.com%2F~user%2F%3Ftest%3D1%26test1%3D2";
364  str = tr_http_unescape (url, strlen (url));
365  check_streq ("http://www.example.com/~user/?test=1&test1=2", str);
366  tr_free (str);
367
368  return 0;
369}
370
371static int
372test_truncd (void)
373{
374  char buf[32];
375  const double nan = sqrt (-1);
376
377  tr_snprintf (buf, sizeof (buf), "%.2f%%", 99.999);
378  check_streq ("100.00%", buf);
379
380  tr_snprintf (buf, sizeof (buf), "%.2f%%", tr_truncd (99.999, 2));
381  check_streq ("99.99%", buf);
382
383  tr_snprintf (buf, sizeof (buf), "%.4f", tr_truncd (403650.656250, 4));
384  check_streq ("403650.6562", buf);
385
386  tr_snprintf (buf, sizeof (buf), "%.2f", tr_truncd (2.15, 2));
387  check_streq ("2.15", buf);
388
389  tr_snprintf (buf, sizeof (buf), "%.2f", tr_truncd (2.05, 2));
390  check_streq ("2.05", buf);
391
392  tr_snprintf (buf, sizeof (buf), "%.2f", tr_truncd (3.3333, 2));
393  check_streq ("3.33", buf);
394
395  tr_snprintf (buf, sizeof (buf), "%.0f", tr_truncd (3.3333, 0));
396  check_streq ("3", buf);
397
398#if !(defined (_MSC_VER) || (defined (__MINGW32__) && defined (__MSVCRT__)))
399  /* FIXME: MSCVRT behaves differently in case of nan */
400  tr_snprintf (buf, sizeof (buf), "%.2f", tr_truncd (nan, 2));
401  check (strstr (buf, "nan") != NULL);
402#else
403  (void) nan;
404#endif
405
406  return 0;
407}
408
409static char *
410test_strdup_printf_valist (const char * fmt, ...)
411{
412  va_list args;
413  char * ret;
414
415  va_start (args, fmt);
416  ret = tr_strdup_vprintf (fmt, args);
417  va_end (args);
418
419  return ret;
420}
421
422static int
423test_strdup_printf (void)
424{
425  char * s, * s2, * s3;
426
427  s = tr_strdup_printf ("%s", "test");
428  check_streq ("test", s);
429  tr_free (s);
430
431  s = tr_strdup_printf ("%d %s %c %u", -1, "0", '1', 2);
432  check_streq ("-1 0 1 2", s);
433  tr_free (s);
434
435  s3 = tr_malloc0 (4098);
436  memset (s3, '-', 4097);
437  s3[2047] = 't';
438  s3[2048] = 'e';
439  s3[2049] = 's';
440  s3[2050] = 't';
441
442  s2 = tr_malloc0 (4096);
443  memset (s2, '-', 4095);
444  s2[2047] = '%';
445  s2[2048] = 's';
446
447  s = tr_strdup_printf (s2, "test");
448  check_streq (s3, s);
449  tr_free (s);
450
451  tr_free (s2);
452
453  s = tr_strdup_printf ("%s", s3);
454  check_streq (s3, s);
455  tr_free (s);
456
457  tr_free (s3);
458
459  s = test_strdup_printf_valist ("\n-%s-%s-%s-\n", "\r", "\t", "\b");
460  check_streq ("\n-\r-\t-\b-\n", s);
461  tr_free (s);
462
463  return 0;
464}
465
466static int
467test_env (void)
468{
469  const char * test_key = "TR_TEST_ENV";
470  int x;
471  char * s;
472
473  unsetenv (test_key);
474
475  check (!tr_env_key_exists (test_key));
476  x = tr_env_get_int (test_key, 123);
477  check_int_eq (123, x);
478  s = tr_env_get_string (test_key, NULL);
479  check (s == NULL);
480  s = tr_env_get_string (test_key, "a");
481  check_streq ("a", s);
482  tr_free (s);
483
484  setenv (test_key, "", 1);
485
486  check (tr_env_key_exists (test_key));
487  x = tr_env_get_int (test_key, 456);
488  check_int_eq (456, x);
489  s = tr_env_get_string (test_key, NULL);
490  check_streq ("", s);
491  tr_free (s);
492  s = tr_env_get_string (test_key, "b");
493  check_streq ("", s);
494  tr_free (s);
495
496  setenv (test_key, "135", 1);
497
498  check (tr_env_key_exists (test_key));
499  x = tr_env_get_int (test_key, 789);
500  check_int_eq (135, x);
501  s = tr_env_get_string (test_key, NULL);
502  check_streq ("135", s);
503  tr_free (s);
504  s = tr_env_get_string (test_key, "c");
505  check_streq ("135", s);
506  tr_free (s);
507
508  return 0;
509}
510
511int
512main (void)
513{
514  const testFunc tests[] = { test_array,
515                             test_buildpath,
516                             test_hex,
517                             test_lowerbound,
518                             test_quickfindFirst,
519                             test_memmem,
520                             test_numbers,
521                             test_strip_positional_args,
522                             test_strdup_printf,
523                             test_strstrip,
524                             test_truncd,
525                             test_url,
526                             test_utf8,
527                             test_env };
528
529  return runTests (tests, NUM_TESTS (tests));
530}
531
Note: See TracBrowser for help on using the repository browser.