/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* Author :
* Damon Chaplin <damon@helixcode.com>
*
* Copyright 2000, Helix Code, Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
* USA
*/
/*
* This tests the recurrence rule expansion functions.
*/
#include <config.h>
#include <string.h>
#include <time.h>
#include <glib.h>
#include "cal-recur.h"
static void set_time (CalObjTime *cotime, gint year, gint month, gint day,
gint hour, gint minute, gint second);
static void display_occs (GArray *occs);
static GList* build_list (gint first, ...);
static gchar* time_to_string (CalObjTime *cotime);
static void do_test (gchar *description,
CalObjTime *event_start,
CalObjRecurrence *recur,
CalObjTime *interval_start,
CalObjTime *interval_end);
#define LIST_END 999
static void
test_yearly ()
{
CalObjTime event_start, interval_start, interval_end;
CalObjRecurrence recur;
set_time (&event_start, 2000, 0, 1, 0, 0, 0);
/* We set the interval to a wide range so we just test the event. */
set_time (&interval_start, 2000, 0, 1, 0, 0, 0);
set_time (&interval_end, 2010, 0, 1, 0, 0, 0);
memset (&recur, 0, sizeof (recur));
recur.type = CAL_RECUR_YEARLY;
recur.interval = 3;
recur.byweekno = build_list (3, 9, 24, LIST_END);
recur.byday = build_list (3, 0, 5, 0, LIST_END);
do_test ("YEARLY every 3 years in weeks 3, 9, 24 on Thu/Sat",
&event_start, &recur, &interval_start, &interval_end);
set_time (&interval_end, 2002, 0, 1, 0, 0, 0);
memset (&recur, 0, sizeof (recur));
recur.type = CAL_RECUR_YEARLY;
recur.interval = 1;
recur.bymonth = build_list (0, 6, LIST_END);
recur.byday = build_list (0, 0, 6, 0, LIST_END);
do_test ("YEARLY every year in Jan/Jul on Mon/Sun",
&event_start, &recur, &interval_start, &interval_end);
memset (&recur, 0, sizeof (recur));
recur.type = CAL_RECUR_YEARLY;
recur.interval = 1;
recur.bymonthday = build_list (3, 7, LIST_END);
do_test ("YEARLY every year on 3rd & 7th of the month",
&event_start, &recur, &interval_start, &interval_end);
memset (&recur, 0, sizeof (recur));
recur.type = CAL_RECUR_YEARLY;
recur.interval = 1;
recur.byyearday = build_list (15, 126, 360, LIST_END);
do_test ("YEARLY every year on 15th, 126th & 360th day of the year",
&event_start, &recur, &interval_start, &interval_end);
}
static void
test_monthly ()
{
CalObjTime event_start, interval_start, interval_end;
CalObjRecurrence recur;
set_time (&event_start, 2000, 0, 1, 0, 0, 0);
/* We set the interval to a wide range so we just test the event. */
set_time (&interval_start, 2000, 0, 1, 0, 0, 0);
set_time (&interval_end, 2002, 0, 1, 0, 0, 0);
memset (&recur, 0, sizeof (recur));
recur.type = CAL_RECUR_MONTHLY;
recur.interval = 1;
do_test ("MONTHLY every month",
&event_start, &recur, &interval_start, &interval_end);
}
static void
test_weekly ()
{
CalObjTime event_start, interval_start, interval_end;
CalObjRecurrence recur;
set_time (&event_start, 2000, 0, 1, 0, 0, 0);
/* We set the interval to a wide range so we just test the event. */
set_time (&interval_start, 2000, 0, 1, 0, 0, 0);
set_time (&interval_end, 2002, 0, 1, 0, 0, 0);
memset (&recur, 0, sizeof (recur));
recur.type = CAL_RECUR_WEEKLY;
recur.interval = 1;
do_test ("WEEKLY every week",
&event_start, &recur, &interval_start, &interval_end);
}
static void
test_daily ()
{
CalObjTime event_start, interval_start, interval_end;
CalObjRecurrence recur;
set_time (&event_start, 2000, 0, 1, 0, 0, 0);
/* We set the interval to a wide range so we just test the event. */
set_time (&interval_start, 2000, 0, 1, 0, 0, 0);
set_time (&interval_end, 2000, 6, 1, 0, 0, 0);
memset (&recur, 0, sizeof (recur));
recur.type = CAL_RECUR_DAILY;
recur.interval = 1;
do_test ("DAILY every day",
&event_start, &recur, &interval_start, &interval_end);
}
static void
test_hourly ()
{
CalObjTime event_start, interval_start, interval_end;
CalObjRecurrence recur;
set_time (&event_start, 2000, 0, 1, 2, 15, 0);
/* We set the interval to a wide range so we just test the event. */
set_time (&interval_start, 2000, 0, 1, 0, 0, 0);
set_time (&interval_end, 2002, 0, 1, 0, 0, 0);
memset (&recur, 0, sizeof (recur));
recur.type = CAL_RECUR_HOURLY;
recur.interval = 3;
recur.bymonth = build_list (3, 11, LIST_END);
recur.byday = build_list (2, 0, 4, 0, LIST_END);
do_test ("HOURLY every 3 hours in Apr/Dec on Wed & Fri",
&event_start, &recur, &interval_start, &interval_end);
}
static void
test_minutely ()
{
CalObjTime event_start, interval_start, interval_end;
CalObjRecurrence recur;
set_time (&event_start, 2000, 0, 1, 0, 0, 0);
/* We set the interval to a wide range so we just test the event. */
set_time (&interval_start, 2000, 0, 1, 0, 0, 0);
set_time (&interval_end, 2000, 0, 2, 0, 0, 0);
memset (&recur, 0, sizeof (recur));
recur.type = CAL_RECUR_MINUTELY;
recur.interval = 45;
do_test ("MINUTELY every 45 minutes",
&event_start, &recur, &interval_start, &interval_end);
}
static void
test_secondly ()
{
CalObjTime event_start, interval_start, interval_end;
CalObjRecurrence recur;
set_time (&event_start, 2000, 0, 1, 0, 0, 0);
/* We set the interval to a wide range so we just test the event. */
set_time (&interval_start, 2000, 0, 1, 0, 0, 0);
set_time (&interval_end, 2000, 0, 2, 0, 0, 0);
memset (&recur, 0, sizeof (recur));
recur.type = CAL_RECUR_SECONDLY;
recur.interval = 15;
recur.byhour = build_list (2, 4, 6, LIST_END);
recur.byminute = build_list (0, 30, LIST_END);
do_test ("SECONDLY every 15 seconds at 2:00,2:30,4:00,4:30,6:00,6:30",
&event_start, &recur, &interval_start, &interval_end);
}
int
main (int argc, char *argv[])
{
test_yearly ();
test_monthly ();
test_weekly ();
test_daily ();
test_hourly ();
test_minutely ();
test_secondly ();
return 0;
}
static void
set_time (CalObjTime *cotime, gint year, gint month, gint day,
gint hour, gint minute, gint second)
{
cotime->year = year;
cotime->month = month;
cotime->day = day;
cotime->hour = hour;
cotime->minute = minute;
cotime->second = second;
}
static GList*
build_list (gint first, ...)
{
va_list args;
GList *list;
gint num;
va_start (args, first);
list = g_list_prepend (NULL, GINT_TO_POINTER (first));
num = va_arg (args, gint);
while (num != LIST_END) {
list = g_list_prepend (list, GINT_TO_POINTER (num));
num = va_arg (args, gint);
}
list = g_list_reverse (list);
va_end (args);
return list;
}
static void
do_test (gchar *description,
CalObjTime *event_start,
CalObjRecurrence *recur,
CalObjTime *interval_start,
CalObjTime *interval_end)
{
GArray *occs;
g_print ("========================================================\n");
g_print ("%s\n", description);
g_print ("(From %s", time_to_string (interval_start));
g_print (" To %s)\n\n", time_to_string (interval_end));
occs = cal_obj_expand_recurrence (event_start, recur,
interval_start, interval_end);
display_occs (occs);
g_array_free (occs, TRUE);
}
static gchar*
time_to_string (CalObjTime *cotime)
{
static gchar buffer[64];
gint month;
gchar *months[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec", "XXX" };
month = cotime->month;
if (month < 0 || month > 12)
month = 12;
sprintf (buffer, "%s %2i %02i:%02i:%02i %4i",
months[month], cotime->day,
cotime->hour, cotime->minute, cotime->second,
cotime->year);
return buffer;
}
static void
display_occs (GArray *occs)
{
CalObjTime *occ;
gint len, i;
struct tm t;
len = occs->len;
for (i = 0; i < len; i++) {
occ = &g_array_index (occs, CalObjTime, i);
t.tm_sec = occ->second;
t.tm_min = occ->minute;
t.tm_hour = occ->hour;
t.tm_mday = occ->day;
t.tm_mon = occ->month;
t.tm_year = occ->year - 1900;
t.tm_isdst = -1;
mktime (&t);
g_print ("%s", asctime (&t));
}
}
