int main()
{
icalarray *builtin_timezones;
icaltimetype tt;
int dd, hh, zz, tried = 0;
long zz2 = -1;
set_zone_directory("../../zoneinfo");
icaltimezone_set_tzid_prefix("/softwarestudio.org/");
tt = icaltime_current_time_with_zone(icaltimezone_get_builtin_timezone("America/New_York"));
tt.year = 2038;
(void)icaltime_as_timet_with_zone(tt, icaltimezone_get_builtin_timezone("PST"));
tried++;
tt.year = 2050;
(void)icaltime_as_timet_with_zone(tt, icaltimezone_get_builtin_timezone("PST"));
tried++;
tt.year = 1958;
(void)icaltime_as_timet_with_zone(tt, icaltimezone_get_builtin_timezone("PST"));
tried++;
builtin_timezones = icaltimezone_get_builtin_timezones();
printf("got %lu zones\n", (unsigned long)builtin_timezones->num_elements);
if (builtin_timezones->num_elements == 0) {
printf("YIKES. Try running from the build/bin directory\n");
return(1);
}
for (zz = -1; zz < (int)builtin_timezones->num_elements; zz++) {
icaltimezone *zone;
if (zz < 0) {
zone = icaltimezone_get_utc_timezone();
} else {
zone = icalarray_element_at(builtin_timezones, (size_t)zz);
}
tt = icaltime_current_time_with_zone(zone);
for (dd = 0; dd < 370; dd += 17) {
for (hh = 0; hh < 60 * 60 * 24; hh += 567) {
int zz2cnt;
icaltime_adjust(&tt, 0, 0, 0, 1);
for (zz2cnt = 0; zz2cnt < 15; zz2cnt++) {
icaltimezone *zone2;
if (zz2 < 0) {
zone2 = icaltimezone_get_utc_timezone();
} else {
zone2 = icalarray_element_at(builtin_timezones, (size_t)zz2);
}
(void)icaltime_as_timet_with_zone(tt, zone2);
tried++;
zz2++;
if (zz2 >= (long)builtin_timezones->num_elements)
zz2 = -1;
}
}
}
printf("\r%lu %% done",
(zz >= 0 ? zz : 0) * 100 / (unsigned long)builtin_timezones->num_elements);
fflush(stdout);
}
printf("\ntried %d times\n", tried);
return 0;
}
int main (int argc,
char **argv)
{
gint retval;
GList *etds, *l;
UhmServer *server;
const gchar *module_path;
GModule *module = NULL;
retval = ews_test_init (argc, argv);
if (retval < 0) {
g_printerr ("Failed to initialize test\n");
goto exit;
}
if (!g_module_supported ()) {
g_printerr ("GModule not supported\n");
retval = 1;
goto exit;
}
module_path = CALENDAR_MODULE_DIR "libecalbackendews.so";
module = g_module_open (module_path, G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL);
if (module == NULL) {
g_printerr ("Failed to load module '%s': %s\n", module_path, g_module_error ());
retval = 2;
goto exit;
}
if (!g_module_symbol (
module,
"e_cal_backend_ews_populate_windows_zones",
(gpointer *) &populate_windows_zones)) {
g_printerr ("\n%s\n", g_module_error ());
retval = 3;
goto exit;
}
if (!g_module_symbol (
module,
"e_cal_backend_ews_tz_util_get_msdn_equivalent",
(gpointer *) &ical_to_msdn_equivalent)) {
g_printerr ("\n%s\n", g_module_error ());
retval = 4;
goto exit;
}
if (!g_module_symbol (
module,
"e_cal_backend_ews_convert_calcomp_to_xml",
(gpointer *) &convert_calcomp_to_xml)) {
g_printerr ("\n%s\n", g_module_error ());
retval = 5;
goto exit;
}
server = ews_test_get_mock_server ();
etds = ews_test_get_test_data_list ();
/* Set handler of debug information */
populate_windows_zones ();
builtin_timezones = icaltimezone_get_builtin_timezones ();
for (l = etds; l != NULL; l = l->next) {
EwsTestData *etd = l->data;
gchar *message;
if (!uhm_server_get_enable_online (server))
g_signal_connect (server, "notify::resolver", (GCallback) server_notify_resolver_cb, etd);
/* Create folder */
if (e_ews_debug_get_server_version_from_string (etd->version) >= E_EWS_EXCHANGE_2010) {
message = g_strdup_printf ("/%s/calendar/timezones/ical_compatibility", etd->version);
g_test_add_data_func (message, etd, test_libical_timezones_compatibility);
g_free (message);
message = g_strdup_printf ("/%s/calendar/timezones/time_zones_sync", etd->version);
g_test_add_data_func (message, etd, test_time_zones_sync);
g_free (message);
}
}
retval = g_test_run ();
if (!uhm_server_get_enable_online (server))
for (l = etds; l != NULL; l = l->next)
g_signal_handlers_disconnect_by_func (server, server_notify_resolver_cb, l->data);
exit:
if (module != NULL)
g_module_close (module);
if (builtin_timezones != NULL)
icalarray_free (builtin_timezones);
ews_test_cleanup ();
return retval;
}
static gchar *
system_timezone_find (void)
{
GHashTable *ical_zones;
icalarray *builtin_timezones;
gint ii;
gchar *tz, *config_tz = NULL;
/* return only timezones known to libical */
ical_zones = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
g_hash_table_insert (ical_zones, g_strdup ("UTC"), GINT_TO_POINTER (1));
builtin_timezones = icaltimezone_get_builtin_timezones ();
for (ii = 0; ii < builtin_timezones->num_elements; ii++) {
icaltimezone *zone;
const gchar *location;
zone = icalarray_element_at (builtin_timezones, ii);
if (!zone)
continue;
location = icaltimezone_get_location (zone);
if (location)
g_hash_table_insert (ical_zones, g_strdup (location), GINT_TO_POINTER (1));
}
/* softlink is the best option, it points to the correct file */
tz = system_timezone_read_etc_localtime_softlink (ical_zones);
if (system_timezone_is_valid (tz, ical_zones)) {
g_hash_table_destroy (ical_zones);
return tz;
}
g_free (tz);
config_tz = NULL;
/* read correct timezone name from config file; checking
* on /etc/localtime content can pick wrong timezone name,
* even the file is same
*/
for (ii = 0; get_system_timezone_methods_config[ii] != NULL; ii++) {
config_tz = get_system_timezone_methods_config[ii] (ical_zones);
if (system_timezone_is_valid (config_tz, ical_zones)) {
break;
}
g_free (config_tz);
config_tz = NULL;
}
if (config_tz) {
struct stat stat_localtime;
gchar *localtime_content = NULL;
gsize localtime_content_len = -1;
if (g_stat (ETC_LOCALTIME, &stat_localtime) == 0 &&
S_ISREG (stat_localtime.st_mode) &&
g_file_get_contents (ETC_LOCALTIME,
&localtime_content,
&localtime_content_len,
NULL)) {
struct stat stat_config_tz;
gchar *filename = g_build_filename (SYSTEM_ZONEINFODIR, config_tz, NULL);
if (filename &&
g_stat (filename, &stat_config_tz) == 0 &&
files_are_identical_content (&stat_localtime,
&stat_config_tz,
localtime_content,
localtime_content_len,
filename)) {
g_free (filename);
g_free (localtime_content);
g_hash_table_destroy (ical_zones);
/* corresponding file name to config_tz matches /etc/localtime,
* thus that's the correct one - return it as system timezone;
* bonus is that it might match configured system timezone name too
*/
return config_tz;
}
g_free (filename);
}
g_free (localtime_content);
}
for (ii = 0; get_system_timezone_methods_slow[ii] != NULL; ii++) {
tz = get_system_timezone_methods_slow[ii] (ical_zones);
if (system_timezone_is_valid (tz, ical_zones)) {
g_hash_table_destroy (ical_zones);
g_free (config_tz);
return tz;
}
g_free (tz);
}
g_hash_table_destroy (ical_zones);
return config_tz;
}
int main()
{
icalarray *timezones;
icaltimezone *zone, *utc_zone;
char *zone_location;
size_t i;
int ret = 0;
unsigned int total_failed = 0;
unsigned int total_okay = 0;
unsigned int percent_failed = 0;
int verbose = 0;
int day;
time_t start_time;
struct tm start_tm;
time_t curr_time;
struct tm curr_tm;
struct icaltimetype curr_tt;
int failed = 0;
int curr_failed;
int zonedef_printed = 0;
#if !defined(HAVE_SETENV)
static char new_tz[256];
#endif
set_zone_directory("../../zoneinfo");
icaltimezone_set_tzid_prefix("/softwarestudio.org/");
timezones = icaltimezone_get_builtin_timezones();
utc_zone = icaltimezone_get_utc_timezone();
/* for all known time zones... */
for (i = 0; i < timezones->num_elements; i++) {
zone = (icaltimezone *)icalarray_element_at(timezones, i);
zone_location = (char *)icaltimezone_get_location(zone);
if (!zone_location)
continue;
/*
* select this location for glibc: needs support for TZ=<location>
* which is not POSIX
*/
#if defined(HAVE_SETENV)
setenv("TZ", zone_location, 1);
#else
new_tz[0] = '\0';
strncat(new_tz, "TZ=", 255);
strncat(new_tz, zone_location, 255 - strlen(new_tz));
putenv(new_tz);
#endif
tzset();
/*
* determine current local time and date: always use midday in
* the current zone and first day of first month in the year
*/
start_time = time(NULL);
localtime_r(&start_time, &start_tm);
start_tm.tm_hour = 12;
start_tm.tm_min = 0;
start_tm.tm_sec = 0;
start_tm.tm_mday = 1;
start_tm.tm_mon = 0;
start_time = mktime(&start_tm);
/* check time conversion for the next 365 days */
for (day = 0, curr_time = start_time; day < 365; day++, curr_time += 24 * 60 * 60) {
/* determine date/time with glibc */
localtime_r(&curr_time, &curr_tm);
/* determine date/time with libical */
curr_tt = icaltime_from_timet_with_zone(curr_time, 0, utc_zone);
curr_tt.zone = utc_zone; /* workaround: icaltime_from_timet_with_zone()
should do this, but doesn't! */
curr_tt = icaltime_convert_to_zone(curr_tt, zone);
/* compare... */
curr_failed =
curr_tm.tm_year + 1900 != curr_tt.year ||
curr_tm.tm_mon + 1 != curr_tt.month ||
curr_tm.tm_mday != curr_tt.day ||
curr_tm.tm_hour != curr_tt.hour ||
curr_tm.tm_min != curr_tt.minute ||
curr_tm.tm_sec != curr_tt.second;
/* only print first failed day and first day which is okay again */
if (verbose || curr_failed != failed) {
struct tm utc_tm;
if (!gmtime_r(&curr_time, &utc_tm))
memset(&utc_tm, 0, sizeof(utc_tm));
printf(
"%s: day %03d: %s: %04d-%02d-%02d %02d:%02d:%02d UTC = "
"libc %04d-%02d-%02d %02d:%02d:%02d dst %d",
zone_location, day,
verbose ? (curr_failed ? "failed" : "okay") : (curr_failed ? "first failed" :
"okay again"),
utc_tm.tm_year + 1900, utc_tm.tm_mon + 1, utc_tm.tm_mday, utc_tm.tm_hour,
utc_tm.tm_min, utc_tm.tm_sec, curr_tm.tm_year + 1900, curr_tm.tm_mon + 1,
curr_tm.tm_mday, curr_tm.tm_hour, curr_tm.tm_min, curr_tm.tm_sec,
curr_tm.tm_isdst);
if (curr_failed) {
printf(" != libical %04d-%02d-%02d %02d:%02d:%02d dst %d",
curr_tt.year,
curr_tt.month,
curr_tt.day,
curr_tt.hour,
curr_tt.minute,
curr_tt.second,
curr_tt.is_daylight);
ret = 1;
}
printf("\n");
failed = curr_failed;
if (!zonedef_printed) {
icalcomponent *comp = icaltimezone_get_component(zone);
if (comp) {
printf("%s\n", icalcomponent_as_ical_string(comp));
}
zonedef_printed = 1;
}
}
if (curr_failed) {
total_failed++;
} else {
total_okay++;
}
}
}
if (total_failed || total_okay) {
percent_failed = total_failed * 100 / (total_failed + total_okay);
printf(" *** Summary: %lu zones tested, %u days failed, %u okay => %u%% failed ***\n",
(unsigned long)timezones->num_elements, total_failed, total_okay, percent_failed);
if (!icaltzutil_get_exact_vtimezones_support()) {
if (!percent_failed) {
ret = 0;
printf(" *** Expect some small error rate with inter-operable vtimezones *** \n");
}
}
}
icaltimezone_free_builtin_timezones();
return ret;
}
int main(int argc, char* argv[])
{
icalarray *zones;
icaltimezone *zone;
char *zone_directory, *zone_subdirectory, *zone_filename, *location;
char output_directory[PATHNAME_BUFFER_SIZE];
char filename[PATHNAME_BUFFER_SIZE];
FILE *fp;
int i;
int skipping = TRUE;
/*
* Command-Line Option Parsing.
*/
for (i = 1; i < argc; i++) {
/* --dump-changes: Dumps a list of times when each timezone changed,
and the new local time offset from UTC. */
if (!strcmp (argv[i], "--dump-changes"))
VzicDumpChanges = TRUE;
else
usage ();
}
zones = icaltimezone_get_builtin_timezones ();
ensure_directory_exists (directory);
for (i = 0; i < zones->num_elements; i++) {
zone = icalarray_element_at (zones, i);
location = icaltimezone_get_location (zone);
#if 0
/* Use this to start at a certain zone. */
if (skipping && strcmp (location, "America/Boise"))
continue;
#endif
skipping = FALSE;
/* Use this to only output data for certain timezones. */
#if 0
if (strcmp (location, "America/Cancun")
&& strcmp (location, "Asia/Baku")
&& strcmp (location, "Asia/Nicosia")
&& strcmp (location, "Asia/Novosibirsk")
&& strcmp (location, "Asia/Samarkand")
&& strcmp (location, "Asia/Tashkent")
&& strcmp (location, "Asia/Tbilisi")
&& strcmp (location, "Asia/Yerevan")
&& strcmp (location, "Australia/Broken_Hill")
&& strcmp (location, "Europe/Simferopol")
&& strcmp (location, "Europe/Tallinn")
&& strcmp (location, "Europe/Zaporozhye")
)
continue;
#endif
#if 0
printf ("%s\n", location);
#endif
parse_zone_name (location, &zone_directory, &zone_subdirectory,
&zone_filename);
sprintf (output_directory, "%s/%s", directory, zone_directory);
ensure_directory_exists (output_directory);
sprintf (filename, "%s/%s", output_directory, zone_filename);
if (zone_subdirectory) {
sprintf (output_directory, "%s/%s/%s", directory, zone_directory,
zone_subdirectory);
ensure_directory_exists (output_directory);
sprintf (filename, "%s/%s", output_directory, zone_filename);
}
fp = fopen (filename, "w");
if (!fp) {
fprintf (stderr, "Couldn't create file: %s\n", filename);
exit (1);
}
/* We can run 2 different tests - output all changes for each zone, or
test against mktime()/localtime(). Should have a command-line option
or something. */
if (VzicDumpChanges)
icaltimezone_dump_changes (zone, CHANGES_MAX_YEAR, fp);
else
dump_local_times (zone, fp);
if (ferror (fp)) {
fprintf (stderr, "Error writing file: %s\n", filename);
exit (1);
}
fclose (fp);
}
return 0;
}
