tests/testglib.c

   1 /* GLIB - Library of useful routines for C programming
   2  * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19 #undef G_LOG_DOMAIN
  20
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include "glib.h"
  24
  25 int array[10000];
  26 gboolean failed = FALSE;
  27
  28 #define TEST(m,cond)    G_STMT_START { failed = !(cond); \
  29 if (failed) \
  30   { if (!m) \
  31       g_print ("\n(%s:%d) failed for: %s\n", __FILE__, __LINE__, ( # cond )); \
  32     else \
  33       g_print ("\n(%s:%d) failed for: %s: (%s)\n", __FILE__, __LINE__, ( # cond ), (gchar*)m); \
  34   } \
  35 else \
  36   g_print ("."); fflush (stdout); \
  37 } G_STMT_END
  38
  39 #define C2P(c)          ((gpointer) ((long) (c)))
  40 #define P2C(p)          ((gchar) ((long) (p)))
  41
  42 #define GLIB_TEST_STRING "el dorado "
  43 #define GLIB_TEST_STRING_5 "el do"
  44
  45 static gboolean
  46 node_build_string (GNode    *node,
  47                    gpointer  data)
  48 {
  49   gchar **p = data;
  50   gchar *string;
  51   gchar c[2] = "_";
  52
  53   c[0] = P2C (node->data);
  54
  55   string = g_strconcat (*p ? *p : "", c, NULL);
  56   g_free (*p);
  57   *p = string;
  58
  59   return FALSE;
  60 }
  61
  62 static void
  63 g_node_test (void)
  64 {
  65   GNode *root;
  66   GNode *node;
  67   GNode *node_B;
  68   GNode *node_F;
  69   GNode *node_G;
  70   GNode *node_J;
  71   guint i;
  72   gchar *tstring;
  73
  74   g_print ("checking n-way trees: ");
  75   failed = FALSE;
  76
  77   root = g_node_new (C2P ('A'));
  78   TEST (NULL, g_node_depth (root) == 1 && g_node_max_height (root) == 1);
  79
  80   node_B = g_node_new (C2P ('B'));
  81   g_node_append (root, node_B);
  82   TEST (NULL, root->children == node_B);
  83
  84   g_node_append_data (node_B, C2P ('E'));
  85   g_node_prepend_data (node_B, C2P ('C'));
  86   g_node_insert (node_B, 1, g_node_new (C2P ('D')));
  87
  88   node_F = g_node_new (C2P ('F'));
  89   g_node_append (root, node_F);
  90   TEST (NULL, root->children->next == node_F);
  91
  92   node_G = g_node_new (C2P ('G'));
  93   g_node_append (node_F, node_G);
  94   node_J = g_node_new (C2P ('J'));
  95   g_node_prepend (node_G, node_J);
  96   g_node_insert (node_G, 42, g_node_new (C2P ('K')));
  97   g_node_insert_data (node_G, 0, C2P ('H'));
  98   g_node_insert (node_G, 1, g_node_new (C2P ('I')));
  99
 100   TEST (NULL, g_node_depth (root) == 1);
 101   TEST (NULL, g_node_max_height (root) == 4);
 102   TEST (NULL, g_node_depth (node_G->children->next) == 4);
 103   TEST (NULL, g_node_n_nodes (root, G_TRAVERSE_LEAFS) == 7);
 104   TEST (NULL, g_node_n_nodes (root, G_TRAVERSE_NON_LEAFS) == 4);
 105   TEST (NULL, g_node_n_nodes (root, G_TRAVERSE_ALL) == 11);
 106   TEST (NULL, g_node_max_height (node_F) == 3);
 107   TEST (NULL, g_node_n_children (node_G) == 4);
 108   TEST (NULL, g_node_find_child (root, G_TRAVERSE_ALL, C2P ('F')) == node_F);
 109   TEST (NULL, g_node_find (root, G_LEVEL_ORDER, G_TRAVERSE_NON_LEAFS, C2P ('I')) == NULL);
 110   TEST (NULL, g_node_find (root, G_IN_ORDER, G_TRAVERSE_LEAFS, C2P ('J')) == node_J);
 111
 112   for (i = 0; i < g_node_n_children (node_B); i++)
 113     {
 114       node = g_node_nth_child (node_B, i);
 115       TEST (NULL, P2C (node->data) == ('C' + i));
 116     }
 117
 118   for (i = 0; i < g_node_n_children (node_G); i++)
 119     TEST (NULL, g_node_child_position (node_G, g_node_nth_child (node_G, i)) == i);
 120
 121   /* we have built:                    A
 122    *                                 /   \
 123    *                               B       F
 124    *                             / | \       \
 125    *                           C   D   E       G
 126    *                                         / /\ \
 127    *                                       H  I  J  K
 128    *
 129    * for in-order traversal, 'G' is considered to be the "left"
 130    * child of 'F', which will cause 'F' to be the last node visited.
 131    */
 132
 133   tstring = NULL;
 134   g_node_traverse (root, G_PRE_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
 135   TEST (tstring, strcmp (tstring, "ABCDEFGHIJK") == 0);
 136   g_free (tstring); tstring = NULL;
 137   g_node_traverse (root, G_POST_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
 138   TEST (tstring, strcmp (tstring, "CDEBHIJKGFA") == 0);
 139   g_free (tstring); tstring = NULL;
 140   g_node_traverse (root, G_IN_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
 141   TEST (tstring, strcmp (tstring, "CBDEAHGIJKF") == 0);
 142   g_free (tstring); tstring = NULL;
 143   g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
 144   TEST (tstring, strcmp (tstring, "ABFCDEGHIJK") == 0);
 145   g_free (tstring); tstring = NULL;
 146
 147   g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_LEAFS, -1, node_build_string, &tstring);
 148   TEST (tstring, strcmp (tstring, "CDEHIJK") == 0);
 149   g_free (tstring); tstring = NULL;
 150   g_node_traverse (root, G_PRE_ORDER, G_TRAVERSE_NON_LEAFS, -1, node_build_string, &tstring);
 151   TEST (tstring, strcmp (tstring, "ABFG") == 0);
 152   g_free (tstring); tstring = NULL;
 153
 154   g_node_reverse_children (node_B);
 155   g_node_reverse_children (node_G);
 156
 157   g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
 158   TEST (tstring, strcmp (tstring, "ABFEDCGKJIH") == 0);
 159   g_free (tstring); tstring = NULL;
 160
 161   g_node_destroy (root);
 162
 163   /* allocation tests */
 164
 165   root = g_node_new (NULL);
 166   node = root;
 167
 168   for (i = 0; i < 2048; i++)
 169     {
 170       g_node_append (node, g_node_new (NULL));
 171       if ((i%5) == 4)
 172         node = node->children->next;
 173     }
 174   TEST (NULL, g_node_max_height (root) > 100);
 175   TEST (NULL, g_node_n_nodes (root, G_TRAVERSE_ALL) == 1 + 2048);
 176
 177   g_node_destroy (root);
 178
 179   if (!failed)
 180     g_print ("ok\n");
 181 }
 182
 183 gboolean
 184 my_hash_callback_remove (gpointer key,
 185                          gpointer value,
 186                          gpointer user_data)
 187 {
 188   int *d = value;
 189
 190   if ((*d) % 2)
 191     return TRUE;
 192
 193   return FALSE;
 194 }
 195
 196 void
 197 my_hash_callback_remove_test (gpointer key,
 198                               gpointer value,
 199                               gpointer user_data)
 200 {
 201   int *d = value;
 202
 203   if ((*d) % 2)
 204     g_print ("bad!\n");
 205 }
 206
 207 void
 208 my_hash_callback (gpointer key,
 209                   gpointer value,
 210                   gpointer user_data)
 211 {
 212   int *d = value;
 213   *d = 1;
 214 }
 215
 216 guint
 217 my_hash (gconstpointer key)
 218 {
 219   return (guint) *((const gint*) key);
 220 }
 221
 222 gint
 223 my_hash_compare (gconstpointer a,
 224                  gconstpointer b)
 225 {
 226   return *((const gint*) a) == *((const gint*) b);
 227 }
 228
 229 gint
 230 my_list_compare_one (gconstpointer a, gconstpointer b)
 231 {
 232   gint one = *((const gint*)a);
 233   gint two = *((const gint*)b);
 234   return one-two;
 235 }
 236
 237 gint
 238 my_list_compare_two (gconstpointer a, gconstpointer b)
 239 {
 240   gint one = *((const gint*)a);
 241   gint two = *((const gint*)b);
 242   return two-one;
 243 }
 244
 245 /* void
 246 my_list_print (gpointer a, gpointer b)
 247 {
 248   gint three = *((gint*)a);
 249   g_print("%d", three);
 250 }; */
 251
 252 gint
 253 my_compare (gconstpointer a,
 254             gconstpointer b)
 255 {
 256   const char *cha = a;
 257   const char *chb = b;
 258
 259   return *cha - *chb;
 260 }
 261
 262 gint
 263 my_traverse (gpointer key,
 264              gpointer value,
 265              gpointer data)
 266 {
 267   char *ch = key;
 268   g_print ("%c ", *ch);
 269   return FALSE;
 270 }
 271
 272 int
 273 main (int   argc,
 274       char *argv[])
 275 {
 276   GList *list, *t;
 277   GSList *slist, *st;
 278   GHashTable *hash_table;
 279   GMemChunk *mem_chunk;
 280   GStringChunk *string_chunk;
 281   GTimer *timer;
 282   gint nums[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
 283   gint morenums[10] = { 8, 9, 7, 0, 3, 2, 5, 1, 4, 6};
 284   gchar *string;
 285
 286   gchar *mem[10000], *tmp_string, *tmp_string_2;
 287   gint i, j;
 288   GArray *garray;
 289   GPtrArray *gparray;
 290   GByteArray *gbarray;
 291   GString *string1, *string2;
 292   GTree *tree;
 293   char chars[62];
 294   GRelation *relation;
 295   GTuples *tuples;
 296   gint data [1024];
 297   struct {
 298     gchar *filename;
 299     gchar *dirname;
 300   } dirname_checks[] = {
 301 #ifndef NATIVE_WIN32
 302     { "/", "/" },
 303     { "////", "/" },
 304     { ".////", "." },
 305     { ".", "." },
 306     { "..", "." },
 307     { "../", ".." },
 308     { "..////", ".." },
 309     { "", "." },
 310     { "a/b", "a" },
 311     { "a/b/", "a/b" },
 312     { "c///", "c" },
 313 #else
 314     { "\\", "\\" },
 315     { ".\\\\\\\\", "." },
 316     { ".", "." },
 317     { "..", "." },
 318     { "..\\", ".." },
 319     { "..\\\\\\\\", ".." },
 320     { "", "." },
 321     { "a\\b", "a" },
 322     { "a\\b\\", "a\\b" },
 323     { "c\\\\\\", "c" },
 324 #endif
 325   };
 326   guint n_dirname_checks = sizeof (dirname_checks) / sizeof (dirname_checks[0]);
 327   guint16 gu16t1 = 0x44afU, gu16t2 = 0xaf44U;
 328   guint32 gu32t1 = 0x02a7f109U, gu32t2 = 0x09f1a702U;
 329 #ifdef G_HAVE_GINT64
 330   guint64 gu64t1 = G_GINT64_CONSTANT(0x1d636b02300a7aa7U),
 331           gu64t2 = G_GINT64_CONSTANT(0xa77a0a30026b631dU);
 332 #endif
 333
 334   g_print ("TestGLib v%u.%u.%u (i:%u b:%u)\n",
 335            glib_major_version,
 336            glib_minor_version,
 337            glib_micro_version,
 338            glib_interface_age,
 339            glib_binary_age);
 340
 341   string = g_get_current_dir ();
 342   g_print ("cwd: %s\n", string);
 343   g_free (string);
 344
 345   /* type sizes */
 346   g_print ("checking size of gint8: %d", (int)sizeof (gint8));
 347   TEST (NULL, sizeof (gint8) == 1);
 348   g_print ("\nchecking size of gint16: %d", (int)sizeof (gint16));
 349   TEST (NULL, sizeof (gint16) == 2);
 350   g_print ("\nchecking size of gint32: %d", (int)sizeof (gint32));
 351   TEST (NULL, sizeof (gint32) == 4);
 352 #ifdef  G_HAVE_GINT64
 353   g_print ("\nchecking size of gint64: %d", (int)sizeof (gint64));
 354   TEST (NULL, sizeof (gint64) == 8);
 355 #endif  /* G_HAVE_GINT64 */
 356   g_print ("\n");
 357
 358   g_print ("checking g_dirname()...");
 359   for (i = 0; i < n_dirname_checks; i++)
 360     {
 361       gchar *dirname;
 362
 363       dirname = g_dirname (dirname_checks[i].filename);
 364       if (strcmp (dirname, dirname_checks[i].dirname) != 0)
 365         {
 366           g_print ("\nfailed for \"%s\"==\"%s\" (returned: \"%s\")\n",
 367                    dirname_checks[i].filename,
 368                    dirname_checks[i].dirname,
 369                    dirname);
 370           n_dirname_checks = 0;
 371         }
 372       g_free (dirname);
 373     }
 374   if (n_dirname_checks)
 375     g_print ("ok\n");
 376
 377   g_print ("checking doubly linked lists...");
 378
 379   list = NULL;
 380   for (i = 0; i < 10; i++)
 381     list = g_list_append (list, &nums[i]);
 382   list = g_list_reverse (list);
 383
 384   for (i = 0; i < 10; i++)
 385     {
 386       t = g_list_nth (list, i);
 387       if (*((gint*) t->data) != (9 - i))
 388         g_error ("Regular insert failed");
 389     }
 390
 391   for (i = 0; i < 10; i++)
 392     if(g_list_position(list, g_list_nth (list, i)) != i)
 393       g_error("g_list_position does not seem to be the inverse of g_list_nth\n");
 394
 395   g_list_free (list);
 396   list = NULL;
 397
 398   for (i = 0; i < 10; i++)
 399     list = g_list_insert_sorted (list, &morenums[i], my_list_compare_one);
 400
 401   /*
 402   g_print("\n");
 403   g_list_foreach (list, my_list_print, NULL);
 404   */
 405
 406   for (i = 0; i < 10; i++)
 407     {
 408       t = g_list_nth (list, i);
 409       if (*((gint*) t->data) != i)
 410          g_error ("Sorted insert failed");
 411     }
 412
 413   g_list_free (list);
 414   list = NULL;
 415
 416   for (i = 0; i < 10; i++)
 417     list = g_list_insert_sorted (list, &morenums[i], my_list_compare_two);
 418
 419   /*
 420   g_print("\n");
 421   g_list_foreach (list, my_list_print, NULL);
 422   */
 423
 424   for (i = 0; i < 10; i++)
 425     {
 426       t = g_list_nth (list, i);
 427       if (*((gint*) t->data) != (9 - i))
 428          g_error ("Sorted insert failed");
 429     }
 430
 431   g_list_free (list);
 432   list = NULL;
 433
 434   for (i = 0; i < 10; i++)
 435     list = g_list_prepend (list, &morenums[i]);
 436
 437   list = g_list_sort (list, my_list_compare_two);
 438
 439   /*
 440   g_print("\n");
 441   g_list_foreach (list, my_list_print, NULL);
 442   */
 443
 444   for (i = 0; i < 10; i++)
 445     {
 446       t = g_list_nth (list, i);
 447       if (*((gint*) t->data) != (9 - i))
 448          g_error ("Merge sort failed");
 449     }
 450
 451   g_list_free (list);
 452
 453   g_print ("ok\n");
 454
 455
 456   g_print ("checking singly linked lists...");
 457
 458   slist = NULL;
 459   for (i = 0; i < 10; i++)
 460     slist = g_slist_append (slist, &nums[i]);
 461   slist = g_slist_reverse (slist);
 462
 463   for (i = 0; i < 10; i++)
 464     {
 465       st = g_slist_nth (slist, i);
 466       if (*((gint*) st->data) != (9 - i))
 467         g_error ("failed");
 468     }
 469
 470   g_slist_free (slist);
 471   slist = NULL;
 472
 473   for (i = 0; i < 10; i++)
 474     slist = g_slist_insert_sorted (slist, &morenums[i], my_list_compare_one);
 475
 476   /*
 477   g_print("\n");
 478   g_slist_foreach (slist, my_list_print, NULL);
 479   */
 480
 481   for (i = 0; i < 10; i++)
 482     {
 483       st = g_slist_nth (slist, i);
 484       if (*((gint*) st->data) != i)
 485          g_error ("Sorted insert failed");
 486     }
 487
 488   g_slist_free(slist);
 489   slist = NULL;
 490
 491   for (i = 0; i < 10; i++)
 492     slist = g_slist_insert_sorted (slist, &morenums[i], my_list_compare_two);
 493
 494   /*
 495   g_print("\n");
 496   g_slist_foreach (slist, my_list_print, NULL);
 497   */
 498
 499   for (i = 0; i < 10; i++)
 500     {
 501       st = g_slist_nth (slist, i);
 502       if (*((gint*) st->data) != (9 - i))
 503          g_error("Sorted insert failed");
 504     }
 505
 506   g_slist_free(slist);
 507   slist = NULL;
 508
 509   for (i = 0; i < 10; i++)
 510     slist = g_slist_prepend (slist, &morenums[i]);
 511
 512   slist = g_slist_sort (slist, my_list_compare_two);
 513
 514   /*
 515   g_print("\n");
 516   g_slist_foreach (slist, my_list_print, NULL);
 517   */
 518
 519   for (i = 0; i < 10; i++)
 520     {
 521       st = g_slist_nth (slist, i);
 522       if (*((gint*) st->data) != (9 - i))
 523          g_error("Sorted insert failed");
 524     }
 525
 526   g_slist_free(slist);
 527
 528   g_print ("ok\n");
 529
 530
 531   g_print ("checking binary trees...\n");
 532
 533   tree = g_tree_new (my_compare);
 534   i = 0;
 535   for (j = 0; j < 10; j++, i++)
 536     {
 537       chars[i] = '0' + j;
 538       g_tree_insert (tree, &chars[i], &chars[i]);
 539     }
 540   for (j = 0; j < 26; j++, i++)
 541     {
 542       chars[i] = 'A' + j;
 543       g_tree_insert (tree, &chars[i], &chars[i]);
 544     }
 545   for (j = 0; j < 26; j++, i++)
 546     {
 547       chars[i] = 'a' + j;
 548       g_tree_insert (tree, &chars[i], &chars[i]);
 549     }
 550
 551   g_print ("tree height: %d\n", g_tree_height (tree));
 552   g_print ("tree nnodes: %d\n", g_tree_nnodes (tree));
 553
 554   g_print ("tree: ");
 555   g_tree_traverse (tree, my_traverse, G_IN_ORDER, NULL);
 556   g_print ("\n");
 557
 558   for (i = 0; i < 10; i++)
 559     g_tree_remove (tree, &chars[i]);
 560
 561   g_print ("tree height: %d\n", g_tree_height (tree));
 562   g_print ("tree nnodes: %d\n", g_tree_nnodes (tree));
 563
 564   g_print ("tree: ");
 565   g_tree_traverse (tree, my_traverse, G_IN_ORDER, NULL);
 566   g_print ("\n");
 567
 568   g_print ("ok\n");
 569
 570
 571   /* check n-way trees */
 572   g_node_test ();
 573
 574   g_print ("checking mem chunks...");
 575
 576   mem_chunk = g_mem_chunk_new ("test mem chunk", 50, 100, G_ALLOC_AND_FREE);
 577
 578   for (i = 0; i < 10000; i++)
 579     {
 580       mem[i] = g_chunk_new (gchar, mem_chunk);
 581
 582       for (j = 0; j < 50; j++)
 583         mem[i][j] = i * j;
 584     }
 585
 586   for (i = 0; i < 10000; i++)
 587     {
 588       g_mem_chunk_free (mem_chunk, mem[i]);
 589     }
 590
 591   g_print ("ok\n");
 592
 593
 594   g_print ("checking hash tables...");
 595
 596   hash_table = g_hash_table_new (my_hash, my_hash_compare);
 597   for (i = 0; i < 10000; i++)
 598     {
 599       array[i] = i;
 600       g_hash_table_insert (hash_table, &array[i], &array[i]);
 601     }
 602   g_hash_table_foreach (hash_table, my_hash_callback, NULL);
 603
 604   for (i = 0; i < 10000; i++)
 605     if (array[i] == 0)
 606       g_print ("%d\n", i);
 607
 608   for (i = 0; i < 10000; i++)
 609     g_hash_table_remove (hash_table, &array[i]);
 610
 611   for (i = 0; i < 10000; i++)
 612     {
 613       array[i] = i;
 614       g_hash_table_insert (hash_table, &array[i], &array[i]);
 615     }
 616
 617   if (g_hash_table_foreach_remove (hash_table, my_hash_callback_remove, NULL) != 5000 ||
 618       g_hash_table_size (hash_table) != 5000)
 619     g_print ("bad!\n");
 620
 621   g_hash_table_foreach (hash_table, my_hash_callback_remove_test, NULL);
 622
 623
 624   g_hash_table_destroy (hash_table);
 625
 626   g_print ("ok\n");
 627
 628
 629   g_print ("checking string chunks...");
 630
 631   string_chunk = g_string_chunk_new (1024);
 632
 633   for (i = 0; i < 100000; i ++)
 634     {
 635       tmp_string = g_string_chunk_insert (string_chunk, "hi pete");
 636
 637       if (strcmp ("hi pete", tmp_string) != 0)
 638         g_error ("string chunks are broken.\n");
 639     }
 640
 641   tmp_string_2 = g_string_chunk_insert_const (string_chunk, tmp_string);
 642
 643   g_assert (tmp_string_2 != tmp_string &&
 644             strcmp(tmp_string_2, tmp_string) == 0);
 645
 646   tmp_string = g_string_chunk_insert_const (string_chunk, tmp_string);
 647
 648   g_assert (tmp_string_2 == tmp_string);
 649
 650   g_string_chunk_free (string_chunk);
 651
 652   g_print ("ok\n");
 653
 654
 655   g_print ("checking arrays...");
 656
 657   garray = g_array_new (FALSE, FALSE, sizeof (gint));
 658   for (i = 0; i < 10000; i++)
 659     g_array_append_val (garray, i);
 660
 661   for (i = 0; i < 10000; i++)
 662     if (g_array_index (garray, gint, i) != i)
 663       g_print ("uh oh: %d ( %d )\n", g_array_index (garray, gint, i), i);
 664
 665   g_array_free (garray, TRUE);
 666
 667   garray = g_array_new (FALSE, FALSE, sizeof (gint));
 668   for (i = 0; i < 100; i++)
 669     g_array_prepend_val (garray, i);
 670
 671   for (i = 0; i < 100; i++)
 672     if (g_array_index (garray, gint, i) != (100 - i - 1))
 673       g_print ("uh oh: %d ( %d )\n", g_array_index (garray, gint, i), 100 - i - 1);
 674
 675   g_array_free (garray, TRUE);
 676
 677   g_print ("ok\n");
 678
 679
 680   g_print ("checking strings...");
 681
 682   string1 = g_string_new ("hi pete!");
 683   string2 = g_string_new ("");
 684
 685   g_assert (strcmp ("hi pete!", string1->str) == 0);
 686
 687   for (i = 0; i < 10000; i++)
 688     g_string_append_c (string1, 'a'+(i%26));
 689
 690 #if !(defined (_MSC_VER) || defined (__LCC__))
 691   /* MSVC and LCC use the same run-time C library, which doesn't like
 692      the %10000.10000f format... */
 693   g_string_sprintf (string2, "%s|%0100d|%s|%s|%0*d|%*.*f|%10000.10000f",
 694                     "this pete guy sure is a wuss, like he's the number ",
 695                     1,
 696                     " wuss.  everyone agrees.\n",
 697                     string1->str,
 698                     10, 666, 15, 15, 666.666666666, 666.666666666);
 699 #else
 700   g_string_sprintf (string2, "%s|%0100d|%s|%s|%0*d|%*.*f|%100.100f",
 701                     "this pete guy sure is a wuss, like he's the number ",
 702                     1,
 703                     " wuss.  everyone agrees.\n",
 704                     string1->str,
 705                     10, 666, 15, 15, 666.666666666, 666.666666666);
 706 #endif
 707
 708   g_print ("string2 length = %d...\n", string2->len);
 709   string2->str[70] = '\0';
 710   g_print ("first 70 chars:\n%s\n", string2->str);
 711   string2->str[141] = '\0';
 712   g_print ("next 70 chars:\n%s\n", string2->str+71);
 713   string2->str[212] = '\0';
 714   g_print ("and next 70:\n%s\n", string2->str+142);
 715   g_print ("last 70 chars:\n%s\n", string2->str+string2->len - 70);
 716
 717   g_print ("ok\n");
 718
 719   g_print ("checking timers...\n");
 720
 721   timer = g_timer_new ();
 722   g_print ("  spinning for 3 seconds...\n");
 723
 724   g_timer_start (timer);
 725   while (g_timer_elapsed (timer, NULL) < 3)
 726     ;
 727
 728   g_timer_stop (timer);
 729   g_timer_destroy (timer);
 730
 731   g_print ("ok\n");
 732
 733   g_print ("checking g_strcasecmp...");
 734   g_assert (g_strcasecmp ("FroboZZ", "frobozz") == 0);
 735   g_assert (g_strcasecmp ("frobozz", "frobozz") == 0);
 736   g_assert (g_strcasecmp ("frobozz", "FROBOZZ") == 0);
 737   g_assert (g_strcasecmp ("FROBOZZ", "froboz") != 0);
 738   g_assert (g_strcasecmp ("", "") == 0);
 739   g_assert (g_strcasecmp ("!#%&/()", "!#%&/()") == 0);
 740   g_assert (g_strcasecmp ("a", "b") < 0);
 741   g_assert (g_strcasecmp ("a", "B") < 0);
 742   g_assert (g_strcasecmp ("A", "b") < 0);
 743   g_assert (g_strcasecmp ("A", "B") < 0);
 744   g_assert (g_strcasecmp ("b", "a") > 0);
 745   g_assert (g_strcasecmp ("b", "A") > 0);
 746   g_assert (g_strcasecmp ("B", "a") > 0);
 747   g_assert (g_strcasecmp ("B", "A") > 0);
 748
 749   g_print ("ok\n");
 750
 751   /* g_debug (argv[0]); */
 752
 753   /* Relation tests */
 754
 755   g_print ("checking relations...");
 756
 757   relation = g_relation_new (2);
 758
 759   g_relation_index (relation, 0, g_int_hash, g_int_equal);
 760   g_relation_index (relation, 1, g_int_hash, g_int_equal);
 761
 762   for (i = 0; i < 1024; i += 1)
 763     data[i] = i;
 764
 765   for (i = 1; i < 1023; i += 1)
 766     {
 767       g_relation_insert (relation, data + i, data + i + 1);
 768       g_relation_insert (relation, data + i, data + i - 1);
 769     }
 770
 771   for (i = 2; i < 1022; i += 1)
 772     {
 773       g_assert (! g_relation_exists (relation, data + i, data + i));
 774       g_assert (! g_relation_exists (relation, data + i, data + i + 2));
 775       g_assert (! g_relation_exists (relation, data + i, data + i - 2));
 776     }
 777
 778   for (i = 1; i < 1023; i += 1)
 779     {
 780       g_assert (g_relation_exists (relation, data + i, data + i + 1));
 781       g_assert (g_relation_exists (relation, data + i, data + i - 1));
 782     }
 783
 784   for (i = 2; i < 1022; i += 1)
 785     {
 786       g_assert (g_relation_count (relation, data + i, 0) == 2);
 787       g_assert (g_relation_count (relation, data + i, 1) == 2);
 788     }
 789
 790   g_assert (g_relation_count (relation, data, 0) == 0);
 791
 792   g_assert (g_relation_count (relation, data + 42, 0) == 2);
 793   g_assert (g_relation_count (relation, data + 43, 1) == 2);
 794   g_assert (g_relation_count (relation, data + 41, 1) == 2);
 795   g_relation_delete (relation, data + 42, 0);
 796   g_assert (g_relation_count (relation, data + 42, 0) == 0);
 797   g_assert (g_relation_count (relation, data + 43, 1) == 1);
 798   g_assert (g_relation_count (relation, data + 41, 1) == 1);
 799
 800   tuples = g_relation_select (relation, data + 200, 0);
 801
 802   g_assert (tuples->len == 2);
 803
 804 #if 0
 805   for (i = 0; i < tuples->len; i += 1)
 806     {
 807       printf ("%d %d\n",
 808               *(gint*) g_tuples_index (tuples, i, 0),
 809               *(gint*) g_tuples_index (tuples, i, 1));
 810     }
 811 #endif
 812
 813   g_assert (g_relation_exists (relation, data + 300, data + 301));
 814   g_relation_delete (relation, data + 300, 0);
 815   g_assert (!g_relation_exists (relation, data + 300, data + 301));
 816
 817   g_tuples_destroy (tuples);
 818
 819   g_relation_destroy (relation);
 820
 821   relation = NULL;
 822
 823   g_print ("ok\n");
 824
 825   g_print ("checking pointer arrays...");
 826
 827   gparray = g_ptr_array_new ();
 828   for (i = 0; i < 10000; i++)
 829     g_ptr_array_add (gparray, GINT_TO_POINTER (i));
 830
 831   for (i = 0; i < 10000; i++)
 832     if (g_ptr_array_index (gparray, i) != GINT_TO_POINTER (i))
 833       g_print ("array fails: %p ( %p )\n", g_ptr_array_index (gparray, i), GINT_TO_POINTER (i));
 834
 835   g_ptr_array_free (gparray, TRUE);
 836
 837   g_print ("ok\n");
 838
 839
 840   g_print ("checking byte arrays...");
 841
 842   gbarray = g_byte_array_new ();
 843   for (i = 0; i < 10000; i++)
 844     g_byte_array_append (gbarray, (guint8*) "abcd", 4);
 845
 846   for (i = 0; i < 10000; i++)
 847     {
 848       g_assert (gbarray->data[4*i] == 'a');
 849       g_assert (gbarray->data[4*i+1] == 'b');
 850       g_assert (gbarray->data[4*i+2] == 'c');
 851       g_assert (gbarray->data[4*i+3] == 'd');
 852     }
 853
 854   g_byte_array_free (gbarray, TRUE);
 855   g_print ("ok\n");
 856
 857   g_printerr ("g_log tests:");
 858   g_warning ("harmless warning with parameters: %d %s %#x", 42, "Boo", 12345);
 859   g_message ("the next warning is a test:");
 860   string = NULL;
 861   g_print (string);
 862
 863   g_print ("endian macro tests...");
 864 #if G_BYTE_ORDER == G_BIG_ENDIAN
 865   g_print ("big endian...\n");
 866 #else
 867   g_print ("little endian...\n");
 868 #endif
 869   g_assert (GUINT16_SWAP_LE_BE (gu16t1) == gu16t2);
 870   g_assert (GUINT32_SWAP_LE_BE (gu32t1) == gu32t2);
 871 #ifdef G_HAVE_GINT64
 872   g_assert (GUINT64_SWAP_LE_BE (gu64t1) == gu64t2);
 873 #endif
 874
 875 #ifdef G_HAVE_ALLOCA
 876   /* test alloca()-based string duplication routines */
 877   g_strdup_a(string, GLIB_TEST_STRING);
 878   g_assert(string != NULL);
 879   g_assert(strcmp(string, GLIB_TEST_STRING) == 0);
 880
 881   g_strndup_a(string, GLIB_TEST_STRING, 5);
 882   g_assert(string != NULL);
 883   g_assert(strlen(string) == 5);
 884   g_assert(strcmp(string, GLIB_TEST_STRING_5) == 0);
 885
 886   g_strconcat_a(string, GLIB_TEST_STRING, GLIB_TEST_STRING, GLIB_TEST_STRING);
 887   g_assert(string != NULL);
 888   g_assert(strcmp(string, GLIB_TEST_STRING GLIB_TEST_STRING
 889                           GLIB_TEST_STRING) == 0);
 890 #endif
 891
 892   g_print ("ok\n");
 893
 894   return 0;
 895 }
 896