/* Portion Copyright © 2008-09 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.*/

 #undef G_DISABLE_ASSERT

 #undef G_LOG_DOMAIN

 #include <glib.h>

 #include <stdio.h>

 #include <unistd.h>

 #ifdef SYMBIAN

 #include "mrt2_glib2_test.h"

 #endif /*SYMBIAN*/

 /* Outputs tested against the reference implementation mt19937ar.c from

    http://www.math.keio.ac.jp/~matumoto/MT2002/emt19937ar.html */

 /* Tests for a simple seed, first number is the seed */

 const guint32 first_numbers[] = 

 {

   0x7a7a7a7a,

   0xfdcc2d54,

   0x3a279ceb,

   0xc4d39c33,

   0xf31895cd,

   0x46ca0afc,

   0x3f5484ff,

   0x54bc9557,

   0xed2c24b1,

   0x84062503,

   0x8f6404b3,

   0x599a94b3,

   0xe46d03d5,

   0x310beb78,

   0x7bee5d08,

   0x760d09be,

   0x59b6e163,

   0xbf6d16ec,

   0xcca5fb54,

   0x5de7259b,

   0x1696330c,

 };

 /* array seed */

 const guint32 seed_array[] =

 {

   0x6553375f,

   0xd6b8d43b,

   0xa1e7667f,

   0x2b10117c

 };

 /* tests for the array seed */

 const guint32 array_outputs[] =

 {

   0xc22b7dc3,

   0xfdecb8ae,

   0xb4af0738,

   0x516bc6e1,

   0x7e372e91,

   0x2d38ff80,

   0x6096494a,

   0xd162d5a8,

   0x3c0aaa0d,

   0x10e736ae

 };

 const gint length = sizeof (first_numbers) / sizeof (first_numbers[0]);

 const gint seed_length = sizeof (seed_array) / sizeof (seed_array[0]);

 const gint array_length = sizeof (array_outputs) / sizeof (array_outputs[0]);

 int main()

 {

   guint n;

   guint ones;

   double proportion;

   GRand* rand;// = g_rand_new_with_seed (first_numbers[0]);

   GRand* copy;

   #ifdef SYMBIAN

   g_log_set_handler (NULL,  G_LOG_FLAG_FATAL| G_LOG_FLAG_RECURSION | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG, &mrtLogHandler, NULL);

   g_set_print_handler(mrtPrintHandler);

   #endif /*SYMBIAN*/

   rand = g_rand_new_with_seed (first_numbers[0]);

   for (n = 1; n < length; n++)

     g_assert (first_numbers[n] == g_rand_int (rand));

   g_rand_set_seed (rand, 2);

   g_rand_set_seed_array (rand, seed_array, seed_length);

   for (n = 0; n < array_length; n++)

     g_assert (array_outputs[n] == g_rand_int (rand));

   copy = g_rand_copy (rand);

   for (n = 0; n < 100; n++)

     g_assert (g_rand_int (copy) == g_rand_int (rand));

  // for (n = 1; n < 100000; n++)

   for (n = 1; n < 100000; n++)

     {

       gint32 i;

       gdouble d;

       gboolean b;

       i = g_rand_int_range (rand, 8,16);

       g_assert (i >= 8 && i < 16);

       i = g_random_int_range (8,16);

       g_assert (i >= 8 && i < 16);

       d = g_rand_double (rand);

       g_assert (d >= 0 && d < 1);

       d = g_random_double ();

       g_assert (d >= 0 && d < 1);

       d = g_rand_double_range (rand, -8, 32);

       g_assert (d >= -8 && d < 32);

       d = g_random_double_range (-8, 32);

       g_assert (d >= -8 && d < 32);

       b = g_random_boolean ();

       g_assert (b == TRUE || b  == FALSE);

       b = g_rand_boolean (rand);

       g_assert (b == TRUE || b  == FALSE);     

     }

   /* Statistical sanity check, count the number of ones

    * when getting random numbers in range [0,3) and see

    * that it must be semi-close to 0.25 with a VERY large

    * probability */

   ones = 0;

   for (n = 1; n < 100000; n++)

     {

       if (g_random_int_range (0, 4) == 1)

         ones ++;

     }

   proportion = (double)ones / (double)100000;

   /* 0.025 is overkill, but should suffice to test for some unreasonability */

   g_assert (ABS (proportion - 0.25) < 0.025);

   g_rand_free (rand);

   g_rand_free (copy);

 #ifdef SYMBIAN

   testResultXml("rand-test");

 #endif /* EMULATOR */

   return 0;

 }