test-date.c

00001 /***************************************************************************
00002  *            test-date.c
00003  *       Rewritten from scratch for QOF 0.7.0
00004  *
00005  *  Copyright (C) 2002, 2004, 2005, 2006 
00006  *  Free Software Foundation, Inc.
00007  *
00008  ****************************************************************************/
00009 /*
00010  *  This program is free software; you can redistribute it and/or modify
00011  *  it under the terms of the GNU General Public License as published by
00012  *  the Free Software Foundation; either version 2 of the License, or
00013  *  (at your option) any later version.
00014  *
00015  *  This program is distributed in the hope that it will be useful,
00016  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00017  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00018  *  GNU General Public License for more details.
00019  *
00020  *  You should have received a copy of the GNU General Public License
00021  *  along with this program; if not, write to the Free Software
00022  *  Foundation, Inc., 51 Franklin Street, Fifth Floor Boston, MA  02110-1301,  USA
00023  */
00024 
00025 #include "config.h"
00026 #include <stdio.h>
00027 #include <ctype.h>
00028 #include <glib.h>
00029 #include <time.h>
00030 #include "qof.h"
00031 #include "test-stuff.h"
00032 
00033 static gboolean test_data_is_init = FALSE;
00034 static GList *test_data = NULL;
00035 static QofLogModule log_module = QOF_MOD_DATE;
00036 
00037 typedef struct
00038 {
00039     /* time value of the date below */
00040     QofTime *time;
00041     /* date value of the above time. */
00042     QofDate *date;
00043     /* GList of the date in each QofDateFormat */
00044     GList   *string_list;
00045     /* unique ID for this date for error reports. */
00046     const gchar *id;
00047 }QTestDate;
00048 
00049 static void
00050 check_date_cycles (gpointer data, gpointer user_data)
00051 {
00052     QofDateFormat df;
00053     gchar *str, *cmp;
00054     QTestDate *d;
00055     gint i;
00056 
00057     d = (QTestDate*)data;
00058     df = qof_date_format_get_current ();
00059     /* test qof_date_to_qtime and qof_date_from_qtime */
00060     {
00061         do_test ((0 == qof_time_cmp (qof_date_to_qtime (d->date), 
00062             d->time)), d->id);
00063         do_test ((0 == qof_date_compare (qof_date_from_qtime (d->time), 
00064             d->date)), d->id);
00065     }
00066     /* don't test locale-sensitive formats, yet. */
00067     for (i = 1; i <= 6; i++)
00068     {
00069         str = qof_date_print (d->date, i);
00070         cmp = (gchar*)g_list_nth_data (d->string_list, (i - 1));
00071         if (0 != safe_strcasecmp (str, cmp))
00072             DEBUG (" str=%s cmp=%s", str, cmp);
00073         do_test ((0 == safe_strcasecmp (str, cmp)), d->id);
00074         /* now test qofstrptime */
00075         {
00076             gint result;
00077             QofDate *h, *j;
00078             const gchar * t;
00079             struct tm base;
00080 
00081             base.tm_year = base.tm_mday = base.tm_mon = 0;
00082             base.tm_min  = base.tm_hour = base.tm_gmtoff = 0;
00083             base.tm_sec  = base.tm_isdst = 0;
00084             result = 0;
00086             if ((d->date->qd_year > 0) &&
00087                 (d->date->qd_year < 9999))
00088             {
00089                 h = qof_date_parse (cmp, i);
00090                 do_test ((h != NULL), "no date could be parsed");
00091                 if (!h)
00092                     PERR (" h failed for str=%s, "
00093                         "cmp=%s, %d\n", str, cmp, i);
00094                 t = qof_date_format_get_format (i);
00095                 strptime (cmp, t, &base);
00096                 j = qof_date_from_struct_tm (&base);
00097                 do_test ((j != NULL), "no value from struct tm");
00098                 if (h)
00099                 {
00100                     j->qd_nanosecs = h->qd_nanosecs;
00101                     result = qof_date_compare (h, j);
00102                     do_test ((0 == qof_date_compare (h, j)),
00103                         "compare with strptime");
00104                 }
00105             if (h)
00106                 qof_date_free (h);
00107             }
00108         }
00109     }
00110     qof_date_format_set_current (df);
00111 }
00112 
00113 static void
00114 test_date_init (void)
00115 {
00116     test_data_is_init = TRUE;
00117     test_data = NULL;
00118     /* A selection of current, old and future dates - all in UTC only. */
00119     {
00120         QTestDate *td = g_new0 (QTestDate, 1);
00121         td->time = qof_time_new ();
00122         qof_time_set_secs (td->time, 1147621550);
00123         qof_time_set_nanosecs (td->time, G_GINT64_CONSTANT(1000));
00124         td->date = qof_date_new ();
00125         td->date->qd_year = 2006;
00126         td->date->qd_mon  = 5;
00127         td->date->qd_mday = 14;
00128         td->date->qd_hour = 15;
00129         td->date->qd_min  = 45;
00130         td->date->qd_sec  = G_GINT64_CONSTANT(50);
00131         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00132         qof_date_valid (td->date);
00133         td->string_list = NULL;
00134         td->string_list = g_list_append (td->string_list, "05/14/2006");
00135         td->string_list = g_list_append (td->string_list, "14/05/2006");
00136         td->string_list = g_list_append (td->string_list, "14.05.2006");
00137         td->string_list = g_list_append (td->string_list, "2006-05-14");
00138         td->string_list = g_list_append (td->string_list, "2006-05-14T15:45:50Z");
00139         td->string_list = g_list_append (td->string_list,
00140             "2006-05-14 15:45:50.000001000 +0000");
00141         td->id = "a current time";
00142         test_data = g_list_prepend (test_data, td);
00143     }
00144     {
00145         QTestDate *td = g_new0 (QTestDate, 1);
00146         td->time = qof_time_new ();
00147         qof_time_set_secs (td->time, 1147132800);
00148         qof_time_set_nanosecs (td->time, 2);
00149         td->date = qof_date_new ();
00150         td->date->qd_year = 2006;
00151         td->date->qd_mon  = 5;
00152         td->date->qd_mday = 9;
00153         td->date->qd_hour = 0;
00154         td->date->qd_min  = 0;
00155         td->date->qd_sec  = G_GINT64_CONSTANT(0);
00156         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00157         qof_date_valid (td->date);
00158         td->string_list = NULL;
00159         td->string_list = g_list_prepend (td->string_list, "05/09/2006");
00160         td->string_list = g_list_prepend (td->string_list, "09/05/2006");
00161         td->string_list = g_list_prepend (td->string_list, "09.05.2006");
00162         td->string_list = g_list_prepend (td->string_list, "2006-05-09");
00163         td->string_list = g_list_prepend (td->string_list, "2006-05-09T00:00:00Z");
00164         td->string_list = g_list_prepend (td->string_list,
00165             "2006-05-09 00:00:00.000000002 +0000");
00166         td->string_list = g_list_reverse (td->string_list);
00167         td->id = "a recent time";
00168         test_data = g_list_prepend (test_data, td);
00169     }
00170     {
00171         QTestDate *td = g_new0 (QTestDate, 1);
00172         td->time = qof_time_new ();
00173         qof_time_set_secs (td->time, 1147186144);
00174         qof_time_set_nanosecs (td->time, 100);
00175         td->date = qof_date_new ();
00176         td->date->qd_year = 2006;
00177         td->date->qd_mon  = 5;
00178         td->date->qd_mday = 9;
00179         td->date->qd_hour = 14;
00180         td->date->qd_min  = 49;
00181         td->date->qd_sec  = G_GINT64_CONSTANT(4);
00182         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00183         qof_date_valid (td->date);
00184         td->string_list = NULL;
00185         td->string_list = g_list_prepend (td->string_list, "05/09/2006");
00186         td->string_list = g_list_prepend (td->string_list, "09/05/2006");
00187         td->string_list = g_list_prepend (td->string_list, "09.05.2006");
00188         td->string_list = g_list_prepend (td->string_list, "2006-05-09");
00189         td->string_list = g_list_prepend (td->string_list, "2006-05-09T14:49:04Z");
00190         td->string_list = g_list_prepend (td->string_list, 
00191             "2006-05-09 14:49:04.000000100 +0000");
00192         td->string_list = g_list_reverse (td->string_list);
00193         td->id = "second recent time";
00194         test_data = g_list_prepend (test_data, td);
00195     }
00196     {
00197         QTestDate *td = g_new0 (QTestDate, 1);
00198         td->time = qof_time_new ();
00199         qof_time_set_secs (td->time, 63039600);
00200         qof_time_set_nanosecs (td->time, 4);
00201         td->date = qof_date_new ();
00202         td->date->qd_year = 1971;
00203         td->date->qd_mon  = 12;
00204         td->date->qd_mday = 31;
00205         td->date->qd_hour = 15;
00206         td->date->qd_min  = 0;
00207         td->date->qd_sec  = G_GINT64_CONSTANT(0);
00208         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00209         qof_date_valid (td->date);
00210         td->string_list = NULL;
00211         td->string_list = g_list_prepend (td->string_list, "12/31/1971");
00212         td->string_list = g_list_prepend (td->string_list, "31/12/1971");
00213         td->string_list = g_list_prepend (td->string_list, "31.12.1971");
00214         td->string_list = g_list_prepend (td->string_list, "1971-12-31");
00215         td->string_list = g_list_prepend (td->string_list, "1971-12-31T15:00:00Z");
00216         td->string_list = g_list_prepend (td->string_list, 
00217             "1971-12-31 15:00:00.000000004 +0000");
00218         td->string_list = g_list_reverse (td->string_list);
00219         td->id = "New Year's Eve 1971";
00220         test_data = g_list_prepend (test_data, td);
00221     }
00222     {
00223         QTestDate *td = g_new0 (QTestDate, 1);
00224         td->time = qof_time_new ();
00225         qof_time_set_secs (td->time, 315532800);
00226         qof_time_set_nanosecs (td->time, 123456789);
00227         td->date = qof_date_new ();
00228         td->date->qd_year = 1980;
00229         td->date->qd_mon  = 1;
00230         td->date->qd_mday = 1;
00231         td->date->qd_hour = 0;
00232         td->date->qd_min  = 0;
00233         td->date->qd_sec  = G_GINT64_CONSTANT(0);
00234         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00235         qof_date_valid (td->date);
00236         td->string_list = NULL;
00237         td->string_list = g_list_prepend (td->string_list, "01/01/1980");
00238         td->string_list = g_list_prepend (td->string_list, "01/01/1980");
00239         td->string_list = g_list_prepend (td->string_list, "01.01.1980");
00240         td->string_list = g_list_prepend (td->string_list, "1980-01-01");
00241         td->string_list = g_list_prepend (td->string_list, "1980-01-01T00:00:00Z");
00242         td->string_list = g_list_prepend (td->string_list,
00243             "1980-01-01 00:00:00.123456789 +0000");
00244         td->string_list = g_list_reverse (td->string_list);
00245         td->id = "New Year's Day 1980";
00246         test_data = g_list_prepend (test_data, td);
00247     }
00248     {
00249         QTestDate *td = g_new0 (QTestDate, 1);
00250         td->time = qof_time_new ();
00251         qof_time_set_secs (td->time, 946684799);
00252         qof_time_set_nanosecs (td->time, 987654321);
00253         td->date = qof_date_new ();
00254         td->date->qd_year = 1999;
00255         td->date->qd_mon  = 12;
00256         td->date->qd_mday = 31;
00257         td->date->qd_hour = 23;
00258         td->date->qd_min  = 59;
00259         td->date->qd_sec  = G_GINT64_CONSTANT(59);
00260         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00261         qof_date_valid (td->date);
00262         td->string_list = NULL;
00263         td->string_list = g_list_prepend (td->string_list, "12/31/1999");
00264         td->string_list = g_list_prepend (td->string_list, "31/12/1999");
00265         td->string_list = g_list_prepend (td->string_list, "31.12.1999");
00266         td->string_list = g_list_prepend (td->string_list, "1999-12-31");
00267         td->string_list = g_list_prepend (td->string_list, "1999-12-31T23:59:59Z");
00268         td->string_list = g_list_prepend (td->string_list,
00269             "1999-12-31 23:59:59.987654321 +0000");
00270         td->string_list = g_list_reverse (td->string_list);
00271         td->id = "Millenium Eve";
00272         test_data = g_list_prepend (test_data, td);
00273     }
00274     {
00275         QTestDate *td = g_new0 (QTestDate, 1);
00276         td->time = qof_time_new ();
00277         qof_time_set_secs (td->time, 699378323);
00278         qof_time_set_nanosecs (td->time, 90000);
00279         td->date = qof_date_new ();
00280         td->date->qd_year = 1992;
00281         td->date->qd_mon  = 2;
00282         td->date->qd_mday = 29;
00283         td->date->qd_hour = 15;
00284         td->date->qd_min  = 45;
00285         td->date->qd_sec  = G_GINT64_CONSTANT(23);
00286         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00287         qof_date_valid (td->date);
00288         td->string_list = NULL;
00289         td->string_list = g_list_prepend (td->string_list, "02/29/1992");
00290         td->string_list = g_list_prepend (td->string_list, "29/02/1992");
00291         td->string_list = g_list_prepend (td->string_list, "29.02.1992");
00292         td->string_list = g_list_prepend (td->string_list, "1992-02-29");
00293         td->string_list = g_list_prepend (td->string_list, "1992-02-29T15:45:23Z");
00294         td->string_list = g_list_prepend (td->string_list, 
00295             "1992-02-29 15:45:23.000090000 +0000");
00296         td->string_list = g_list_reverse (td->string_list);
00297         td->id = "29th February 1992";
00298         test_data = g_list_prepend (test_data, td);
00299     }
00300     {
00301 
00302         QTestDate *td = g_new0 (QTestDate, 1);
00303         td->time = qof_time_new ();
00304         qof_time_set_secs (td->time, -1);
00305         qof_time_set_nanosecs (td->time, 9);
00306         td->date = qof_date_new ();
00307         td->date->qd_year = 1969;
00308         td->date->qd_mon  = 12;
00309         td->date->qd_mday = 31;
00310         td->date->qd_hour = 23;
00311         td->date->qd_min  = 59;
00312         td->date->qd_sec  = G_GINT64_CONSTANT(59);
00313         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00314         qof_date_valid (td->date);
00315         td->string_list = NULL;
00316         td->string_list = g_list_prepend (td->string_list, "12/31/1969");
00317         td->string_list = g_list_prepend (td->string_list, "31/12/1969");
00318         td->string_list = g_list_prepend (td->string_list, "31.12.1969");
00319         td->string_list = g_list_prepend (td->string_list, "1969-12-31");
00320         td->string_list = g_list_prepend (td->string_list, "1969-12-31T23:59:59Z");
00321         td->string_list = g_list_prepend (td->string_list, 
00322             "1969-12-31 23:59:59.000000009 +0000");
00323         td->string_list = g_list_reverse (td->string_list);
00324         td->id = "epoch eve";
00325         test_data = g_list_prepend (test_data, td);
00326     }
00327     {
00328         QTestDate *td = g_new0 (QTestDate, 1);
00329         td->time = qof_time_new ();
00330         qof_time_set_secs (td->time, -192776400);
00331         qof_time_set_nanosecs (td->time, 818818818);
00332         td->date = qof_date_new ();
00333         td->date->qd_year = 1963;
00334         td->date->qd_mon  = 11;
00335         td->date->qd_mday = 22;
00336         td->date->qd_hour = 19;
00337         td->date->qd_min  = 0;
00338         td->date->qd_sec  = G_GINT64_CONSTANT(0);
00339         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00340         qof_date_valid (td->date);
00341         td->string_list = NULL;
00342         td->string_list = g_list_prepend (td->string_list, "11/22/1963");
00343         td->string_list = g_list_prepend (td->string_list, "22/11/1963");
00344         td->string_list = g_list_prepend (td->string_list, "22.11.1963");
00345         td->string_list = g_list_prepend (td->string_list, "1963-11-22");
00346         td->string_list = g_list_prepend (td->string_list, "1963-11-22T19:00:00Z");
00347         td->string_list = g_list_prepend (td->string_list, 
00348             "1963-11-22 19:00:00.818818818 +0000");
00349         td->string_list = g_list_reverse (td->string_list);
00350         td->id = "approx JFK, 1963";
00351         test_data = g_list_prepend (test_data, td);
00352     }
00353     {
00354         QTestDate *td = g_new0 (QTestDate, 1);
00355         td->time = qof_time_new ();
00356         qof_time_set_secs (td->time, -767311080);
00357         qof_time_set_nanosecs (td->time, 0);
00358         td->date = qof_date_new ();
00359         td->date->qd_year = 1945;
00360         td->date->qd_mon  = 9;
00361         td->date->qd_mday = 8;
00362         td->date->qd_hour = 2;
00363         td->date->qd_min  = 2;
00364         td->date->qd_sec  = G_GINT64_CONSTANT(0);
00365         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00366         qof_date_valid (td->date);
00367         td->string_list = NULL;
00368         td->string_list = g_list_prepend (td->string_list, "09/08/1945");
00369         td->string_list = g_list_prepend (td->string_list, "08/09/1945");
00370         td->string_list = g_list_prepend (td->string_list, "08.09.1945");
00371         td->string_list = g_list_prepend (td->string_list, "1945-09-08");
00372         td->string_list = g_list_prepend (td->string_list, "1945-09-08T02:02:00Z");
00373         td->string_list = g_list_prepend (td->string_list, 
00374             "1945-09-08 02:02:00.000000000 +0000");
00375         td->string_list = g_list_reverse (td->string_list);
00376         td->id = "Nagasaki, 1945";
00377         test_data = g_list_prepend (test_data, td);
00378     }
00379     {
00380         QTestDate *td = g_new0 (QTestDate, 1);
00381         td->time = qof_time_new ();
00382         qof_time_set_secs (td->time, -1613826000);
00383         qof_time_set_nanosecs (td->time, 0);
00384         td->date = qof_date_new ();
00385         td->date->qd_year = 1918;
00386         td->date->qd_mon  = 11;
00387         td->date->qd_mday = 11;
00388         td->date->qd_hour = 11;
00389         td->date->qd_min  = 0;
00390         td->date->qd_sec  = G_GINT64_CONSTANT(0);
00391         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00392         qof_date_valid (td->date);
00393         td->string_list = NULL;
00394         td->string_list = g_list_prepend (td->string_list, "11/11/1918");
00395         td->string_list = g_list_prepend (td->string_list, "11/11/1918");
00396         td->string_list = g_list_prepend (td->string_list, "11.11.1918");
00397         td->string_list = g_list_prepend (td->string_list, "1918-11-11");
00398         td->string_list = g_list_prepend (td->string_list, "1918-11-11T11:00:00Z");
00399         td->string_list = g_list_prepend (td->string_list, 
00400             "1918-11-11 11:00:00.000000000 +0000");
00401         td->string_list = g_list_reverse (td->string_list);
00402         td->id = "Armistice 1918";
00403         test_data = g_list_prepend (test_data, td);
00404     }
00405     {
00406         QTestDate *td = g_new0 (QTestDate, 1);
00407         td->time = qof_time_new ();
00408         qof_time_set_secs (td->time, 
00409             G_GINT64_CONSTANT(-2208988801));
00410         qof_time_set_nanosecs (td->time, 0);
00411         td->date = qof_date_new ();
00412         td->date->qd_year = 1899;
00413         td->date->qd_mon  = 12;
00414         td->date->qd_mday = 31;
00415         td->date->qd_hour = 23;
00416         td->date->qd_min  = 59;
00417         td->date->qd_sec  = G_GINT64_CONSTANT(59);
00418         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00419         qof_date_valid (td->date);
00420         td->string_list = NULL;
00421         td->string_list = g_list_prepend (td->string_list, "12/31/1899");
00422         td->string_list = g_list_prepend (td->string_list, "31/12/1899");
00423         td->string_list = g_list_prepend (td->string_list, "31.12.1899");
00424         td->string_list = g_list_prepend (td->string_list, "1899-12-31");
00425         td->string_list = g_list_prepend (td->string_list, "1899-12-31T23:59:59Z");
00426         td->string_list = g_list_prepend (td->string_list, 
00427             "1899-12-31 23:59:59.000000000 +0000");
00428         td->string_list = g_list_reverse (td->string_list);
00429         td->id = "19th century Millenium Eve";
00430         test_data = g_list_prepend (test_data, td);
00431     }
00432     {
00433         QTestDate *td = g_new0 (QTestDate, 1);
00434         td->time = qof_time_new ();
00435         qof_time_set_secs (td->time, 
00436             G_GINT64_CONSTANT(-13311993599));
00437         qof_time_set_nanosecs (td->time, 0);
00438         td->date = qof_date_new ();
00439         td->date->qd_year = 1548;
00440         td->date->qd_mon  = 2;
00441         td->date->qd_mday = 29;
00442         td->date->qd_hour = 0;
00443         td->date->qd_min  = 0;
00444         td->date->qd_sec  = G_GINT64_CONSTANT(1);
00445         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00446         qof_date_valid (td->date);
00447         td->string_list = NULL;
00448         td->string_list = g_list_prepend (td->string_list, "02/29/1548");
00449         td->string_list = g_list_prepend (td->string_list, "29/02/1548");
00450         td->string_list = g_list_prepend (td->string_list, "29.02.1548");
00451         td->string_list = g_list_prepend (td->string_list, "1548-02-29");
00452         td->string_list = g_list_prepend (td->string_list, "1548-02-29T00:00:01Z");
00453         td->string_list = g_list_prepend (td->string_list, 
00454             "1548-02-29 00:00:01.000000000 +0000");
00455         td->string_list = g_list_reverse (td->string_list);
00456         td->id = "16th century leap day";
00457         test_data = g_list_prepend (test_data, td);
00458     }
00459     {
00460         QTestDate *td = g_new0 (QTestDate, 1);
00461         td->time = qof_time_new ();
00462         qof_time_set_secs (td->time, G_GINT64_CONSTANT(-28502726400));
00463         qof_time_set_nanosecs (td->time, 0);
00464         td->date = qof_date_new ();
00465         td->date->qd_year = 1066;
00466         td->date->qd_mon  = 10;
00467         td->date->qd_mday = 14;
00468         td->date->qd_hour = 8;
00469         td->date->qd_min  = 0;
00470         td->date->qd_sec  = G_GINT64_CONSTANT(0);
00471         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00472         qof_date_valid (td->date);
00473         td->string_list = NULL;
00474         td->string_list = g_list_prepend (td->string_list, "10/14/1066");
00475         td->string_list = g_list_prepend (td->string_list, "14/10/1066");
00476         td->string_list = g_list_prepend (td->string_list, "14.10.1066");
00477         td->string_list = g_list_prepend (td->string_list, "1066-10-14");
00478         td->string_list = g_list_prepend (td->string_list, "1066-10-14T08:00:00Z");
00479         td->string_list = g_list_prepend (td->string_list, 
00480             "1066-10-14 08:00:00.000000000 +0000");
00481         td->string_list = g_list_reverse (td->string_list);
00482         td->id = "Battle of Hastings, 1066";
00483         test_data = g_list_prepend (test_data, td);
00484     }
00485     {
00486         QTestDate *td = g_new0 (QTestDate, 1);
00487         td->time = qof_time_new ();
00488         qof_time_set_secs (td->time, 
00489             G_GINT64_CONSTANT(-36417340799));
00490         qof_time_set_nanosecs (td->time, 0);
00491         td->date = qof_date_new ();
00492         td->date->qd_year = 815;
00493         td->date->qd_mon  = 12;
00494         td->date->qd_mday = 25;
00495         td->date->qd_hour = 0;
00496         td->date->qd_min  = 0;
00497         td->date->qd_sec  = G_GINT64_CONSTANT(1);
00498         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00499         qof_date_valid (td->date);
00500         td->string_list = NULL;
00501         td->string_list = g_list_prepend (td->string_list, "12/25/0815");
00502         td->string_list = g_list_prepend (td->string_list, "25/12/0815");
00503         td->string_list = g_list_prepend (td->string_list, "25.12.0815");
00504         td->string_list = g_list_prepend (td->string_list, "0815-12-25");
00505         td->string_list = g_list_prepend (td->string_list, "0815-12-25T00:00:01Z");
00506         td->string_list = g_list_prepend (td->string_list, 
00507             "0815-12-25 00:00:01.000000000 +0000");
00508         td->string_list = g_list_reverse (td->string_list);
00509         td->id = "9th century Christmas Day";
00510         test_data = g_list_prepend (test_data, td);
00511     }
00512     {
00513         QTestDate *td = g_new0 (QTestDate, 1);
00514         td->time = qof_time_new ();
00515         qof_time_set_secs (td->time, G_GINT64_CONSTANT(-60798160800));
00516         qof_time_set_nanosecs (td->time, 0);
00517         td->date = qof_date_new ();
00518         td->date->qd_year = 43;
00519         td->date->qd_mon  = 5;
00520         td->date->qd_mday = 20;
00521         td->date->qd_hour = 14;
00522         td->date->qd_min  = 0;
00523         td->date->qd_sec  = G_GINT64_CONSTANT(0);
00524         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00525         qof_date_valid (td->date);
00526         td->string_list = NULL;
00527         td->string_list = g_list_prepend (td->string_list, "05/20/0043");
00528         td->string_list = g_list_prepend (td->string_list, "20/05/0043");
00529         td->string_list = g_list_prepend (td->string_list, "20.05.0043");
00530         td->string_list = g_list_prepend (td->string_list, "0043-05-20");
00531         td->string_list = g_list_prepend (td->string_list, "0043-05-20T14:00:00Z");
00532         td->string_list = g_list_prepend (td->string_list, 
00533             "0043-05-20 14:00:00.000000000 +0000");
00534         td->string_list = g_list_reverse (td->string_list);
00535         td->id = "approx Roman invasion, 43AD";
00536         test_data = g_list_prepend (test_data, td);
00537     }
00542     {
00543         QTestDate *td = g_new0 (QTestDate, 1);
00544         td->time = qof_time_new ();
00545         qof_time_set_secs (td->time, G_GINT64_CONSTANT(-62167824001));
00546         qof_time_set_nanosecs (td->time, 0);
00547         td->date = qof_date_new ();
00548         td->date->qd_year = -1;
00549         td->date->qd_mon  = 12;
00550         td->date->qd_mday = 24;
00551         td->date->qd_hour = 23;
00552         td->date->qd_min  = 59;
00553         td->date->qd_sec  = G_GINT64_CONSTANT(59);
00554         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00555         qof_date_valid (td->date);
00556         td->string_list = NULL;
00557         td->string_list = g_list_prepend (td->string_list, "12/24/-001");
00558         td->string_list = g_list_prepend (td->string_list, "24/12/-001");
00559         td->string_list = g_list_prepend (td->string_list, "24.12.-001");
00560         td->string_list = g_list_prepend (td->string_list, "-001-12-24");
00561         td->string_list = g_list_prepend (td->string_list, "-001-12-24T23:59:59Z");
00562         td->string_list = g_list_prepend (td->string_list, 
00563             "-001-12-24 23:59:59.000000000 +0000");
00564         td->string_list = g_list_reverse (td->string_list);
00565         td->id = "Xmas eve, 1BC";
00566         test_data = g_list_prepend (test_data, td);
00567     }
00568     {
00569         QTestDate *td = g_new0 (QTestDate, 1);
00570         td->time = qof_time_new ();
00571         qof_time_set_secs (td->time, 
00572             G_GINT64_CONSTANT(-204110409601));
00573         qof_time_set_nanosecs (td->time, 0);
00574         td->date = qof_date_new ();
00575         td->date->qd_year = -4499;
00576         td->date->qd_mon  = 12;
00577         td->date->qd_mday = 31;
00578         td->date->qd_hour = 23;
00579         td->date->qd_min  = 59;
00580         td->date->qd_sec  = G_GINT64_CONSTANT(59);
00581         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00582         qof_date_valid (td->date);
00583         td->string_list = NULL;
00584         td->string_list = g_list_prepend (td->string_list, "12/31/-4499");
00585         td->string_list = g_list_prepend (td->string_list, "31/12/-4499");
00586         td->string_list = g_list_prepend (td->string_list, "31.12.-4499");
00587         td->string_list = g_list_prepend (td->string_list, "-4499-12-31");
00588         td->string_list = g_list_prepend (td->string_list, "-4499-12-31T23:59:59Z");
00589         td->string_list = g_list_prepend (td->string_list, 
00590             "-4499-12-31 23:59:59.000000000 +0000");
00591         td->string_list = g_list_reverse (td->string_list);
00592         td->id = "far past.";
00593         test_data = g_list_prepend (test_data, td);
00594     }
00595     {
00596         QTestDate *td = g_new0 (QTestDate, 1);
00597         td->time = qof_time_new ();
00598         qof_time_set_secs (td->time, 
00599             G_GINT64_CONSTANT(-2097527529601));
00600         qof_time_set_nanosecs (td->time, 0);
00601         td->date = qof_date_new ();
00602         td->date->qd_year = -64499;
00603         td->date->qd_mon  = 12;
00604         td->date->qd_mday = 31;
00605         td->date->qd_hour = 23;
00606         td->date->qd_min  = 59;
00607         td->date->qd_sec  = G_GINT64_CONSTANT(59);
00608         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00609         qof_date_valid (td->date);
00610         td->string_list = NULL;
00611         td->string_list = g_list_prepend (td->string_list, "12/31/-64499");
00612         td->string_list = g_list_prepend (td->string_list, "31/12/-64499");
00613         td->string_list = g_list_prepend (td->string_list, "31.12.-64499");
00614         td->string_list = g_list_prepend (td->string_list, "-64499-12-31");
00615         td->string_list = g_list_prepend (td->string_list, "-64499-12-31T23:59:59Z");
00616         td->string_list = g_list_prepend (td->string_list, 
00617             "-64499-12-31 23:59:59.000000000 +0000");
00618         td->string_list = g_list_reverse (td->string_list);
00619         td->id = "far, far past.";
00620         test_data = g_list_prepend (test_data, td);
00621     }
00622     /* now test far future dates */
00623     {
00624         QTestDate *td = g_new0 (QTestDate, 1);
00625         td->time = qof_time_new ();
00626         qof_time_set_secs (td->time, G_GINT64_CONSTANT(32679095666));
00627         qof_time_set_nanosecs (td->time, 800);
00628         td->date = qof_date_new ();
00629         td->date->qd_year = 3005;
00630         td->date->qd_mon  = 7;
00631         td->date->qd_mday = 24;
00632         td->date->qd_hour = 6;
00633         td->date->qd_min  = 34;
00634         td->date->qd_sec  = G_GINT64_CONSTANT(26);
00635         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00636         qof_date_valid (td->date);
00637         td->string_list = NULL;
00638         td->string_list = g_list_prepend (td->string_list, "07/24/3005");
00639         td->string_list = g_list_prepend (td->string_list, "24/07/3005");
00640         td->string_list = g_list_prepend (td->string_list, "24.07.3005");
00641         td->string_list = g_list_prepend (td->string_list, "3005-07-24");
00642         td->string_list = g_list_prepend (td->string_list, "3005-07-24T06:34:26Z");
00643         td->string_list = g_list_prepend (td->string_list, 
00644             "3005-07-24 06:34:26.000000800 +0000");
00645         td->string_list = g_list_reverse (td->string_list);
00646         td->id = "24th July 3005";
00647         test_data = g_list_prepend (test_data, td);
00648     }
00649     {
00650         QTestDate *td = g_new0 (QTestDate, 1);
00651         td->time = qof_time_new ();
00652         qof_time_set_secs (td->time, 
00653             G_GINT64_CONSTANT(79839129599));
00654         qof_time_set_nanosecs (td->time, 50000);
00655         td->date = qof_date_new ();
00656         td->date->qd_year = 4499;
00657         td->date->qd_mon  = 12;
00658         td->date->qd_mday = 31;
00659         td->date->qd_hour = 23;
00660         td->date->qd_min  = 59;
00661         td->date->qd_sec  = G_GINT64_CONSTANT(59);
00662         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00663         qof_date_valid (td->date);
00664         td->string_list = NULL;
00665         td->string_list = g_list_prepend (td->string_list, "12/31/4499");
00666         td->string_list = g_list_prepend (td->string_list, "31/12/4499");
00667         td->string_list = g_list_prepend (td->string_list, "31.12.4499");
00668         td->string_list = g_list_prepend (td->string_list, "4499-12-31");
00669         td->string_list = g_list_prepend (td->string_list, "4499-12-31T23:59:59Z");
00670         td->string_list = g_list_prepend (td->string_list, 
00671             "4499-12-31 23:59:59.000050000 +0000");
00672         td->string_list = g_list_reverse (td->string_list);
00673         td->id = "44th century Millenium Eve";
00674         test_data = g_list_prepend (test_data, td);
00675     }
00676     {
00677         QTestDate *td = g_new0 (QTestDate, 1);
00678         td->time = qof_time_new ();
00679         qof_time_set_secs (td->time, 
00680             G_GINT64_CONSTANT(395408649599));
00681         qof_time_set_nanosecs (td->time, 7000000);
00682         td->date = qof_date_new ();
00683         td->date->qd_year = 14499;
00684         td->date->qd_mon  = 12;
00685         td->date->qd_mday = 31;
00686         td->date->qd_hour = 23;
00687         td->date->qd_min  = 59;
00688         td->date->qd_sec  = G_GINT64_CONSTANT(59);
00689         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00690         qof_date_valid (td->date);
00691         td->string_list = NULL;
00692         td->string_list = g_list_prepend (td->string_list, "12/31/14499");
00693         td->string_list = g_list_prepend (td->string_list, "31/12/14499");
00694         td->string_list = g_list_prepend (td->string_list, "31.12.14499");
00695         td->string_list = g_list_prepend (td->string_list, "14499-12-31");
00696         td->string_list = g_list_prepend (td->string_list, "14499-12-31T23:59:59Z");
00697         td->string_list = g_list_prepend (td->string_list, 
00698             "14499-12-31 23:59:59.007000000 +0000");
00699         td->string_list = g_list_reverse (td->string_list);
00700         td->id = "144th century Millenium Eve";
00701         test_data = g_list_prepend (test_data, td);
00702     }
00703     {
00704         QTestDate *td = g_new0 (QTestDate, 1);
00705         td->time = qof_time_new ();
00706         qof_time_set_secs (td->time, 
00707             G_GINT64_CONSTANT(74869815369599));
00708         qof_time_set_nanosecs (td->time, 45321545);
00709         td->date = qof_date_new ();
00710         td->date->qd_year = 2374499;
00711         td->date->qd_mon  = 12;
00712         td->date->qd_mday = 31;
00713         td->date->qd_hour = 23;
00714         td->date->qd_min  = 59;
00715         td->date->qd_sec  = G_GINT64_CONSTANT(59);
00716         td->date->qd_nanosecs = qof_time_get_nanosecs (td->time);
00717         qof_date_valid (td->date);
00718         td->string_list = NULL;
00719         td->string_list = g_list_prepend (td->string_list, "12/31/2374499");
00720         td->string_list = g_list_prepend (td->string_list, "31/12/2374499");
00721         td->string_list = g_list_prepend (td->string_list, "31.12.2374499");
00722         td->string_list = g_list_prepend (td->string_list, "2374499-12-31");
00723         td->string_list = g_list_prepend (td->string_list, "2374499-12-31T23:59:59Z");
00724         td->string_list = g_list_prepend (td->string_list,
00725             "2374499-12-31 23:59:59.045321545 +0000");
00726         td->string_list = g_list_reverse (td->string_list);
00727         td->id = "far, far future";
00728         test_data = g_list_prepend (test_data, td);
00729     }
00730 }
00731 
00732 static void
00733 free_test_data (gpointer data, gpointer user_data)
00734 {
00735     QTestDate *td;
00736 
00737     td = (QTestDate*)data;
00738     qof_date_free (td->date);
00739     qof_time_free (td->time);
00740     td->string_list = NULL;
00741     g_free (td);
00742     td = NULL;
00743 }
00744 
00745 static void
00746 test_date_close (void)
00747 {
00748     g_list_foreach (test_data, free_test_data, NULL);
00749 }
00750 
00751 static void
00752 scan_and_stamp (const gchar * str, QofDateFormat df, QofTimeSecs check)
00753 {
00754     QofTime *scan;
00755     QofDate *qd;
00756     gchar *stamp;
00757 
00758     qd = qof_date_parse (str, df);
00759     scan = qof_date_to_qtime (qd);
00760     do_test ((scan != NULL), "scan failed");
00761     if (scan == NULL)
00762         return;
00763     do_test ((0 == safe_strcasecmp(qd->qd_zone, "GMT")),
00764         " timezone reset incorrect");
00765     do_test ((qof_time_get_secs (scan) == check), 
00766         "wrong time value");
00767     if (qof_time_get_secs (scan) != check)
00768         PERR (" wrong time value %"
00769             G_GINT64_FORMAT " %" G_GINT64_FORMAT " diff=%"
00770             G_GINT64_FORMAT " df=%d str=%s cmp=%s",
00771             qof_time_get_secs (scan), check,
00772             qof_time_get_secs (scan) - check, df, str,
00773             qof_date_print(qd, QOF_DATE_FORMAT_UTC));
00774     stamp = qof_date_print (qof_date_from_qtime(scan), df);
00775     do_test ((stamp != NULL), "stamp failed");
00776     /* timezone tests mean stamp cannot be compared to str */
00777     qof_time_free (scan);
00778 }
00779 
00780 static void
00781 stamp_and_scan (QofTimeSecs start, glong nanosecs, 
00782     QofDateFormat df)
00783 {
00784     gchar *str1, *str2;
00785     QofDate *check;
00786     QofTime *time, *scan;
00787 
00788     time = qof_time_new ();
00789     qof_time_set_secs (time, start);
00790     qof_time_set_nanosecs (time, nanosecs);
00791     str1 = qof_date_print (qof_date_from_qtime(time), df);
00792     do_test ((str1 != NULL), "stamp failed");
00793     if (!str1)
00794         return;
00795     check = qof_date_parse (str1, df);
00796     do_test ((check != NULL), "parse failed");
00797     if (!check)
00798         PERR (" tried to parse %s\n", str1);
00799     scan = qof_date_to_qtime (check);
00800     qof_date_free (check);
00801     do_test ((scan != NULL), "scan failed");
00802     if (!scan)
00803         return;
00804     /* depending on the format, data may be lost here
00805     as some formats do not encode the time. So only
00806     test that the returned stamp is the same. */
00807     check = qof_date_from_qtime (scan);
00808     str2 = qof_date_print (check, df);
00809     qof_date_free (check);
00810     /* 2 digit year errors with format 6  */
00811     do_test ((str2 != NULL), "printed string is null");
00812     do_test ((qof_date_from_qtime (scan) != NULL),
00813         "from_qtime failed");
00814     do_test ((0 == safe_strcasecmp (str1, str2)), 
00815         "stamp different to scan");
00816     if (0 != safe_strcasecmp (str1, str2))
00817         PERR (" df=%d str=%s scan=%s", df, str1, str2);
00818     qof_time_free (scan);
00819     qof_time_free (time);
00820     g_free (str1);
00821     g_free (str2);
00822 }
00823 
00824 static void
00825 run_print_scan_tests (void)
00826 {
00827     gint i;
00828     gint64 secs;
00829     QofDateFormat df;
00830 
00831     /* Set a secs value at the limit of the range of time_t 
00832        on 32bit systems. */
00833     secs = G_MAXINT32;
00834     /* add ten days */
00835     secs += SECS_PER_DAY * 10;
00836     for (i = 1; i <= QOF_DATE_FORMAT_ISO8601; i++)
00837     {
00838         stamp_and_scan (796179600, 0, i);
00839         stamp_and_scan (796179500, 72000, i);
00840         stamp_and_scan (152098136, 0, i);
00841         stamp_and_scan (1964049931, 0, i);
00842         stamp_and_scan (1162088421, 12548000, i);
00843         stamp_and_scan (325659000 - 6500, 0, i);
00844         stamp_and_scan (1143943200, 0, i);
00845         stamp_and_scan (1603591171, 595311000, i);
00846         stamp_and_scan (1738909365, 204102000, i);
00847         stamp_and_scan (1603591171, 595311000, i);
00848         stamp_and_scan (1143943200 - 1, 0, i);
00849         stamp_and_scan (1143943200, 0, i);
00850         stamp_and_scan (1143943200 + (7 * 60 * 60), 0, i);
00851         stamp_and_scan (1143943200 + (8 * 60 * 60), 0, i);
00852         stamp_and_scan (1841443200, 0, i);
00853 
00854         /* work with early dates */
00855         stamp_and_scan (G_GINT64_CONSTANT (-796179600), 253, i);
00856         stamp_and_scan (G_GINT64_CONSTANT (-152098136), 865, i);
00857         stamp_and_scan (G_GINT64_CONSTANT (-1143943200), 67, i);
00858         stamp_and_scan (G_GINT64_CONSTANT (-1964049931), 53, i);
00859         stamp_and_scan (G_GINT64_CONSTANT (-2463880447), 48, i);
00860         stamp_and_scan (G_GINT64_CONSTANT (-22905158401), 9, i);
00861         stamp_and_scan (G_GINT64_CONSTANT (-28502726400), 1, i);
00862         stamp_and_scan (G_GINT64_CONSTANT (-60798211200), 0, i);
00863         stamp_and_scan (G_GINT64_CONSTANT (-32727638740), 0, i);
00864 /*      stamp_and_scan (G_GINT64_CONSTANT (-86956848000), 0, i);*/
00865         stamp_and_scan (secs, 0, i);
00866         /* Wed 29 Jan 2048 03:14:07 UTC */
00867         stamp_and_scan (G_GINT64_CONSTANT (2463880447), 0, i);
00868         /* Sat 29 Jan 2050 03:14:07 UTC */
00869         stamp_and_scan (G_GINT64_CONSTANT (2527038847), 0, i);
00870         /* work with far future dates */
00871         /* 32,727,638,740 Fri Feb  6 02:45:40 UTC 3007 */
00872         stamp_and_scan (G_GINT64_CONSTANT (32727638740), 0, i);
00873         /* 88,313,632,867 Fri Jul 19 12:41:07 UTC 4768 */
00874         stamp_and_scan (G_GINT64_CONSTANT (88313632867), 0, i);
00875         /* 189,216,632,865 Fri Jan 14 07:47:45 UTC 7966 */
00876         stamp_and_scan (G_GINT64_CONSTANT (189216632865), 0, i);
00877         /* 378,432,632,864 Sat Jan 20 07:47:44 UTC 13,962  */
00878         stamp_and_scan (G_GINT64_CONSTANT (378432632864), 0, i);
00879         /* 3165071328567 Wed Feb 13 00:09:27 UTC 102,267 */
00880         stamp_and_scan (G_GINT64_CONSTANT (3165071328567), 0, i);
00881     }
00882     /* far, far future dates delay the test */
00883 #ifdef TEST_DEBUG
00884     /* 43165071328567 Wed Aug 28 23:16:07 UTC 1,369,816 */
00885     stamp_and_scan (G_GINT64_CONSTANT (3165071328567), 
00886         0, QOF_DATE_FORMAT_UTC);
00887     /* 843165071328567 Tue Jun 19 05:29:27 UTC 26,720,807 */
00888     stamp_and_scan (G_GINT64_CONSTANT(843165071328567), 
00889         0, QOF_DATE_FORMAT_UTC);
00891     /* 9843165071328567 Mon Jan  9 21:29:27 UTC 311,919,454 */
00892 /*  stamp_and_scan (G_GINT64_CONSTANT(9843165071328567), 
00893         0, QOF_DATE_FORMAT_UTC);
00894     stamp_and_scan (G_GINT64_CONSTANT(9843165071328567), 
00895         354758450, QOF_DATE_FORMAT_ISO8601);*/
00896 #endif
00897     scan_and_stamp ("05/09/2006", QOF_DATE_FORMAT_US, 
00898         1147132800);
00899     scan_and_stamp ("09/05/2006", QOF_DATE_FORMAT_UK, 
00900         1147132800);
00901     scan_and_stamp ("09.05.2006", QOF_DATE_FORMAT_CE, 
00902         1147132800);
00903     scan_and_stamp ("2006-05-09", QOF_DATE_FORMAT_ISO, 
00904         1147132800);
00905     scan_and_stamp ("2006-05-09T00:00:00Z", QOF_DATE_FORMAT_UTC, 
00906         1147132800);
00907     scan_and_stamp ("2006-05-09T14:49:04Z", QOF_DATE_FORMAT_UTC, 
00908         1147186144);
00909 
00910     /* test a custom format */
00911     df = 0;
00912     do_test ((qof_date_format_add ("%Y-%m-%d %H:%M:%S %z", 
00913         &df) == TRUE), "failed to add scan suitable format");
00914     /* test timezone settings */
00915     /* 1972-01-01T00:00:00Z */
00916     scan_and_stamp ("1971-12-31 15:00:00 -0900", df, 63072000);
00917     /* 1980-01-01T00:00:00Z */
00918     scan_and_stamp ("1979-12-31 15:00:00 -0900", df, 315532800);
00919     scan_and_stamp ("1980-01-01 00:00:00 -0000", df, 315532800);
00920     scan_and_stamp ("1980-01-01 00:00:00 +0000", df, 315532800);
00921     scan_and_stamp ("1980-01-01 09:00:00 +0900", df, 315532800);
00922     scan_and_stamp ("1980-01-01 08:30:00 +0830", df, 315532800);
00923     /* pre-1970 dates */
00924     scan_and_stamp ("1963-11-22 14:00:00 -0500", df, -192776400);
00925     scan_and_stamp ("1945-09-08 11:02:00 +0900", df, -767311080);
00926     scan_and_stamp ("1918-11-11 11:00:00 +0000", df, -1613826000);
00927     /* work with really early dates */
00928     /* 14th October 1066 (time is just a guess) */
00929     scan_and_stamp ("1066-10-14 08:00:00 +0000", df, 
00930         G_GINT64_CONSTANT (-28502726400));
00931     /* May 43AD Roman invasion (day and time guessed) */
00932     scan_and_stamp ("0043-05-20 14:00:00 +0000", df, 
00933         G_GINT64_CONSTANT (-60798160800));
00934     {
00935         QofDate *qd;
00936         QofTime *qt;
00937         gint64 secs;
00938 
00939         qt = qof_time_new ();
00940         /* Tue May  9 14:50:10 UTC 2006 */
00941         qof_time_set_secs (qt, 1147186210);
00942         qd = qof_date_from_qtime (qt);
00943         do_test ((qof_date_adddays (qd, 45) == TRUE),
00944                  "add_days failed");
00945         secs = 1147186210 + (45 * SECS_PER_DAY);
00946         qof_time_free (qt);
00947         qt = qof_date_to_qtime (qd);
00948         qof_date_free (qd);
00949         do_test ((secs == qof_time_get_secs (qt)),
00950                  "add_days gave incorrect result.");
00951         if (secs != qof_time_get_secs (qt))
00952             PERR (" secs=%" G_GINT64_FORMAT "cmp=%"
00953             G_GINT64_FORMAT, secs, qof_time_get_secs (qt));
00954         qof_time_set_secs (qt, 1147186210);
00955         qd = qof_date_from_qtime (qt);
00956         do_test ((qof_date_addmonths (qd, 50, TRUE) == TRUE),
00957                  "add_months failed");
00958         qof_time_free (qt);
00959         qt = qof_date_to_qtime (qd);
00960         do_test ((1278687010 == qof_time_get_secs (qt)),
00961                  "add_months gave incorrect result.");
00962         qof_time_free (qt);
00963         qof_date_free (qd);
00964     }
00965 }
00966 
00967 static void
00968 run_qofdate_test (void)
00969 {
00970     QofDateFormat df, test;
00971 
00972     df = qof_date_format_get_current ();
00973     /* default date format tests */
00974     {
00975         qof_date_format_set_current (QOF_DATE_FORMAT_UK);
00976         test = qof_date_format_get_current ();
00977         do_test ((test == QOF_DATE_FORMAT_UK), 
00978             "setting current format as UK");
00979         do_test ((safe_strcasecmp (qof_date_format_to_name (test), 
00980             "uk") == 0), "getting the shorthand name");
00981         do_test ((FALSE ==
00982             qof_date_format_set_name ("foo", QOF_DATE_FORMAT_UK)),
00983             "default name should not be overridden");
00984         do_test ((QOF_DATE_FORMAT_UK == 
00985             qof_date_format_from_name ("uk")),
00986             "getting date format from shorthand name");
00987         do_test (('/' == qof_date_format_get_date_separator (test)),
00988             "getting date format separator from date format");
00989         do_test ((FALSE == qof_date_format_set_date_separator (':', 
00990             test)), "default separator should not be overridden");
00991     }
00992     /* custom date format tests */
00993     {
00994         QofDateFormat df, df2;
00995         do_test ((qof_date_format_add ("%T", &df) == TRUE),
00996                  "adding a valid format");
00997         do_test ((qof_date_format_add ("%a%A%b%B%c%C%d%D%e%F%f%r", 
00998                 &df2) == FALSE), "adding an invalid format");
00999         qof_date_format_set_current (df);
01000         test = qof_date_format_get_current ();
01001         do_test ((test == df), "setting current format");
01002         do_test ((safe_strcasecmp (qof_date_format_to_name (test), 
01003             "%T") == 0), "getting the shorthand name");
01004         do_test ((TRUE == qof_date_format_set_name ("foo", test)),
01005                  "custom name should be overridden");
01006         do_test ((test == qof_date_format_from_name ("foo")),
01007                  "getting date format from shorthand name");
01008         do_test (('\0' == qof_date_format_get_date_separator (test)),
01009                  "getting date format separator from date format");
01010         do_test ((TRUE == qof_date_format_set_date_separator (':', test)),
01011                  "custom separator should be overridden");
01012         do_test ((':' == qof_date_format_get_date_separator (test)),
01013                  "getting modified date format separator from date format");
01014     }
01015     qof_date_format_set_current (df);
01016     /* run tests on date_normalise */
01017     {
01018         QofDate *date;
01019 
01020         date = qof_date_new ();
01021         /* Mon Jan  3 00:00:30 UTC 2000 */
01022         date->qd_sec = SECS_PER_DAY * 2 + 30;
01023         date->qd_year = 2000;
01024         do_test ((qof_date_valid (date) == TRUE), "date 1 was invalid");
01025         do_test ((date->qd_sec == 30), "normalised seconds incorrect - 1");
01026         do_test ((date->qd_mday == 2), "normalised day incorrect - 1");
01027         date->qd_mday = 54;
01028         do_test ((qof_date_valid (date) == TRUE), "date 2 was invalid");
01029         do_test ((date->qd_sec == 30), "normalised seconds incorrect - 2");
01030         do_test ((date->qd_mday == 23), "normalised day incorrect - 2");
01031         date->qd_hour = 34;
01032         qof_date_valid (date);
01033         do_test ((date->qd_hour == 10), "normalised hour incorrect");
01034         do_test ((date->qd_mday == 24), "normalised day incorrect - 3");
01035         date->qd_mon = 17;
01036         qof_date_valid (date);
01037         do_test ((date->qd_mon == 5), "normalised month incorrect");
01038         do_test ((date->qd_year == 2001), "normalised year incorrect");
01039         date->qd_hour = 27;
01040         qof_date_valid (date);
01041         do_test ((date->qd_hour == 3), "normalised hour incorrect - 1");
01042         do_test ((date->qd_mday == 25), "normalised day incorrect - 4");
01043         date->qd_hour = -53;
01044         qof_date_valid (date);
01045         do_test ((date->qd_hour == 19), "normalised hour incorrect - 2");
01046         do_test ((date->qd_mday == 22), "normalised day incorrect - 5");
01047         date->qd_min = -225;
01048         qof_date_valid (date);
01049         do_test ((date->qd_min == 15), "normalised min incorrect");
01050         do_test ((date->qd_hour == 15), "normalised hour incorrect - 3");
01051         date->qd_min = 5;
01052         date->qd_sec = 68;
01053         qof_date_valid (date);
01054         do_test ((date->qd_sec == 8), "doxygen sec example incorrect - 1");
01055         do_test ((date->qd_min == 6),  "doxygen min example incorrect - 1");
01056         date->qd_min = 5;
01057         date->qd_sec = -64;
01058         qof_date_valid (date);
01059         do_test ((date->qd_sec == 56), "doxygen sec example incorrect - 2");
01060         do_test ((date->qd_min == 3),  "doxygen min example incorrect - 2");
01061     }
01062     /* run tests against QofDate<->QofTime conversions. */
01063     /* opposite direction compared to the tests above. */
01064     {
01065         QofDate *qd;
01066         QofTime *qt;
01067         gchar *str1;
01068 
01069         qd = qof_date_new ();
01070         qd->qd_year = 2006;
01071         qd->qd_mon = 5;
01072         qd->qd_mday = 30;
01073         qd->qd_hour = 18;
01074         qd->qd_min = 24;
01075         qd->qd_sec = 17;
01076         qd->qd_nanosecs = 123456789;
01077         do_test ((qof_date_valid (qd)), "date not valid");
01078         qt = qof_date_to_qtime (qd);
01079         str1 = qof_date_print (qd, QOF_DATE_FORMAT_UTC);
01080         do_test ((0 == safe_strcasecmp (str1, 
01081             "2006-05-30T18:24:17Z")), "with nanosecs");
01082         do_test ((qof_time_get_nanosecs (qt) ==
01083             123456789L), "nanosecs mismatched.");
01084         do_test ((0 == safe_strcasecmp ("05/30/2006",
01085             qof_date_print (qd, QOF_DATE_FORMAT_US))), 
01086             "strftime:US:first");
01087         do_test ((0 == safe_strcasecmp ("30/05/2006",
01088             qof_date_print (qd, QOF_DATE_FORMAT_UK))), 
01089             "strftime:UK:first");
01090         do_test ((0 == safe_strcasecmp ("30.05.2006",
01091             qof_date_print (qd, QOF_DATE_FORMAT_CE))), 
01092             "strftime:CE:first");
01093         do_test ((0 == safe_strcasecmp ("2006-05-30",
01094             qof_date_print (qd, QOF_DATE_FORMAT_ISO))), 
01095             "strftime:ISO:first");
01096         do_test ((0 == safe_strcasecmp ("2006-05-30T18:24:17Z",
01097             qof_date_print (qd, QOF_DATE_FORMAT_UTC))), 
01098             "strftime:UTC:first");
01099         do_test ((0 != safe_strcasecmp (NULL,
01100             qof_date_print (qd, QOF_DATE_FORMAT_LOCALE))), 
01101             "strftime:LOCALE:first:inrange");
01102         do_test ((0 != safe_strcasecmp (NULL,
01103             qof_date_print (qd, QOF_DATE_FORMAT_CUSTOM))), 
01104             "strftime:CUSTOM:first:inrange");
01105         qof_date_free (qd);
01106         qof_time_free (qt);
01107         qd = qof_date_new ();
01108         qd->qd_year = 3005;
01109         qd->qd_mon = 07;
01110         qd->qd_mday = 24;
01111         qd->qd_hour = 06;
01112         qd->qd_min  = 34;
01113         qd->qd_sec  = 26;
01114         do_test ((qof_date_valid (qd)), "date not valid");
01115         qt = qof_date_to_qtime (qd);
01116         do_test ((0 == safe_strcasecmp ("07/24/3005",
01117             qof_date_print (qd, QOF_DATE_FORMAT_US))), 
01118             "strftime:US:forward");
01119         do_test ((0 == safe_strcasecmp ("24/07/3005",
01120             qof_date_print (qd, QOF_DATE_FORMAT_UK))), 
01121             "strftime:UK:forward");
01122         do_test ((0 == safe_strcasecmp ("24.07.3005",
01123             qof_date_print (qd, QOF_DATE_FORMAT_CE))), 
01124             "strftime:CE:forward");
01125         do_test ((0 == safe_strcasecmp ("3005-07-24",
01126             qof_date_print (qd, QOF_DATE_FORMAT_ISO))), 
01127             "strftime:ISO:forward");
01128         do_test ((0 == safe_strcasecmp ("3005-07-24T06:34:26Z",
01129             qof_date_print (qd, QOF_DATE_FORMAT_UTC))), 
01130             "strftime:UTC:forward");
01131         do_test ((0 != safe_strcasecmp (NULL,
01132             qof_date_print (qd, QOF_DATE_FORMAT_LOCALE))), 
01133             "strftime:LOCALE:forward:inrange");
01134         do_test ((0 != safe_strcasecmp (NULL,
01135             qof_date_print (qd, QOF_DATE_FORMAT_CUSTOM))), 
01136             "strftime:CUSTOM:forward:inrange");
01137         qof_date_free (qd);
01138         qd = qof_date_new ();
01139         qd->qd_year = 4500;
01140         qd->qd_mon = 07;
01141         qd->qd_mday = 24;
01142         qd->qd_hour = 06;
01143         qd->qd_min  = 34;
01144         qd->qd_sec  = 26;
01145         do_test ((qof_date_valid (qd)), "date not valid");
01146         qt = qof_date_to_qtime (qd);
01147         do_test ((0 == safe_strcasecmp ("07/24/4500",
01148             qof_date_print (qd, QOF_DATE_FORMAT_US))), 
01149             "strftime:US:fifth");
01150         do_test ((0 == safe_strcasecmp ("24/07/4500",
01151             qof_date_print (qd, QOF_DATE_FORMAT_UK))), 
01152             "strftime:UK:fifth");
01153         do_test ((0 == safe_strcasecmp ("24.07.4500",
01154             qof_date_print (qd, QOF_DATE_FORMAT_CE))), 
01155             "strftime:CE:fifth");
01156         do_test ((0 == safe_strcasecmp ("4500-07-24",
01157             qof_date_print (qd, QOF_DATE_FORMAT_ISO))), 
01158             "strftime:ISO:fifth");
01159         do_test ((0 == safe_strcasecmp ("4500-07-24T06:34:26Z",
01160             qof_date_print (qd, QOF_DATE_FORMAT_UTC))), 
01161             "strftime:UTC:fifth");
01162         do_test ((0 != safe_strcasecmp (NULL,
01163             qof_date_print (qd, QOF_DATE_FORMAT_LOCALE))), 
01164             "strftime:LOCALE:fifth:inrange");
01165         do_test ((0 != safe_strcasecmp (NULL,
01166             qof_date_print (qd, QOF_DATE_FORMAT_CUSTOM))), 
01167             "strftime:CUSTOM:fifth:inrange");
01168         qof_date_free (qd);
01169         qd = qof_date_new ();
01170         qd->qd_year = 45000;
01171         qd->qd_mon = 07;
01172         qd->qd_mday = 24;
01173         qd->qd_hour = 06;
01174         qd->qd_min  = 34;
01175         qd->qd_sec  = 26;
01176         do_test ((qof_date_valid (qd)), "date not valid");
01177         qt = qof_date_to_qtime (qd);
01178         do_test ((0 == safe_strcasecmp ("07/24/45000",
01179             qof_date_print (qd, QOF_DATE_FORMAT_US))), 
01180             "strftime:US:forward2");
01181         do_test ((0 == safe_strcasecmp ("24/07/45000",
01182             qof_date_print (qd, QOF_DATE_FORMAT_UK))), 
01183             "strftime:UK:forward2");
01184         do_test ((0 == safe_strcasecmp ("24.07.45000",
01185             qof_date_print (qd, QOF_DATE_FORMAT_CE))), 
01186             "strftime:CE:forward2");
01187         do_test ((0 == safe_strcasecmp ("45000-07-24",
01188             qof_date_print (qd, QOF_DATE_FORMAT_ISO))), 
01189             "strftime:ISO:forward2");
01190         do_test ((0 == safe_strcasecmp ("45000-07-24T06:34:26Z",
01191             qof_date_print (qd, QOF_DATE_FORMAT_UTC))), 
01192             "strftime:UTC:forward2");
01193         do_test ((0 != safe_strcasecmp (NULL,
01194             qof_date_print (qd, QOF_DATE_FORMAT_LOCALE))), 
01195             "strftime:LOCALE:forward2:outofrange");
01196         do_test ((0 != safe_strcasecmp (NULL,
01197             qof_date_print (qd, QOF_DATE_FORMAT_CUSTOM))), 
01198             "strftime:CUSTOM:forward2:outofrange");
01199         qof_date_free (qd);
01200         g_free (str1);
01201         qd = qof_date_new ();
01202         qd->qd_year = 1914;
01203         qd->qd_mon = 11;
01204         qd->qd_mday = 11;
01205         qd->qd_hour = 11;
01206         do_test ((qof_date_valid (qd)), "date not valid");
01207         qt = qof_date_to_qtime (qd);
01208         str1 = qof_date_print (qd, QOF_DATE_FORMAT_UTC);
01209         do_test ((0 == safe_strcasecmp (str1,
01210             "1914-11-11T11:00:00Z")), "armistice day");
01211         do_test ((0 == safe_strcasecmp ("11/11/1914",
01212             qof_date_print (qd, QOF_DATE_FORMAT_US))), 
01213             "strftime:US:second");
01214         do_test ((0 == safe_strcasecmp ("11/11/1914",
01215             qof_date_print (qd, QOF_DATE_FORMAT_UK))), 
01216             "strftime:UK:second");
01217         do_test ((0 == safe_strcasecmp ("11.11.1914",
01218             qof_date_print (qd, QOF_DATE_FORMAT_CE))), 
01219             "strftime:CE:second");
01220         do_test ((0 == safe_strcasecmp ("1914-11-11",
01221             qof_date_print (qd, QOF_DATE_FORMAT_ISO))), 
01222             "strftime:ISO:second");
01223         do_test ((0 == safe_strcasecmp ("1914-11-11T11:00:00Z",
01224             qof_date_print (qd, QOF_DATE_FORMAT_UTC))), 
01225             "strftime:UTC:second");
01226         do_test ((0 != safe_strcasecmp (NULL,
01227             qof_date_print (qd, QOF_DATE_FORMAT_LOCALE))), 
01228             "strftime:LOCALE:second:inrange");
01229         do_test ((0 != safe_strcasecmp (NULL,
01230             qof_date_print (qd, QOF_DATE_FORMAT_CUSTOM))), 
01231             "strftime:CUSTOM:second:inrange");
01232         qof_date_free (qd);
01233         qof_time_free (qt);
01234         qd = qof_date_new ();
01235         qd->qd_year = 1812;
01236         qd->qd_mon = 07;
01237         qd->qd_mday = 24;
01238         qd->qd_hour = 06;
01239         qd->qd_min  = 34;
01240         qd->qd_sec  = 26;
01241         do_test ((qof_date_valid (qd)), "date not valid");
01242         qt = qof_date_to_qtime (qd);
01243         do_test ((0 == safe_strcasecmp ("07/24/1812",
01244             qof_date_print (qd, QOF_DATE_FORMAT_US))), 
01245             "strftime:US:third");
01246         do_test ((0 == safe_strcasecmp ("24/07/1812",
01247             qof_date_print (qd, QOF_DATE_FORMAT_UK))), 
01248             "strftime:UK:third");
01249         do_test ((0 == safe_strcasecmp ("24.07.1812",
01250             qof_date_print (qd, QOF_DATE_FORMAT_CE))), 
01251             "strftime:CE:third");
01252         do_test ((0 == safe_strcasecmp ("1812-07-24",
01253             qof_date_print (qd, QOF_DATE_FORMAT_ISO))), 
01254             "strftime:ISO:third");
01255         do_test ((0 == safe_strcasecmp ("1812-07-24T06:34:26Z",
01256             qof_date_print (qd, QOF_DATE_FORMAT_UTC))), 
01257             "strftime:UTC:third");
01258         do_test ((0 == safe_strcasecmp (NULL,
01259             qof_date_print (qd, QOF_DATE_FORMAT_LOCALE))), 
01260             "strftime:LOCALE:third:outofrange");
01261         do_test ((0 == safe_strcasecmp (NULL,
01262             qof_date_print (qd, QOF_DATE_FORMAT_CUSTOM))), 
01263             "strftime:CUSTOM:third:outofrange");
01264         qof_date_free (qd);
01265         qd = qof_date_new ();
01266         qd->qd_year = 1066;
01267         qd->qd_mon = 07;
01268         qd->qd_mday = 24;
01269         qd->qd_hour = 06;
01270         qd->qd_min  = 34;
01271         qd->qd_sec  = 26;
01272         do_test ((qof_date_valid (qd)), "date not valid");
01273         qt = qof_date_to_qtime (qd);
01274         do_test ((0 == safe_strcasecmp ("07/24/1066",
01275             qof_date_print (qd, QOF_DATE_FORMAT_US))), 
01276             "strftime:US:fourth");
01277         do_test ((0 == safe_strcasecmp ("24/07/1066",
01278             qof_date_print (qd, QOF_DATE_FORMAT_UK))), 
01279             "strftime:UK:fourth");
01280         do_test ((0 == safe_strcasecmp ("24.07.1066",
01281             qof_date_print (qd, QOF_DATE_FORMAT_CE))), 
01282             "strftime:CE:fourth");
01283         do_test ((0 == safe_strcasecmp ("1066-07-24",
01284             qof_date_print (qd, QOF_DATE_FORMAT_ISO))), 
01285             "strftime:ISO:fourth");
01286         do_test ((0 == safe_strcasecmp ("1066-07-24T06:34:26Z",
01287             qof_date_print (qd, QOF_DATE_FORMAT_UTC))), 
01288             "strftime:UTC:fourth");
01289         do_test ((0 == safe_strcasecmp (NULL,
01290             qof_date_print (qd, QOF_DATE_FORMAT_LOCALE))), 
01291             "strftime:LOCALE:fourth:outofrange");
01292         do_test ((0 == safe_strcasecmp (NULL,
01293             qof_date_print (qd, QOF_DATE_FORMAT_CUSTOM))), 
01294             "strftime:CUSTOM:fourth:outofrange");
01295         qof_date_free (qd);
01296         qd = qof_date_new ();
01297         qd->qd_year = -45;
01298         qd->qd_mon = 07;
01299         qd->qd_mday = 24;
01300         qd->qd_hour = 06;
01301         qd->qd_min  = 34;
01302         qd->qd_sec  = 26;
01303         do_test ((qof_date_valid (qd)), "date not valid");
01304         qt = qof_date_to_qtime (qd);
01305         do_test ((0 == safe_strcasecmp ("07/24/-045",
01306             qof_date_print (qd, QOF_DATE_FORMAT_US))), 
01307             "strftime:US:fifth");
01308         do_test ((0 == safe_strcasecmp ("24/07/-045",
01309             qof_date_print (qd, QOF_DATE_FORMAT_UK))), 
01310             "strftime:UK:fifth");
01311         do_test ((0 == safe_strcasecmp ("24.07.-045",
01312             qof_date_print (qd, QOF_DATE_FORMAT_CE))), 
01313             "strftime:CE:fifth");
01314         do_test ((0 == safe_strcasecmp ("-045-07-24",
01315             qof_date_print (qd, QOF_DATE_FORMAT_ISO))), 
01316             "strftime:ISO:fifth");
01317         do_test ((0 == safe_strcasecmp ("-045-07-24T06:34:26Z",
01318             qof_date_print (qd, QOF_DATE_FORMAT_UTC))), 
01319             "strftime:UTC:fifth");
01320         do_test ((0 == safe_strcasecmp (NULL,
01321             qof_date_print (qd, QOF_DATE_FORMAT_LOCALE))), 
01322             "strftime:LOCALE:fifth:outofrange");
01323         do_test ((0 == safe_strcasecmp (NULL,
01324             qof_date_print (qd, QOF_DATE_FORMAT_CUSTOM))), 
01325             "strftime:CUSTOM:fifth:outofrange");
01326         qof_date_free (qd);
01327         qd = qof_date_new ();
01328         qd->qd_year = -4500;
01329         qd->qd_mon = 07;
01330         qd->qd_mday = 24;
01331         qd->qd_hour = 06;
01332         qd->qd_min  = 34;
01333         qd->qd_sec  = 26;
01334         do_test ((qof_date_valid (qd)), "date not valid");
01335         qt = qof_date_to_qtime (qd);
01336         do_test ((0 == safe_strcasecmp ("07/24/-4500",
01337             qof_date_print (qd, QOF_DATE_FORMAT_US))), 
01338             "strftime:US:sixth");
01339         do_test ((0 == safe_strcasecmp ("24/07/-4500",
01340             qof_date_print (qd, QOF_DATE_FORMAT_UK))), 
01341             "strftime:UK:sixth");
01342         do_test ((0 == safe_strcasecmp ("24.07.-4500",
01343             qof_date_print (qd, QOF_DATE_FORMAT_CE))), 
01344             "strftime:CE:sixth");
01345         do_test ((0 == safe_strcasecmp ("-4500-07-24",
01346             qof_date_print (qd, QOF_DATE_FORMAT_ISO))), 
01347             "strftime:ISO:sixth");
01348         do_test ((0 == safe_strcasecmp ("-4500-07-24T06:34:26Z",
01349             qof_date_print (qd, QOF_DATE_FORMAT_UTC))), 
01350             "strftime:UTC:sixth");
01351         do_test ((0 == safe_strcasecmp (NULL,
01352             qof_date_print (qd, QOF_DATE_FORMAT_LOCALE))), 
01353             "strftime:LOCALE:sixth:outofrange");
01354         do_test ((0 == safe_strcasecmp (NULL,
01355             qof_date_print (qd, QOF_DATE_FORMAT_CUSTOM))), 
01356             "strftime:CUSTOM:sixth:outofrange");
01357         qof_date_free (qd);
01358         qd = qof_date_new ();
01359         qd->qd_year = -4500000;
01360         qd->qd_mon = 07;
01361         qd->qd_mday = 24;
01362         qd->qd_hour = 06;
01363         qd->qd_min  = 34;
01364         qd->qd_sec  = 26;
01365         do_test ((qof_date_valid (qd)), "date not valid");
01366         qt = qof_date_to_qtime (qd);
01367         do_test ((0 == safe_strcasecmp ("07/24/-4500000",
01368             qof_date_print (qd, QOF_DATE_FORMAT_US))), 
01369             "strftime:US:seventh");
01370         do_test ((0 == safe_strcasecmp ("24/07/-4500000",
01371             qof_date_print (qd, QOF_DATE_FORMAT_UK))), 
01372             "strftime:UK:seventh");
01373         do_test ((0 == safe_strcasecmp ("24.07.-4500000",
01374             qof_date_print (qd, QOF_DATE_FORMAT_CE))), 
01375             "strftime:CE:seventh");
01376         do_test ((0 == safe_strcasecmp ("-4500000-07-24",
01377             qof_date_print (qd, QOF_DATE_FORMAT_ISO))), 
01378             "strftime:ISO:seventh");
01379         do_test ((0 == safe_strcasecmp ("-4500000-07-24T06:34:26Z",
01380             qof_date_print (qd, QOF_DATE_FORMAT_UTC))), 
01381             "strftime:UTC:seventh");
01382         do_test ((0 == safe_strcasecmp (NULL,
01383             qof_date_print (qd, QOF_DATE_FORMAT_LOCALE))), 
01384             "strftime:LOCALE:seventh:outofrange");
01385         do_test ((0 == safe_strcasecmp (NULL,
01386             qof_date_print (qd, QOF_DATE_FORMAT_CUSTOM))), 
01387             "strftime:CUSTOM:seventh:outofrange");
01388         qof_date_free (qd);
01389     }
01390 }
01391 
01392 static void
01393 run_qoftime_test (void)
01394 {
01395     QofTime *time, *cmp, *diff;
01396 
01397     time = qof_time_new ();
01398     do_test ((time != NULL), "failed to initialise QofTime.");
01399     /* basic tests */
01400     {
01401         qof_time_set_secs (time, 796179600);
01402         do_test ((qof_time_get_secs (time) > 0), "failed to set secs");
01403         do_test ((time != NULL), "error found");
01404         qof_time_set_secs (time, 0);
01405         qof_time_set_nanosecs (time, 2041020040);
01406         do_test ((qof_time_get_secs (time) > 0), "failed to normalise.");
01407         do_test ((time != NULL), "error found");
01408         do_test ((qof_time_get_nanosecs (time) > 0),
01409                  "failed to set nanosecs");
01410     }
01411     /* calculation and comparison tests */
01412     {
01413         qof_time_add_secs (time, -1143943200);
01414         do_test ((qof_time_get_secs (time) < 0), "failed to subtract.");
01415         do_test ((time != NULL), "error found");
01416         cmp = qof_time_new ();
01417         qof_time_set_secs (cmp, 0);
01418         do_test ((qof_time_equal (time, cmp) == FALSE), "test equal failed.");
01419         do_test ((qof_time_cmp (time, cmp) == -1), "compare cmp test");
01420         diff = qof_time_new ();
01421         qof_time_set_secs (diff, qof_time_get_secs (cmp));
01422         do_test ((qof_time_cmp (diff, cmp) == 0), "compare diff test");
01423         qof_time_free (diff);
01424         diff = qof_time_diff (time, cmp);
01425         do_test ((qof_time_get_secs (diff) < 0), "diff of negative value");
01426         qof_time_free (diff);
01427         diff = qof_time_diff (cmp, time);
01428         do_test ((qof_time_get_secs (diff) > 0), "diff of negative value");
01429         time = qof_time_abs (time);
01430         do_test ((qof_time_get_nanosecs (time) != 0), "abs failed");
01431         qof_time_set_secs (cmp, qof_time_get_secs (time));
01432         qof_time_set_nanosecs (cmp, qof_time_get_nanosecs (time));
01433         do_test ((qof_time_equal (cmp, time) == TRUE),
01434                  "equality test failed");
01435         qof_time_free (cmp);
01436         qof_time_free (time);
01437     }
01438     /* gdate basic tests */
01439     {
01440         GDate *date, *test;
01441         GTimeVal gtv;
01442 
01443         date = g_date_new_dmy (15, 5, 2006);
01444         time = qof_time_from_gdate (date);
01445         test = qof_time_to_gdate (time);
01446         do_test ((g_date_get_day (test) == 15), "gdate day fail");
01447         do_test ((g_date_get_month (test) == 5), "gdate month fail");
01448         do_test ((g_date_get_year (test) == 2006), "gdate year fail");
01449         do_test ((qof_time_to_gtimeval (time, &gtv)), "gtimeval fail");
01450         {
01451             QofTime *copy, *diff;
01452 
01453             qof_time_add_secs (time, 26451);
01454             copy = qof_time_add_secs_copy (time, -26451);
01455             diff = qof_time_diff (time, copy);
01456             do_test ((qof_time_get_secs (diff) == 26451), 
01457                 "add seconds failed");
01458             qof_time_free (copy);
01459             qof_time_free (diff);
01460         }
01461         g_date_free (date);
01462         g_date_free (test);
01463         qof_time_free (time);
01464     }
01465     /* gdate comparison tests */
01466     {
01467         GDate *date, *cmp;
01468         gint64 time_secs, diff;
01469         glong time_nano;
01470 
01471         date = g_date_new_dmy (15, 5, 2006);
01472         time = qof_time_from_gdate (date);
01473         cmp = qof_time_to_gdate (time);
01474         do_test ((g_date_compare (date, cmp) == 0),
01475                  "convert to and from gdate failed");
01476         g_date_free (cmp);
01477         time_secs = qof_time_get_secs (time);
01478         time_nano = qof_time_get_nanosecs (time);
01479         qof_time_add_secs (time, 7252);
01480         qof_time_set_nanosecs (time, 123456);
01481         do_test ((qof_time_set_day_start (time)), "set_day_start failed");
01482         do_test ((qof_time_get_secs (time) == time_secs),
01483                  "start of day incorrect");
01484         do_test ((qof_time_get_nanosecs (time) == 0),
01485                  "set nano at day start incorrect");
01486         do_test ((qof_time_set_day_middle (time) == TRUE),
01487                  "set_day_middle failed");
01488         diff = qof_time_get_secs (time) - time_secs;
01489         do_test (diff == (SECS_PER_DAY / 2), "middle of day incorrect");
01490         /* convert middle of day back to date */
01491         cmp = qof_time_to_gdate (time);
01492         do_test ((g_date_compare (date, cmp) == 0),
01493                  "middle of day not the same as original day");
01494         g_date_free (cmp);
01495 
01496         do_test ((qof_time_set_day_end (time)), "set_day_end failed");
01497         do_test ((qof_time_get_secs (time) - time_secs)
01498                  == (SECS_PER_DAY - 1), "end of day incorrect");
01499 
01500         /* convert end of day back to date */
01501         cmp = qof_time_to_gdate (time);
01502 
01503         do_test ((g_date_compare (date, cmp) == 0),
01504                  "end of day not the same as original day");
01505         qof_time_free (time);
01506         g_date_free (cmp);
01507         g_date_free (date);
01508     }
01509     /* QofTime today tests */
01510     {
01511         GTimeVal *current;
01512         gint64 time_secs;
01513         QofTime *diff;
01514 
01515         current = qof_time_get_current_start ();
01516         diff = qof_time_new ();
01517         qof_time_from_gtimeval (diff, current);
01518         time_secs = qof_time_get_secs (diff);
01519         time = qof_time_get_today_start ();
01520         do_test ((qof_time_get_secs (time) == time_secs),
01521                  "start of day incorrect");
01522         do_test ((qof_time_get_nanosecs (time) == 0),
01523                  "today start nanosecs non zero");
01524         qof_time_free (time);
01525         time = qof_time_get_today_end ();
01526         time_secs += SECS_PER_DAY - 1;
01527         do_test ((qof_time_get_secs (time) == time_secs),
01528                  "start of today incorrect");
01529         do_test ((qof_time_get_nanosecs (time) == 0),
01530                  "today start nanosecs non zero");
01531         qof_time_free (time);
01532     }
01533     /* last mday test */
01534     {
01535         GDate *date;
01536         guint8 mday;
01537 
01538         date = g_date_new_dmy (15, 5, 2006);
01539         time = qof_time_from_gdate (date);
01540         mday = qof_time_last_mday (time);
01541         do_test ((mday == 31), " wrong last day of May");
01542     }
01543     /* qof_date_get_mday and qof_date_get_yday tests */
01544     {
01545         QofDate *d;
01546         /* Wed 3rd Sep 2003 = 246. */
01547         do_test ((246 == qof_date_get_yday (3, 9, 2003)),
01548             "get year day test, September");
01549         d = qof_date_new ();
01550         d->qd_mday = 3;
01551         d->qd_mon  = 9;
01552         d->qd_year = 2003;
01553         do_test ((TRUE == qof_date_valid (d)),
01554             "3/9/2003 not valid");
01555         do_test ((3 == d->qd_wday), "not Wednesday");
01556         qof_date_free (d);
01557         /* Fri 3rd Sep 2004 = 247. */
01558         do_test ((247 == qof_date_get_yday (3, 9, 2004)),
01559             "get year day test, leap year");
01560         d = qof_date_new ();
01561         d->qd_mday = 3;
01562         d->qd_mon  = 9;
01563         d->qd_year = 2004;
01564         do_test ((TRUE == qof_date_valid (d)),
01565             "3/9/2003 not valid");
01566         do_test ((5 == d->qd_wday), "not Friday");
01567         qof_date_free (d);
01568         /* Sun 19th May 2002 = 139. */
01569         do_test ((139 == qof_date_get_yday (19, 5, 2002)),
01570             "get year day test, May");
01571         d = qof_date_new ();
01572         d->qd_mday = 19;
01573         d->qd_mon  = 5;
01574         d->qd_year = 2002;
01575         do_test ((TRUE == qof_date_valid (d)),
01576             "3/9/2003 not valid");
01577         do_test ((0 == d->qd_wday), "not Sunday");
01578         qof_date_free (d);
01579         /* Wed 19th May 2004 = 140. */
01580         do_test ((140 == qof_date_get_yday (19, 5, 2004)),
01581             "get year day test, May");
01582         d = qof_date_new ();
01583         d->qd_mday = 19;
01584         d->qd_mon  = 5;
01585         d->qd_year = 2004;
01586         do_test ((TRUE == qof_date_valid (d)),
01587             "3/9/2003 not valid");
01588         do_test ((3 == d->qd_wday), "not Wednesday, May");
01589         qof_date_free (d);
01590         /* Nov 2003 = 30 */
01591         do_test ((30 == qof_date_get_mday (11, 2003)),
01592             "get days in month, non-leap");
01593         /* Feb 2004 = 29 */
01594         do_test ((29 == qof_date_get_mday (2, 2004)),
01595             "get days in month, leap year");
01596     }
01597     /* time to dmy test */
01598     {
01599         gboolean success;
01600         guint8 day, month;
01601         guint16 year;
01602         GDate *date;
01603         QofTime *reverse;
01604 
01605         date = g_date_new_dmy (15, 5, 2006);
01606         time = qof_time_from_gdate (date);
01607         success = qof_time_to_dmy (time, &day, &month, &year);
01608         do_test ((success == TRUE), "time to dmy failed");
01609         do_test ((day == 15), "wrong day calculated");
01610         do_test ((month == 5), "wrong month calculated");
01611         do_test ((year == 2006), "wrong year calculated");
01612         reverse = qof_time_dmy_to_time (day, month, year);
01613         do_test ((qof_time_cmp (time, reverse) == 0), "dmy to time failed");
01614         g_date_free (date);
01615         qof_time_free (time);
01616         qof_time_free (reverse);
01617     }
01618     {
01619         /* day, month, year wrapping */
01620         QofTime *wrap_t;
01621         QofDate *wrap_d;
01622         glong day, month, year;
01623 
01624         /* Thu Jul 13 18:20:27 UTC 2006 */
01625         wrap_t = qof_time_set (1152814827, 345634);
01626         wrap_d = qof_date_from_qtime (wrap_t);
01627         PINFO (" base date for section =    %s",
01628             qof_date_print (wrap_d, QOF_DATE_FORMAT_ISO8601));
01629         day = wrap_d->qd_mday;
01630         month = wrap_d->qd_mon;
01631         year = wrap_d->qd_year;
01632         qof_date_free (wrap_d);     
01633         /* one day ago */
01634         wrap_d = qof_date_from_qtime (wrap_t);
01635         wrap_d->qd_mday -= 1;
01636         qof_date_valid (wrap_d);
01637         do_test ((wrap_d->qd_mon == month &&
01638             wrap_d->qd_year == year &&
01639             wrap_d->qd_mday == (day - 1)),
01640             " this time on previous day");
01641         PINFO (" same time previous day =   %s",
01642             qof_date_print (wrap_d, QOF_DATE_FORMAT_ISO8601));
01643         qof_date_free (wrap_d);
01644         /* this time last month */
01645         wrap_d = qof_date_from_qtime (wrap_t);
01646         wrap_d->qd_mon -= 1;
01647         qof_date_valid (wrap_d);
01648         do_test ((wrap_d->qd_mon == (month - 1) &&
01649             wrap_d->qd_year == year &&
01650             wrap_d->qd_mday == day),
01651             " this time last month");
01652         PINFO (" same time previous month = %s",
01653             qof_date_print (wrap_d, QOF_DATE_FORMAT_ISO8601));
01654         qof_date_free (wrap_d);
01655         /* this time last year */
01656         wrap_d = qof_date_from_qtime (wrap_t);
01657         wrap_d->qd_year -= 1;
01658         qof_date_valid (wrap_d);
01659         do_test ((wrap_d->qd_mon == month &&
01660             wrap_d->qd_year == (year - 1) &&
01661             wrap_d->qd_mday == day),
01662             " this time last year");
01663         PINFO (" same time previous year =  %s",
01664             qof_date_print (wrap_d, QOF_DATE_FORMAT_ISO8601));
01665         qof_time_free (wrap_t);
01666         qof_date_free (wrap_d);
01667     }
01668 }
01669 
01670 int
01671 main (int argc, char **argv)
01672 {
01673     qof_init ();
01674 #ifdef TEST_DEBUG
01675     qof_log_init_filename ("test-date.trace");
01676     qof_log_set_default (QOF_LOG_DETAIL);
01677     ENTER (" ");
01678 #endif
01679     test_date_init ();
01680     run_qoftime_test ();
01681     run_qofdate_test ();
01682     run_print_scan_tests ();
01683     g_list_foreach (test_data, check_date_cycles, NULL);
01684     print_test_results ();
01685     test_date_close ();
01686 #ifdef TEST_DEBUG
01687     LEAVE (" ");
01688     qof_log_shutdown ();
01689 #endif
01690     qof_close ();
01691     exit (get_rv ());
01692 }

Generated on Tue Sep 19 17:05:32 2006 for QOF by  doxygen 1.4.7