/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */

/*

 * GData Client

 * Copyright (C) Philip Withnall 2009, 2010, 2014, 2015, 2017 <philip@tecnocode.co.uk>

 *

 * GData Client is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * GData Client 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with GData Client.  If not, see <http://www.gnu.org/licenses/>.

 */

#include <glib.h>

#include <unistd.h>

#include <string.h>

#include "gdata.h"

#include "common.h"

#include "gdata-dummy-authorizer.h"

static UhmServer *mock_server = NULL;

#undef CLIENT_ID  /* from common.h */

#define CLIENT_ID "352818697630-nqu2cmt5quqd6lr17ouoqmb684u84l1f.apps.googleusercontent.com"

#define CLIENT_SECRET "-fA4pHQJxR3zJ-FyAMPQsikg"

#define REDIRECT_URI "urn:ietf:wg:oauth:2.0:oob"

typedef struct {

	GDataCalendarCalendar *calendar;

} TempCalendarData;

static void

set_up_temp_calendar (TempCalendarData *data, gconstpointer service)

{

	GDataCalendarCalendar *calendar;

	GDataColor colour;

	gdata_test_mock_server_start_trace (mock_server, "setup-temp-calendar");

	g_assert (gdata_color_from_hexadecimal ("#7A367A", &colour) == TRUE);

	/* Create a single temporary test calendar */

	calendar = gdata_calendar_calendar_new (NULL);

	gdata_entry_set_title (GDATA_ENTRY (calendar), "Temp Test Calendar");

	gdata_calendar_calendar_set_color (calendar, &colour);

	data->calendar = GDATA_CALENDAR_CALENDAR (gdata_service_insert_entry (GDATA_SERVICE (service),

	                                                                      gdata_calendar_service_get_primary_authorization_domain (),

	                                                                      "https://www.googleapis.com/calendar/v3/calendars",

	                                                                      GDATA_ENTRY (calendar), NULL, NULL));

	g_assert (GDATA_IS_CALENDAR_CALENDAR (data->calendar));

	g_object_unref (calendar);

	uhm_server_end_trace (mock_server);

}

static void

tear_down_temp_calendar (TempCalendarData *data, gconstpointer service)

{

	gdata_test_mock_server_start_trace (mock_server, "teardown-temp-calendar");

	/* Delete the calendar */

	g_assert (gdata_service_delete_entry (GDATA_SERVICE (service), gdata_calendar_service_get_primary_authorization_domain (),

	                                      GDATA_ENTRY (data->calendar), NULL, NULL) == TRUE);

	g_object_unref (data->calendar);

	uhm_server_end_trace (mock_server);

}

static void

test_authentication (void)

{

	GDataOAuth2Authorizer *authorizer = NULL;  /* owned */

	gchar *authentication_uri, *authorisation_code;

	gdata_test_mock_server_start_trace (mock_server, "authentication");

	authorizer = gdata_oauth2_authorizer_new (CLIENT_ID, CLIENT_SECRET,

	                                          REDIRECT_URI,

	                                          GDATA_TYPE_CALENDAR_SERVICE);

	/* Get an authentication URI. */

	authentication_uri = gdata_oauth2_authorizer_build_authentication_uri (authorizer, NULL, FALSE);

	g_assert (authentication_uri != NULL);

	/* Get the authorisation code off the user. */

	if (uhm_server_get_enable_online (mock_server)) {

		authorisation_code = gdata_test_query_user_for_verifier (authentication_uri);

	} else {

		/* Hard coded, extracted from the trace file. */

		authorisation_code = g_strdup ("4/OEX-S1iMbOA_dOnNgUlSYmGWh3TK.QrR73axcNMkWoiIBeO6P2m_su7cwkQI");

	}

	g_free (authentication_uri);

	if (authorisation_code == NULL) {

		/* Skip tests. */

		goto skip_test;

	}

	/* Authorise the token */

	g_assert (gdata_oauth2_authorizer_request_authorization (authorizer, authorisation_code, NULL, NULL) == TRUE);

	/* Check all is as it should be */

	g_assert (gdata_authorizer_is_authorized_for_domain (GDATA_AUTHORIZER (authorizer),

	                                                     gdata_calendar_service_get_primary_authorization_domain ()) == TRUE);

skip_test:

	g_free (authorisation_code);

	g_object_unref (authorizer);

	uhm_server_end_trace (mock_server);

}

typedef struct {

	GDataCalendarCalendar *calendar1;

	GDataCalendarCalendar *calendar2;

} QueryCalendarsData;

static void

set_up_query_calendars (QueryCalendarsData *data, gconstpointer service)

{

	GDataCalendarCalendar *calendar;

	GDataColor colour;

	gdata_test_mock_server_start_trace (mock_server, "setup-query-calendars");

	g_assert (gdata_color_from_hexadecimal ("#7A367A", &colour) == TRUE);

	/* Create some new calendars for queries */

	calendar = gdata_calendar_calendar_new (NULL);

	gdata_entry_set_title (GDATA_ENTRY (calendar), "Test Calendar 1");

	gdata_calendar_calendar_set_color (calendar, &colour);

	data->calendar1 = GDATA_CALENDAR_CALENDAR (gdata_service_insert_entry (GDATA_SERVICE (service),

	                                                                       gdata_calendar_service_get_primary_authorization_domain (),

	                                                                       "https://www.googleapis.com/calendar/v3/calendars",

	                                                                       GDATA_ENTRY (calendar), NULL, NULL));

	g_assert (GDATA_IS_CALENDAR_CALENDAR (data->calendar1));

	g_object_unref (calendar);

	calendar = gdata_calendar_calendar_new (NULL);

	gdata_entry_set_title (GDATA_ENTRY (calendar), "Test Calendar 2");

	gdata_calendar_calendar_set_color (calendar, &colour);

	data->calendar2 = GDATA_CALENDAR_CALENDAR (gdata_service_insert_entry (GDATA_SERVICE (service),

	                                                                       gdata_calendar_service_get_primary_authorization_domain (),

	                                                                       "https://www.googleapis.com/calendar/v3/calendars",

	                                                                       GDATA_ENTRY (calendar), NULL, NULL));

	g_assert (GDATA_IS_CALENDAR_CALENDAR (data->calendar2));

	g_object_unref (calendar);

	uhm_server_end_trace (mock_server);

}

static void

tear_down_query_calendars (QueryCalendarsData *data, gconstpointer service)

{

	gdata_test_mock_server_start_trace (mock_server, "teardown-query-calendars");

	/* Delete the calendars */

	g_assert (gdata_service_delete_entry (GDATA_SERVICE (service), gdata_calendar_service_get_primary_authorization_domain (),

	                                      GDATA_ENTRY (data->calendar1), NULL, NULL) == TRUE);

	g_object_unref (data->calendar1);

	g_assert (gdata_service_delete_entry (GDATA_SERVICE (service), gdata_calendar_service_get_primary_authorization_domain (),

	                                      GDATA_ENTRY (data->calendar2), NULL, NULL) == TRUE);

	g_object_unref (data->calendar2);

	uhm_server_end_trace (mock_server);

}

static void

test_query_all_calendars (QueryCalendarsData *data, gconstpointer service)

{

	GDataFeed *feed;

	GError *error = NULL;

	gdata_test_mock_server_start_trace (mock_server, "query-all-calendars");

	feed = gdata_calendar_service_query_all_calendars (GDATA_CALENDAR_SERVICE (service), NULL, NULL, NULL, NULL, &error);

	g_assert_no_error (error);

	g_assert (GDATA_IS_CALENDAR_FEED (feed));

	g_clear_error (&error);

	/* TODO: check entries and feed properties */

	g_object_unref (feed);

	uhm_server_end_trace (mock_server);

}

GDATA_ASYNC_CLOSURE_FUNCTIONS (query_calendars, QueryCalendarsData);

GDATA_ASYNC_TEST_FUNCTIONS (query_all_calendars, QueryCalendarsData,

G_STMT_START {

	gdata_calendar_service_query_all_calendars_async (GDATA_CALENDAR_SERVICE (service), NULL, cancellable, NULL,

	                                                  NULL, NULL, async_ready_callback, async_data);

} G_STMT_END,

G_STMT_START {

	GDataFeed *feed;

	feed = gdata_service_query_finish (GDATA_SERVICE (obj), async_result, &error);

	if (error == NULL) {

		/* TODO: Tests? */

		g_assert (GDATA_IS_CALENDAR_FEED (feed));

		g_object_unref (feed);

	} else {

		g_assert (feed == NULL);

	}

} G_STMT_END);

static void

test_query_all_calendars_async_progress_closure (QueryCalendarsData *query_data, gconstpointer service)

{

	GDataAsyncProgressClosure *data = g_slice_new0 (GDataAsyncProgressClosure);

	gdata_test_mock_server_start_trace (mock_server, "query-all-calendars-async-progress-closure");

	data->main_loop = g_main_loop_new (NULL, TRUE);

	gdata_calendar_service_query_all_calendars_async (GDATA_CALENDAR_SERVICE (service), NULL, NULL,

	                                                  (GDataQueryProgressCallback) gdata_test_async_progress_callback,

	                                                  data, (GDestroyNotify) gdata_test_async_progress_closure_free,

	                                                  (GAsyncReadyCallback) gdata_test_async_progress_finish_callback, data);

	g_main_loop_run (data->main_loop);

	g_main_loop_unref (data->main_loop);

	/* Check that both callbacks were called exactly once */

	g_assert_cmpuint (data->progress_destroy_notify_count, ==, 1);

	g_assert_cmpuint (data->async_ready_notify_count, ==, 1);

	g_slice_free (GDataAsyncProgressClosure, data);

	uhm_server_end_trace (mock_server);

}

static void

test_query_own_calendars (QueryCalendarsData *data, gconstpointer service)

{

	GDataFeed *feed;

	GError *error = NULL;

	gdata_test_mock_server_start_trace (mock_server, "query-own-calendars");

	feed = gdata_calendar_service_query_own_calendars (GDATA_CALENDAR_SERVICE (service), NULL, NULL, NULL, NULL, &error);

	g_assert_no_error (error);

	g_assert (GDATA_IS_CALENDAR_FEED (feed));

	g_clear_error (&error);

	/* TODO: check entries and feed properties */

	g_object_unref (feed);

	uhm_server_end_trace (mock_server);

}

GDATA_ASYNC_TEST_FUNCTIONS (query_own_calendars, QueryCalendarsData,

G_STMT_START {

	gdata_calendar_service_query_own_calendars_async (GDATA_CALENDAR_SERVICE (service), NULL, cancellable, NULL,

	                                                  NULL, NULL, async_ready_callback, async_data);

} G_STMT_END,

G_STMT_START {

	GDataFeed *feed;

	feed = gdata_service_query_finish (GDATA_SERVICE (obj), async_result, &error);

	if (error == NULL) {

		g_assert (GDATA_IS_CALENDAR_FEED (feed));

		/* TODO: Tests? */

		g_object_unref (feed);

	} else {

		g_assert (feed == NULL);

	}

} G_STMT_END);

static void

test_query_own_calendars_async_progress_closure (QueryCalendarsData *query_data, gconstpointer service)

{

	GDataAsyncProgressClosure *data = g_slice_new0 (GDataAsyncProgressClosure);

	gdata_test_mock_server_start_trace (mock_server, "query-own-calendars-async-progress-closure");

	data->main_loop = g_main_loop_new (NULL, TRUE);

	gdata_calendar_service_query_own_calendars_async (GDATA_CALENDAR_SERVICE (service), NULL, NULL,

	                                               (GDataQueryProgressCallback) gdata_test_async_progress_callback,

	                                               data, (GDestroyNotify) gdata_test_async_progress_closure_free,

	                                               (GAsyncReadyCallback) gdata_test_async_progress_finish_callback, data);

	g_main_loop_run (data->main_loop);

	g_main_loop_unref (data->main_loop);

	/* Check that both callbacks were called exactly once */

	g_assert_cmpuint (data->progress_destroy_notify_count, ==, 1);

	g_assert_cmpuint (data->async_ready_notify_count, ==, 1);

	g_slice_free (GDataAsyncProgressClosure, data);

	uhm_server_end_trace (mock_server);

}

typedef struct {

	TempCalendarData parent;

	GDataCalendarEvent *event1;

	GDataCalendarEvent *event2;

	GDataCalendarEvent *event3;

} QueryEventsData;

static void

set_up_query_events (QueryEventsData *data, gconstpointer service)

{

	GDataCalendarEvent *event;

	GDataGDWhen *when;

	GError *error = NULL;

	/* Set up a temporary calendar */

	set_up_temp_calendar ((TempCalendarData*) data, service);

	gdata_test_mock_server_start_trace (mock_server, "setup-query-events");

	/* Add some test events to it */

	event = gdata_calendar_event_new (NULL);

	gdata_entry_set_title (GDATA_ENTRY (event), "Test Event 1");

	when = gdata_gd_when_new (1419113727, 1419113728, FALSE);

	gdata_calendar_event_add_time (event, when);

	g_object_unref (when);

	data->event1 = gdata_calendar_service_insert_calendar_event (GDATA_CALENDAR_SERVICE (service), data->parent.calendar, event, NULL, &error);

	g_assert_no_error (error);

	g_assert (GDATA_IS_CALENDAR_EVENT (data->event1));

	g_object_unref (event);

	event = gdata_calendar_event_new (NULL);

	gdata_entry_set_title (GDATA_ENTRY (event), "Test Event 2");

	when = gdata_gd_when_new (1419113000, 1419114000, FALSE);

	gdata_calendar_event_add_time (event, when);

	g_object_unref (when);

	data->event2 = gdata_calendar_service_insert_calendar_event (GDATA_CALENDAR_SERVICE (service), data->parent.calendar, event, NULL, &error);

	g_assert_no_error (error);

	g_assert (GDATA_IS_CALENDAR_EVENT (data->event2));

	g_object_unref (event);

	event = gdata_calendar_event_new (NULL);

	gdata_entry_set_title (GDATA_ENTRY (event), "Test Event 3");

	when = gdata_gd_when_new (1419110000, 1419120000, TRUE);

	gdata_calendar_event_add_time (event, when);

	g_object_unref (when);

	data->event3 = gdata_calendar_service_insert_calendar_event (GDATA_CALENDAR_SERVICE (service), data->parent.calendar, event, NULL, &error);

	g_assert_no_error (error);

	g_assert (GDATA_IS_CALENDAR_EVENT (data->event3));

	g_object_unref (event);

	uhm_server_end_trace (mock_server);

}

static void

tear_down_query_events (QueryEventsData *data, gconstpointer service)

{

	gdata_test_mock_server_start_trace (mock_server, "teardown-query-events");

	/* Delete the events */

	g_assert (gdata_service_delete_entry (GDATA_SERVICE (service), gdata_calendar_service_get_primary_authorization_domain (),

	                                      GDATA_ENTRY (data->event1), NULL, NULL) == TRUE);

	g_object_unref (data->event1);

	g_assert (gdata_service_delete_entry (GDATA_SERVICE (service), gdata_calendar_service_get_primary_authorization_domain (),

	                                      GDATA_ENTRY (data->event2), NULL, NULL) == TRUE);

	g_object_unref (data->event2);

	g_assert (gdata_service_delete_entry (GDATA_SERVICE (service), gdata_calendar_service_get_primary_authorization_domain (),

	                                      GDATA_ENTRY (data->event3), NULL, NULL) == TRUE);

	g_object_unref (data->event3);

	uhm_server_end_trace (mock_server);

	/* Delete the calendar */

	tear_down_temp_calendar ((TempCalendarData*) data, service);

}

static void

test_query_events (QueryEventsData *data, gconstpointer service)

{

	GDataFeed *feed;

	GError *error = NULL;

	gdata_test_mock_server_start_trace (mock_server, "query-events");

	/* Get the entry feed */

	feed = gdata_calendar_service_query_events (GDATA_CALENDAR_SERVICE (service), data->parent.calendar, NULL, NULL, NULL, NULL, &error);

	g_assert_no_error (error);

	g_assert (GDATA_IS_CALENDAR_FEED (feed));

	g_clear_error (&error);

	/* TODO: check entries and feed properties */

	g_object_unref (feed);

	uhm_server_end_trace (mock_server);

}

GDATA_ASYNC_CLOSURE_FUNCTIONS (query_events, QueryEventsData);

GDATA_ASYNC_TEST_FUNCTIONS (query_events, QueryEventsData,

G_STMT_START {

	gdata_calendar_service_query_events_async (GDATA_CALENDAR_SERVICE (service), data->parent.calendar, NULL, cancellable, NULL, NULL, NULL,

	                                           async_ready_callback, async_data);

} G_STMT_END,

G_STMT_START {

	GDataFeed *feed;

	feed = gdata_service_query_finish (GDATA_SERVICE (obj), async_result, &error);

	if (error == NULL) {

		g_assert (GDATA_IS_CALENDAR_FEED (feed));

		g_object_unref (feed);

	} else {

		g_assert (feed == NULL);

	}

} G_STMT_END);

static void

test_query_events_async_progress_closure (QueryEventsData *query_data, gconstpointer service)

{

	GDataAsyncProgressClosure *data = g_slice_new0 (GDataAsyncProgressClosure);

	gdata_test_mock_server_start_trace (mock_server, "query-events-async-progress-closure");

	data->main_loop = g_main_loop_new (NULL, TRUE);

	gdata_calendar_service_query_events_async (GDATA_CALENDAR_SERVICE (service), query_data->parent.calendar, NULL, NULL,

	                                           (GDataQueryProgressCallback) gdata_test_async_progress_callback,

	                                           data, (GDestroyNotify) gdata_test_async_progress_closure_free,

	                                           (GAsyncReadyCallback) gdata_test_async_progress_finish_callback, data);

	g_main_loop_run (data->main_loop);

	g_main_loop_unref (data->main_loop);

	/* Check that both callbacks were called exactly once */

	g_assert_cmpuint (data->progress_destroy_notify_count, ==, 1);

	g_assert_cmpuint (data->async_ready_notify_count, ==, 1);

	g_slice_free (GDataAsyncProgressClosure, data);

	uhm_server_end_trace (mock_server);

}

typedef struct {

	TempCalendarData parent;

	GDataCalendarEvent *new_event;

} InsertEventData;

static void

set_up_insert_event (InsertEventData *data, gconstpointer service)

{

	set_up_temp_calendar ((TempCalendarData*) data, service);

	data->new_event = NULL;

}

static void

tear_down_insert_event (InsertEventData *data, gconstpointer service)

{

	gdata_test_mock_server_start_trace (mock_server, "teardown-insert-event");

	/* Delete the new event */

	g_assert (gdata_service_delete_entry (GDATA_SERVICE (service), gdata_calendar_service_get_primary_authorization_domain (),

	                                      GDATA_ENTRY (data->new_event), NULL, NULL) == TRUE);

	g_object_unref (data->new_event);

	uhm_server_end_trace (mock_server);

	/* Delete the calendar too */

	tear_down_temp_calendar ((TempCalendarData*) data, service);

}

static void

test_event_insert (InsertEventData *data, gconstpointer service)

{

	GDataCalendarEvent *event, *new_event;

	GDataGDWhere *where;

	GDataGDWho *who;

	GDataGDWhen *when;

	GTimeVal start_time, end_time;

	GError *error = NULL;

	gdata_test_mock_server_start_trace (mock_server, "event-insert");

	event = gdata_calendar_event_new (NULL);

	gdata_entry_set_title (GDATA_ENTRY (event), "Tennis with Beth");

	gdata_entry_set_content (GDATA_ENTRY (event), "Meet for a quick lesson.");

	gdata_calendar_event_set_transparency (event, GDATA_GD_EVENT_TRANSPARENCY_OPAQUE);

	gdata_calendar_event_set_status (event, GDATA_GD_EVENT_STATUS_CONFIRMED);

	where = gdata_gd_where_new (NULL, "Rolling Lawn Courts", NULL);

	gdata_calendar_event_add_place (event, where);

	g_object_unref (where);

	who = gdata_gd_who_new (GDATA_GD_WHO_EVENT_ORGANIZER, "John Smith‽", "john.smith@example.com");

	gdata_calendar_event_add_person (event, who);

	g_object_unref (who);

	g_time_val_from_iso8601 ("2009-04-17T15:00:00.000Z", &start_time);

	g_time_val_from_iso8601 ("2009-04-17T17:00:00.000Z", &end_time);

	when = gdata_gd_when_new (start_time.tv_sec, end_time.tv_sec, FALSE);

	gdata_calendar_event_add_time (event, when);

	g_object_unref (when);

	/* Insert the event */

	new_event = data->new_event = gdata_calendar_service_insert_calendar_event (GDATA_CALENDAR_SERVICE (service),

	                                                                            data->parent.calendar, event, NULL, &error);

	g_assert_no_error (error);

	g_assert (GDATA_IS_CALENDAR_EVENT (new_event));

	g_clear_error (&error);

	/* TODO: check entries and feed properties */

	g_object_unref (event);

	uhm_server_end_trace (mock_server);

}

GDATA_ASYNC_CLOSURE_FUNCTIONS (insert_event, InsertEventData);

GDATA_ASYNC_TEST_FUNCTIONS (event_insert, InsertEventData,

G_STMT_START {

	GDataCalendarEvent *event;

	GDataGDWhere *where;

	GDataGDWho *who;

	GDataGDWhen *when;

	GTimeVal start_time;

	GTimeVal end_time;

	event = gdata_calendar_event_new (NULL);

	gdata_entry_set_title (GDATA_ENTRY (event), "Tennis with Beth");

	gdata_entry_set_content (GDATA_ENTRY (event), "Meet for a quick lesson.");

	gdata_calendar_event_set_transparency (event, GDATA_GD_EVENT_TRANSPARENCY_OPAQUE);

	gdata_calendar_event_set_status (event, GDATA_GD_EVENT_STATUS_CONFIRMED);

	where = gdata_gd_where_new (NULL, "Rolling Lawn Courts", NULL);

	gdata_calendar_event_add_place (event, where);

	g_object_unref (where);

	who = gdata_gd_who_new (GDATA_GD_WHO_EVENT_ORGANIZER, "John Smith‽", "john.smith@example.com");

	gdata_calendar_event_add_person (event, who);

	g_object_unref (who);

	g_time_val_from_iso8601 ("2009-04-17T15:00:00.000Z", &start_time);

	g_time_val_from_iso8601 ("2009-04-17T17:00:00.000Z", &end_time);

	when = gdata_gd_when_new (start_time.tv_sec, end_time.tv_sec, FALSE);

	gdata_calendar_event_add_time (event, when);

	g_object_unref (when);

	/* Insert the event */

	gdata_calendar_service_insert_calendar_event_async (GDATA_CALENDAR_SERVICE (service),

	                                                    data->parent.calendar, event, cancellable,

	                                                    async_ready_callback, async_data);

	g_object_unref (event);

} G_STMT_END,

G_STMT_START {

	GDataEntry *event;

	event = gdata_service_insert_entry_finish (GDATA_SERVICE (obj), async_result, &error);

	if (error == NULL) {

		g_assert (GDATA_IS_CALENDAR_EVENT (event));

		data->new_event = GDATA_CALENDAR_EVENT (event);

		g_assert_cmpstr (gdata_entry_get_title (event), ==, "Tennis with Beth");

	} else {

		g_assert (event == NULL);

	}

} G_STMT_END);

static void

test_event_json (void)

{

	GDataCalendarEvent *event;

	GDataGDWhere *where;

	GDataGDWho *who;

	GDataGDWhen *when;

	GTimeVal start_time, end_time;

	event = gdata_calendar_event_new (NULL);

	gdata_entry_set_title (GDATA_ENTRY (event), "Tennis with Beth");

	gdata_entry_set_content (GDATA_ENTRY (event), "Meet for a quick lesson.");

	gdata_calendar_event_set_transparency (event, GDATA_GD_EVENT_TRANSPARENCY_OPAQUE);

	gdata_calendar_event_set_status (event, GDATA_GD_EVENT_STATUS_CONFIRMED);

	where = gdata_gd_where_new (NULL, "Rolling Lawn Courts", NULL);

	gdata_calendar_event_add_place (event, where);

	g_object_unref (where);

	who = gdata_gd_who_new (GDATA_GD_WHO_EVENT_ORGANIZER, "John Smith‽", "john.smith@example.com");

	gdata_calendar_event_add_person (event, who);

	g_object_unref (who);

	g_time_val_from_iso8601 ("2009-04-17T15:00:00.000Z", &start_time);

	g_time_val_from_iso8601 ("2009-04-17T17:00:00.000Z", &end_time);

	when = gdata_gd_when_new (start_time.tv_sec, end_time.tv_sec, FALSE);

	gdata_calendar_event_add_time (event, when);

	g_object_unref (when);

	/* Check the JSON */

	gdata_test_assert_json (event, "{"

		"'summary': 'Tennis with Beth',"

		"'description': 'Meet for a quick lesson.',"

		"'kind': 'calendar#event',"

		"'status': 'confirmed',"

		"'transparency': 'opaque',"

		"'guestsCanModify': false,"

		"'guestsCanInviteOthers': false,"

		"'guestsCanSeeOtherGuests': false,"

		"'anyoneCanAddSelf': false,"

		"'start': {"

			"'dateTime': '2009-04-17T15:00:00Z',"

			"'timeZone': 'UTC'"

		"},"

		"'end': {"

			"'dateTime': '2009-04-17T17:00:00Z',"

			"'timeZone': 'UTC'"

		"},"

		"'attendees': ["

			"{"

				"'email': 'john.smith@example.com',"

				"'displayName': 'John Smith‽',"

				"'organizer': true"

			"}"

		"],"

		"'organizer': {"

			"'email': 'john.smith@example.com',"

			"'displayName': 'John Smith‽'"

		"},"

		"'location': 'Rolling Lawn Courts'"

	"}");

}

static void

test_event_json_attendees (void)

{

	GDataCalendarEvent *event;

	GList/*<unowned GDataGDWho>*/ *l;

	guint n_people;

	const struct {

		const gchar *relation_type;

		const gchar *value_string;

		const gchar *email_address;

	} expected[] = {

		{ GDATA_GD_WHO_EVENT_ATTENDEE, "Joe Hibbs", "person1@gmail.com" },

		{ GDATA_GD_WHO_EVENT_ATTENDEE, "Me McMeeson", "me@gmail.com" },

		{ GDATA_GD_WHO_EVENT_ATTENDEE, NULL, "person2@gmail.com" },

		{ GDATA_GD_WHO_EVENT_ATTENDEE, "Example Person 3", "person3@gmail.com" },

		{ GDATA_GD_WHO_EVENT_ATTENDEE, NULL, "person4@gmail.com" },

		{ GDATA_GD_WHO_EVENT_ORGANIZER, "Ruth Pettut", "blah@example.com" },

	};

	GError *error = NULL;

	event = GDATA_CALENDAR_EVENT (gdata_parsable_new_from_json (GDATA_TYPE_CALENDAR_EVENT, "{"

		"'kind': 'calendar#event',"

		"'id': 'some-id',"

		"'created': '2017-02-04T17:53:47.000Z',"

		"'summary': 'Duff this',"

		"'organizer': {"

			"'email': 'blah@example.com',"

			"'displayName': 'Ruth Pettut'"

		"},"

		"'attendees': ["

			"{"

				"'email': 'person1@gmail.com',"

				"'displayName': 'Joe Hibbs',"

				"'responseStatus': 'accepted'"

			"},"

			"{"

				"'email': 'me@gmail.com',"

				"'displayName': 'Me McMeeson',"

				"'self': true,"

				"'responseStatus': 'needsAction'"

			"},"

			"{"

				"'email': 'person2@gmail.com',"

				"'responseStatus': 'needsAction'"

			"},"

			"{"

				"'email': 'person3@gmail.com',"

				"'displayName': 'Example Person 3',"

				"'responseStatus': 'tentative',"

				"'comment': 'Some poor excuse about not coming.'"

			"},"

			"{"

				"'email': 'person4@gmail.com',"

				"'responseStatus': 'accepted'"

			"},"

			"{"

				"'email': 'blah@example.com',"

				"'displayName': 'Ruth Pettut',"

				"'organizer': true,"

				"'responseStatus': 'accepted'"

			"}"

		"]"

	"}", -1, &error));

	g_assert_no_error (error);

	g_assert (GDATA_IS_ENTRY (event));

	g_clear_error (&error);

	/* Check attendee details. */

	for (n_people = 0, l = gdata_calendar_event_get_people (event);

	     l != NULL;

	     n_people += 1, l = l->next) {

		GDataGDWho *who = GDATA_GD_WHO (l->data);

		gsize i;

		g_test_message ("Examining attendee: %s",

		                gdata_gd_who_get_email_address (who));

		for (i = 0; i < G_N_ELEMENTS (expected); i++) {

			if (g_strcmp0 (gdata_gd_who_get_email_address (who),

			               expected[i].email_address) == 0) {

				g_assert_cmpstr (gdata_gd_who_get_relation_type (who), ==, expected[i].relation_type);

				g_assert_cmpstr (gdata_gd_who_get_value_string (who), ==, expected[i].value_string);

				break;

			}

		}

		g_assert_cmpuint (i, <, G_N_ELEMENTS (expected));

	}

	g_assert_cmpuint (n_people, ==, G_N_ELEMENTS (expected));

	g_object_unref (event);

}

static void

test_event_json_dates (void)

{

	guint i;

	const struct {

		const gchar *json;

		gboolean is_date;

		gint64 start_time;

		gint64 end_time;

		const gchar *output_json;  /* NULL if equal to @json */

	} test_vectors[] = {

		/* Plain date, single day. */

		{ "'start': {"

			"'date': '2009-04-17',"

			"'timeZone': 'UTC'"

		"},"

		"'end': {"

			"'date': '2009-04-18',"

			"'timeZone': 'UTC'"

		"}", TRUE, 1239926400, 1239926400 + 86400, NULL },

		/* Full date and time. */

		{ "'start': {"

			"'dateTime': '2009-04-17T15:00:00Z',"

			"'timeZone': 'UTC'"

		"},"

		"'end': {"

			"'dateTime': '2009-04-17T16:00:00Z',"

			"'timeZone': 'UTC'"

		"}", FALSE, 1239926400 + 54000, 1239926400 + 54000 + 3600, NULL },

		/* Start and end time. */

		{ "'start': {"

			"'date': '2009-04-27',"

			"'timeZone': 'UTC'"

		"},"

		"'end': {"

			"'date': '20090506',"

			"'timeZone': 'UTC'"

		"}", TRUE, 1239926400 + 864000, 1241568000, "'start': {"

			"'date': '2009-04-27',"

			"'timeZone': 'UTC'"

		"},"

		"'end': {"

			"'date': '2009-05-06',"

			"'timeZone': 'UTC'"

		"}" },

	};

	for (i = 0; i < G_N_ELEMENTS (test_vectors); i++) {

		gchar *json = NULL, *output_json = NULL;  /* owned */

		GDataCalendarEvent *event;

		GList *j;

		GDataGDWhen *when;

		gint64 _time;

		GError *error = NULL;

		json = g_strdup_printf ("{"

			"'summary': 'Tennis with Beth',"

			"'description': 'Meet for a quick lesson.',"

			"'kind': 'calendar#event',"

			"%s"

		"}", test_vectors[i].json);

		output_json = g_strdup_printf ("{"

			"'summary': 'Tennis with Beth',"

			"'description': 'Meet for a quick lesson.',"

			"'kind': 'calendar#event',"

			"'guestsCanModify': false,"

			"'guestsCanInviteOthers': false,"

			"'guestsCanSeeOtherGuests': false,"

			"'anyoneCanAddSelf': false,"

			"'attendees': [],"

			"%s"

		"}", (test_vectors[i].output_json != NULL) ? test_vectors[i].output_json : test_vectors[i].json);

		event = GDATA_CALENDAR_EVENT (gdata_parsable_new_from_json (GDATA_TYPE_CALENDAR_EVENT, json, -1, &error));

		g_assert_no_error (error);

		g_assert (GDATA_IS_ENTRY (event));

		g_clear_error (&error);

		/* Check the times */

		j = gdata_calendar_event_get_times (event);

		g_assert (j != NULL);

		when = GDATA_GD_WHEN (j->data);

		g_assert (gdata_gd_when_is_date (when) == test_vectors[i].is_date);

		_time = gdata_gd_when_get_start_time (when);

		g_assert_cmpint (_time, ==, test_vectors[i].start_time);

		_time = gdata_gd_when_get_end_time (when);

		g_assert_cmpint (_time, ==, test_vectors[i].end_time);

		g_assert (gdata_gd_when_get_value_string (when) == NULL);

		g_assert (gdata_gd_when_get_reminders (when) == NULL);

		/* Should be no other times. */

		g_assert (j->next == NULL);

		/* Check the JSON */

		gdata_test_assert_json (event, output_json);

		g_object_unref (event);

		g_free (output_json);

		g_free (json);

	}

}

static void

test_event_json_organizer (void)

{

	GDataCalendarEvent *event;

	GError *error = NULL;

	event = GDATA_CALENDAR_EVENT (gdata_parsable_new_from_json (GDATA_TYPE_CALENDAR_EVENT, "{"

		"'kind': 'calendar#event',"

		"'id': 'some-id',"

		"'created': '2013-12-22T18:00:00.000Z',"

		"'summary': 'FOSDEM GNOME Beer Event',"

		"'organizer': {"

			"'id': 'another-id',"

			"'displayName': 'Guillaume Desmottes'"

		"},"

		"'attendees': ["

			"{"

				"'id': 'another-id',"

				"'displayName': 'Guillaume Desmottes',"

				"'organizer': true,"

				"'responseStatus': 'accepted'"

			"}"

		"]"

	"}", -1, &error));

	g_assert_no_error (error);

	g_assert (GDATA_IS_ENTRY (event));

	g_clear_error (&error);

	g_object_unref (event);

}

static void

test_event_json_recurrence (void)

{

	GDataCalendarEvent *event;

	GError *error = NULL;

	gchar *id, *uri;

	event = GDATA_CALENDAR_EVENT (gdata_parsable_new_from_json (GDATA_TYPE_CALENDAR_EVENT, "{"