/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
/*
* GData Client
* Copyright (C) Philip Withnall 2008–2010 <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 <locale.h>
#include "gdata.h"
#include "common.h"
static void
test_xml_comparison (void)
{
GDataAccessRule *rule;
/* Since we've written the XML comparison function used across all the test suites, it's necessary to test that it actually works before we
* blindly assert that its results are correct. */
rule = gdata_access_rule_new ("an-id");
gdata_access_rule_set_role (rule, GDATA_ACCESS_ROLE_NONE);
gdata_access_rule_set_scope (rule, GDATA_ACCESS_SCOPE_USER, "foo@example.com");
/* Check a valid comparison */
gdata_test_assert_xml (rule,
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' "
"xmlns:gd='http://schemas.google.com/g/2005' "
"xmlns:gAcl='http://schemas.google.com/acl/2007'>"
"<title type='text'>none</title>"
"<id>an-id</id>"
"<category term='http://schemas.google.com/acl/2007#accessRule' scheme='http://schemas.google.com/g/2005#kind'/>"
"<gAcl:role value='none'/>"
"<gAcl:scope type='user' value='foo@example.com'/>"
"</entry>");
/* Check a valid comparison with namespaces swapped */
gdata_test_assert_xml (rule,
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' "
"xmlns:gAcl='http://schemas.google.com/acl/2007' "
"xmlns:gd='http://schemas.google.com/g/2005'>"
"<title type='text'>none</title>"
"<id>an-id</id>"
"<category term='http://schemas.google.com/acl/2007#accessRule' scheme='http://schemas.google.com/g/2005#kind'/>"
"<gAcl:role value='none'/>"
"<gAcl:scope type='user' value='foo@example.com'/>"
"</entry>");
/* Check a valid comparison with elements swapped */
gdata_test_assert_xml (rule,
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' "
"xmlns:gd='http://schemas.google.com/g/2005' "
"xmlns:gAcl='http://schemas.google.com/acl/2007'>"
"<id>an-id</id>"
"<title type='text'>none</title>"
"<category term='http://schemas.google.com/acl/2007#accessRule' scheme='http://schemas.google.com/g/2005#kind'/>"
"<gAcl:role value='none'/>"
"<gAcl:scope type='user' value='foo@example.com'/>"
"</entry>");
/* Missing namespace (still valid XML, just not what's expected) */
g_assert (gdata_test_compare_xml (GDATA_PARSABLE (rule),
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' "
"xmlns:gAcl='http://schemas.google.com/acl/2007'>"
"<title type='text'>none</title>"
"<id>an-id</id>"
"<category term='http://schemas.google.com/acl/2007#accessRule' scheme='http://schemas.google.com/g/2005#kind'/>"
"<gAcl:role value='none'/>"
"<gAcl:scope type='user' value='foo@example.com'/>"
"</entry>", FALSE) == FALSE);
/* Extra namespace */
g_assert (gdata_test_compare_xml (GDATA_PARSABLE (rule),
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' "
"xmlns:gd='http://schemas.google.com/g/2005' "
"xmlns:gAcl='http://schemas.google.com/acl/2007' "
"xmlns:foo='http://foo.com/'>"
"<title type='text'>none</title>"
"<id>an-id</id>"
"<category term='http://schemas.google.com/acl/2007#accessRule' scheme='http://schemas.google.com/g/2005#kind'/>"
"<gAcl:role value='none'/>"
"<gAcl:scope type='user' value='foo@example.com'/>"
"</entry>", FALSE) == FALSE);
/* Missing element */
g_assert (gdata_test_compare_xml (GDATA_PARSABLE (rule),
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' "
"xmlns:gd='http://schemas.google.com/g/2005' "
"xmlns:gAcl='http://schemas.google.com/acl/2007'>"
"<id>an-id</id>"
"<category term='http://schemas.google.com/acl/2007#accessRule' scheme='http://schemas.google.com/g/2005#kind'/>"
"<gAcl:role value='none'/>"
"<gAcl:scope type='user' value='foo@example.com'/>"
"</entry>", FALSE) == FALSE);
/* Extra element */
g_assert (gdata_test_compare_xml (GDATA_PARSABLE (rule),
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' "
"xmlns:gd='http://schemas.google.com/g/2005' "
"xmlns:gAcl='http://schemas.google.com/acl/2007'>"
"<title type='text'>none</title>"
"<foo>bar</foo>"
"<id>an-id</id>"
"<category term='http://schemas.google.com/acl/2007#accessRule' scheme='http://schemas.google.com/g/2005#kind'/>"
"<gAcl:role value='none'/>"
"<gAcl:scope type='user' value='foo@example.com'/>"
"</entry>", FALSE) == FALSE);
/* Incorrect namespace on element */
g_assert (gdata_test_compare_xml (GDATA_PARSABLE (rule),
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' "
"xmlns:gd='http://schemas.google.com/g/2005' "
"xmlns:gAcl='http://schemas.google.com/acl/2007'>"
"<gAcl:title type='text'>none</gAcl:title>"
"<id>an-id</id>"
"<category term='http://schemas.google.com/acl/2007#accessRule' scheme='http://schemas.google.com/g/2005#kind'/>"
"<gAcl:role value='none'/>"
"<gAcl:scope type='user' value='foo@example.com'/>"
"</entry>", FALSE) == FALSE);
/* Mis-valued content */
g_assert (gdata_test_compare_xml (GDATA_PARSABLE (rule),
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' "
"xmlns:gd='http://schemas.google.com/g/2005' "
"xmlns:gAcl='http://schemas.google.com/acl/2007'>"
"<title type='text'>none</title>"
"<id>an-other-id</id>"
"<category term='http://schemas.google.com/acl/2007#accessRule' scheme='http://schemas.google.com/g/2005#kind'/>"
"<gAcl:role value='none'/>"
"<gAcl:scope type='user' value='foo@example.com'/>"
"</entry>", FALSE) == FALSE);
/* Missing attribute */
g_assert (gdata_test_compare_xml (GDATA_PARSABLE (rule),
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' "
"xmlns:gd='http://schemas.google.com/g/2005' "
"xmlns:gAcl='http://schemas.google.com/acl/2007'>"
"<title type='text'>none</title>"
"<id>an-id</id>"
"<category term='http://schemas.google.com/acl/2007#accessRule' scheme='http://schemas.google.com/g/2005#kind'/>"
"<gAcl:role/>"
"<gAcl:scope type='user' value='foo@example.com'/>"
"</entry>", FALSE) == FALSE);
/* Extra attribute */
g_assert (gdata_test_compare_xml (GDATA_PARSABLE (rule),
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' "
"xmlns:gd='http://schemas.google.com/g/2005' "
"xmlns:gAcl='http://schemas.google.com/acl/2007'>"
"<title type='text'>none</title>"
"<id>an-id</id>"
"<category term='http://schemas.google.com/acl/2007#accessRule' scheme='http://schemas.google.com/g/2005#kind'/>"
"<gAcl:role value='none' other-value='foo'/>"
"<gAcl:scope type='user' value='foo@example.com'/>"
"</entry>", FALSE) == FALSE);
/* Mis-valued attribute */
g_assert (gdata_test_compare_xml (GDATA_PARSABLE (rule),
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' "
"xmlns:gd='http://schemas.google.com/g/2005' "
"xmlns:gAcl='http://schemas.google.com/acl/2007'>"
"<title type='text'>none</title>"
"<id>an-id</id>"
"<category term='http://schemas.google.com/acl/2007#accessRule' scheme='http://schemas.google.com/g/2005#kind'/>"
"<gAcl:role value='other'/>"
"<gAcl:scope type='user' value='foo@example.com'/>"
"</entry>", FALSE) == FALSE);
g_object_unref (rule);
}
static void
test_entry_get_xml (void)
{
gint64 updated, published, updated2, published2, updated3, published3;
GDataEntry *entry, *entry2;
GDataCategory *category;
GDataLink *_link; /* stupid unistd.h */
GDataAuthor *author;
gchar *xml, *title, *summary, *id, *etag, *content, *content_uri, *rights;
gboolean is_inserted;
GList *list;
GError *error = NULL;
entry = gdata_entry_new (NULL);
/* Test setting properties directly */
g_object_set (G_OBJECT (entry),
"title", "First testing title & escaping",
"summary", "Test summary & escaping.",
"content", "Test <markup> & escaping.",
"rights", "Philip Withnall <philip@tecnocode.co.uk>",
NULL);
g_assert_cmpstr (gdata_entry_get_title (entry), ==, "First testing title & escaping");
g_assert_cmpstr (gdata_entry_get_summary (entry), ==, "Test summary & escaping.");
g_assert_cmpstr (gdata_entry_get_content (entry), ==, "Test <markup> & escaping.");
g_assert (gdata_entry_get_content_uri (entry) == NULL);
g_assert_cmpstr (gdata_entry_get_rights (entry), ==, "Philip Withnall <philip@tecnocode.co.uk>");
/* Set the properties more conventionally */
gdata_entry_set_title (entry, "Testing title & escaping");
gdata_entry_set_summary (entry, NULL);
gdata_entry_set_content (entry, "This is some sample content testing, amongst other things, <markup> & odd characters‽");
gdata_entry_set_rights (entry, NULL);
/* Content URI */
g_object_set (G_OBJECT (entry), "content-uri", "http://foo.com/", NULL);
g_assert (gdata_entry_get_content (entry) == NULL);
g_assert_cmpstr (gdata_entry_get_content_uri (entry), ==, "http://foo.com/");
gdata_entry_set_content_uri (entry, "http://bar.com/");
/* Check the generated XML's OK */
gdata_test_assert_xml (entry,
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005'>"
"<title type='text'>Testing title & escaping</title>"
"<content type='text/plain' src='http://bar.com/'/>"
"</entry>");
/* Reset the content */
gdata_entry_set_content (entry, "This is some sample content testing, amongst other things, <markup> & odd characters‽");
/* Categories */
category = gdata_category_new ("test", NULL, NULL);
gdata_entry_add_category (entry, category);
g_object_unref (category);
category = gdata_category_new ("example", NULL, "Example stuff");
gdata_entry_add_category (entry, category);
g_object_unref (category);
category = gdata_category_new ("Film", "http://gdata.youtube.com/schemas/2007/categories.cat", "Film & Animation");
gdata_entry_add_category (entry, category);
g_object_unref (category);
/* Links */
_link = gdata_link_new ("http://test.com/", GDATA_LINK_SELF);
gdata_link_set_content_type (_link, "application/atom+xml");
gdata_entry_add_link (entry, _link);
g_object_unref (_link);
_link = gdata_link_new ("http://example.com/", NULL);
gdata_entry_add_link (entry, _link);
g_object_unref (_link);
_link = gdata_link_new ("http://test.mn/", GDATA_LINK_RELATED);
gdata_link_set_content_type (_link, "text/html");
gdata_link_set_language (_link, "mn");
gdata_link_set_title (_link, "A treatise on Mongolian test websites & other stuff.");
gdata_link_set_length (_link, 5010);
gdata_entry_add_link (entry, _link);
g_object_unref (_link);
_link = gdata_link_new ("http://example.com/", "http://foobar.link");
gdata_entry_add_link (entry, _link);
g_object_unref (_link);
_link = gdata_link_new ("http://example2.com/", "http://foobar.link");
gdata_entry_add_link (entry, _link);
g_object_unref (_link);
/* Authors */
author = gdata_author_new ("Joe Bloggs", "http://example.com/", "joe@example.com");
gdata_entry_add_author (entry, author);
g_object_unref (author);
author = gdata_author_new ("John Smith", NULL, "smith.john@example.com");
gdata_entry_add_author (entry, author);
g_object_unref (author);
author = gdata_author_new ("F. Barr؟", NULL, NULL);
gdata_entry_add_author (entry, author);
g_object_unref (author);
/* Check the generated XML's OK */
gdata_test_assert_xml (entry,
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005'>"
"<title type='text'>Testing title & escaping</title>"
"<content type='text'>This is some sample content testing, amongst other things, <markup> & odd characters\342\200\275</content>"
"<category term='Film' scheme='http://gdata.youtube.com/schemas/2007/categories.cat' label='Film & Animation'/>"
"<category term='example' label='Example stuff'/>"
"<category term='test'/>"
"<link href='http://example2.com/' rel='http://foobar.link'/>"
"<link href='http://example.com/' rel='http://foobar.link'/>"
"<link href='http://test.mn/' title='A treatise on Mongolian test websites & other stuff.' rel='http://www.iana.org/assignments/relation/related' type='text/html' hreflang='mn' length='5010'/>"
"<link href='http://example.com/' rel='http://www.iana.org/assignments/relation/alternate'/>"
"<link href='http://test.com/' rel='http://www.iana.org/assignments/relation/self' type='application/atom+xml'/>"
"<author><name>F. Barr\330\237</name></author>"
"<author><name>John Smith</name><email>smith.john@example.com</email></author>"
"<author><name>Joe Bloggs</name><uri>http://example.com/</uri><email>joe@example.com</email></author>"
"</entry>");
/* Check again by re-parsing the XML to a GDataEntry */
xml = gdata_parsable_get_xml (GDATA_PARSABLE (entry));
entry2 = GDATA_ENTRY (gdata_parsable_new_from_xml (GDATA_TYPE_ENTRY, xml, -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_ENTRY (entry2));
g_clear_error (&error);
g_free (xml);
g_assert_cmpstr (gdata_entry_get_title (entry), ==, gdata_entry_get_title (entry2));
g_assert_cmpstr (gdata_entry_get_id (entry), ==, gdata_entry_get_id (entry2)); /* should both be NULL */
g_assert_cmpstr (gdata_entry_get_content (entry), ==, gdata_entry_get_content (entry2));
g_assert_cmpstr (gdata_entry_get_content_uri (entry), ==, gdata_entry_get_content_uri (entry2)); /* should both be NULL */
updated = gdata_entry_get_updated (entry);
updated2 = gdata_entry_get_updated (entry2);
g_assert_cmpuint (updated, ==, updated2);
published = gdata_entry_get_published (entry);
published2 = gdata_entry_get_published (entry2);
g_assert_cmpuint (published, ==, published2);
/* Check links */
_link = gdata_entry_look_up_link (entry, GDATA_LINK_SELF);
g_assert (_link != NULL);
g_assert_cmpstr (gdata_link_get_uri (_link), ==, "http://test.com/");
g_assert_cmpstr (gdata_link_get_relation_type (_link), ==, GDATA_LINK_SELF);
g_assert_cmpstr (gdata_link_get_content_type (_link), ==, "application/atom+xml");
_link = gdata_entry_look_up_link (entry, "http://link.not.exist");
g_assert (_link == NULL);
list = gdata_entry_look_up_links (entry, "http://foobar.link");
g_assert (list != NULL);
g_assert_cmpint (g_list_length (list), ==, 2);
_link = GDATA_LINK (list->data);
g_assert (_link != NULL);
g_assert_cmpstr (gdata_link_get_uri (_link), ==, "http://example2.com/");
g_assert_cmpstr (gdata_link_get_relation_type (_link), ==, "http://foobar.link");
_link = GDATA_LINK (list->next->data);
g_assert (_link != NULL);
g_assert_cmpstr (gdata_link_get_uri (_link), ==, "http://example.com/");
g_assert_cmpstr (gdata_link_get_relation_type (_link), ==, "http://foobar.link");
g_list_free (list);
/* Check authors */
list = gdata_entry_get_authors (entry);
g_assert_cmpuint (g_list_length (list), ==, 3);
author = GDATA_AUTHOR (list->data);
g_assert (author != NULL);
g_assert_cmpstr (gdata_author_get_name (author), ==, "F. Barr؟");
g_assert (gdata_author_get_uri (author) == NULL);
g_assert (gdata_author_get_email_address (author) == NULL);
author = GDATA_AUTHOR (list->next->data);
g_assert (author != NULL);
g_assert_cmpstr (gdata_author_get_name (author), ==, "John Smith");
g_assert (gdata_author_get_uri (author) == NULL);
g_assert_cmpstr (gdata_author_get_email_address (author), ==, "smith.john@example.com");
author = GDATA_AUTHOR (list->next->next->data);
g_assert (author != NULL);
g_assert_cmpstr (gdata_author_get_name (author), ==, "Joe Bloggs");
g_assert_cmpstr (gdata_author_get_uri (author), ==, "http://example.com/");
g_assert_cmpstr (gdata_author_get_email_address (author), ==, "joe@example.com");
/* Check categories */
list = gdata_entry_get_categories (entry);
g_assert (list != NULL);
g_assert_cmpint (g_list_length (list), ==, 3);
category = GDATA_CATEGORY (list->data);
g_assert (category != NULL);
g_assert_cmpstr (gdata_category_get_term (category), ==, "Film");
g_assert_cmpstr (gdata_category_get_scheme (category), ==, "http://gdata.youtube.com/schemas/2007/categories.cat");
g_assert_cmpstr (gdata_category_get_label (category), ==, "Film & Animation");
category = GDATA_CATEGORY (list->next->data);
g_assert (category != NULL);
g_assert_cmpstr (gdata_category_get_term (category), ==, "example");
g_assert (gdata_category_get_scheme (category) == NULL);
g_assert_cmpstr (gdata_category_get_label (category), ==, "Example stuff");
category = GDATA_CATEGORY (list->next->next->data);
g_assert (category != NULL);
g_assert_cmpstr (gdata_category_get_term (category), ==, "test");
g_assert (gdata_category_get_scheme (category) == NULL);
g_assert (gdata_category_get_label (category) == NULL);
/* TODO: Check authors */
/* Check properties a different way */
g_object_get (G_OBJECT (entry2),
"title", &title,
"summary", &summary,
"id", &id,
"etag", &etag,
"updated", &updated3,
"published", &published3,
"content", &content,
"content-uri", &content_uri,
"is-inserted", &is_inserted,
"rights", &rights,
NULL);
g_assert_cmpstr (title, ==, gdata_entry_get_title (entry));
g_assert_cmpstr (summary, ==, gdata_entry_get_summary (entry));
g_assert_cmpstr (id, ==, gdata_entry_get_id (entry));
g_assert_cmpstr (etag, ==, gdata_entry_get_etag (entry));
g_assert_cmpint (updated3, ==, updated);
g_assert_cmpint (published3, ==, published);
g_assert_cmpstr (content, ==, gdata_entry_get_content (entry));
g_assert_cmpstr (content_uri, ==, gdata_entry_get_content_uri (entry));
g_assert (is_inserted == FALSE);
g_assert_cmpstr (rights, ==, gdata_entry_get_rights (entry));
g_free (title);
g_free (summary);
g_free (id);
g_free (etag);
g_free (content);
g_free (content_uri);
g_free (rights);
/* Set the content URI and check that */
gdata_entry_set_content_uri (entry, "http://baz.net/");
g_object_get (G_OBJECT (entry),
"content", &content,
"content-uri", &content_uri,
NULL);
g_assert_cmpstr (content, ==, gdata_entry_get_content (entry));
g_assert_cmpstr (content_uri, ==, gdata_entry_get_content_uri (entry));
g_free (content);
g_free (content_uri);
g_object_unref (entry);
g_object_unref (entry2);
}
static void
test_entry_get_json (void)
{
gint64 updated, published, updated2, published2;
GDataEntry *entry, *entry2;
gchar *json;
GError *error = NULL;
entry = gdata_entry_new (NULL);
/* Set the properties more conventionally */
gdata_entry_set_title (entry, "Testing title & \"escaping\"");
gdata_entry_set_summary (entry, NULL);
gdata_entry_set_content (entry, NULL);
gdata_entry_set_rights (entry, NULL);
/* Check the generated JSON's OK */
gdata_test_assert_json (entry,
"{"
"\"title\":\"Testing title & \\\"escaping\\\"\""
"}");
/* Check again by re-parsing the JSON to a GDataEntry. */
json = gdata_parsable_get_json (GDATA_PARSABLE (entry));
entry2 = GDATA_ENTRY (gdata_parsable_new_from_json (GDATA_TYPE_ENTRY, json, -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_ENTRY (entry2));
g_clear_error (&error);
g_free (json);
g_assert_cmpstr (gdata_entry_get_title (entry), ==, gdata_entry_get_title (entry2));
g_assert_cmpstr (gdata_entry_get_id (entry), ==, gdata_entry_get_id (entry2)); /* should both be NULL */
g_assert_cmpstr (gdata_entry_get_content (entry), ==, gdata_entry_get_content (entry2));
g_assert_cmpstr (gdata_entry_get_content_uri (entry), ==, gdata_entry_get_content_uri (entry2)); /* should both be NULL */
updated = gdata_entry_get_updated (entry);
updated2 = gdata_entry_get_updated (entry2);
g_assert_cmpuint (updated, ==, updated2);
published = gdata_entry_get_published (entry);
published2 = gdata_entry_get_published (entry2);
g_assert_cmpuint (published, ==, published2);
g_object_unref (entry);
g_object_unref (entry2);
}
static void
test_entry_parse_xml (void)
{
GDataEntry *entry;
GError *error = NULL;
/* Create an entry from XML with unhandled elements */
entry = GDATA_ENTRY (gdata_parsable_new_from_xml (GDATA_TYPE_ENTRY,
"<entry xmlns='http://www.w3.org/2005/Atom' xmlns:ns='http://example.com/'>"
"<title type='text'>Testing unhandled XML</title>"
"<updated>2009-01-25T14:07:37Z</updated>"
"<published>2009-01-23T14:06:37Z</published>"
"<content type='text'>Here we test unhandled XML elements.</content>"
"<foobar>Test!</foobar>"
"<barfoo shizzle='zing'/>"
"<ns:barfoo shizzle='zing' fo='shizzle'>How about some characters‽</ns:barfoo>"
"</entry>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_ENTRY (entry));
g_clear_error (&error);
/* Now check the outputted XML from the entry still has the unhandled elements */
gdata_test_assert_xml (entry,
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' xmlns:ns='http://example.com/'>"
"<title type='text'>Testing unhandled XML</title>"
"<updated>2009-01-25T14:07:37Z</updated>"
"<published>2009-01-23T14:06:37Z</published>"
"<content type='text'>Here we test unhandled XML elements.</content>"
"<foobar>Test!</foobar>"
"<barfoo shizzle=\"zing\"/>"
"<ns:barfoo shizzle=\"zing\" fo=\"shizzle\">How about some characters‽</ns:barfoo>"
"</entry>");
g_object_unref (entry);
}
static void
test_entry_parse_xml_kind_category (void)
{
GDataEntry *entry;
GError *error = NULL;
g_test_bug ("707477");
/* Create an entry from XML with a ‘kind’ category with extra attributes. */
entry = GDATA_ENTRY (gdata_parsable_new_from_xml (GDATA_TYPE_ENTRY,
"<entry xmlns='http://www.w3.org/2005/Atom'>"
"<title type='text'>Testing kind categories</title>"
"<updated>2009-01-25T14:07:37Z</updated>"
"<published>2009-01-23T14:06:37Z</published>"
"<content type='text'>Here we test kind categories.</content>"
"<category scheme='http://schemas.google.com/g/2005#kind' "
"term='http://schemas.google.com/docs/2007#file' "
"label='application/vnd.oasis.opendocument.presentation'/>"
"<category scheme='http://schemas.google.com/g/2005/labels' "
"term='http://schemas.google.com/g/2005/labels#modified-by-me' "
"label='modified-by-me'/>"
"</entry>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_ENTRY (entry));
g_clear_error (&error);
/* Now check the outputted XML from the entry still has the extra attributes */
gdata_test_assert_xml (entry,
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005'>"
"<title type='text'>Testing kind categories</title>"
"<updated>2009-01-25T14:07:37Z</updated>"
"<published>2009-01-23T14:06:37Z</published>"
"<content type='text'>Here we test kind categories.</content>"
"<category term='http://schemas.google.com/docs/2007#file' "
"scheme='http://schemas.google.com/g/2005#kind' "
"label='application/vnd.oasis.opendocument.presentation'/>"
"<category term='http://schemas.google.com/g/2005/labels#modified-by-me' "
"scheme='http://schemas.google.com/g/2005/labels' "
"label='modified-by-me'/>"
"</entry>");
g_object_unref (entry);
}
static void
test_entry_parse_json (void)
{
GDataEntry *entry;
GError *error = NULL;
/* Create an entry from JSON with unhandled nodes. */
entry = GDATA_ENTRY (gdata_parsable_new_from_json (GDATA_TYPE_ENTRY,
"{"
"\"title\":\"A title\","
"\"updated\":\"2009-01-25T14:07:37Z\","
"\"selfLink\":\"http://example.com/\","
"\"etag\":\"some-etag\","
"\"id\":\"some-id\","
"\"kind\":\"kind#kind\","
"\"unhandled-boolean\":false,"
"\"unhandled-string\":\"this-is-a-string---sometimes\","
"\"unhandled-int\":15,"
"\"unhandled-double\":42.42,"
"\"unhandled-object\":{"
"\"a\":true,"
"\"b\":true"
"},"
"\"unhandled-array\":["
"1,"
"2,"
"3"
"],"
"\"unhandled-null\":null"
"}", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_ENTRY (entry));
/* Now check the outputted JSON from the entry still has the unhandled nodes. */
gdata_test_assert_json (entry,
"{"
"\"title\":\"A title\","
"\"id\":\"some-id\","
"\"updated\":\"2009-01-25T14:07:37Z\","
"\"etag\":\"some-etag\","
"\"selfLink\":\"http://example.com/\","
"\"kind\":\"kind#kind\","
"\"unhandled-boolean\":false,"
"\"unhandled-string\":\"this-is-a-string---sometimes\","
"\"unhandled-int\":15,"
"\"unhandled-double\":42.42,"
"\"unhandled-object\":{"
"\"a\":true,"
"\"b\":true"
"},"
"\"unhandled-array\":["
"1,"
"2,"
"3"
"],"
"\"unhandled-null\":null"
"}");
g_object_unref (entry);
/* Test parsing of empty titles. */
entry = GDATA_ENTRY (gdata_parsable_new_from_json (GDATA_TYPE_ENTRY,
"{"
"\"title\":\"\""
"}", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_ENTRY (entry));
g_object_unref (entry);
}
static void
test_entry_error_handling_xml (void)
{
GDataEntry *entry;
GError *error = NULL;
#define TEST_XML_ERROR_HANDLING(x) entry = GDATA_ENTRY (gdata_parsable_new_from_xml (GDATA_TYPE_ENTRY,\
"<entry>"\
x\
"</entry>", -1, &error));\
g_assert_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR);\
g_assert (entry == NULL);\
g_clear_error (&error)
/* updated */
TEST_XML_ERROR_HANDLING ("<updated>not a date</updated>"); /* invalid date */
/* published */
TEST_XML_ERROR_HANDLING ("<published>also not a date</published>"); /* invalid date */
/* category */
TEST_XML_ERROR_HANDLING ("<category/>"); /* invalid category */
/* link */
TEST_XML_ERROR_HANDLING ("<link/>"); /* invalid link */
/* author */
TEST_XML_ERROR_HANDLING ("<author/>"); /* invalid author */
#undef TEST_XML_ERROR_HANDLING
}
static void
test_entry_error_handling_json (void)
{
GDataEntry *entry;
GError *error = NULL;
#define TEST_JSON_ERROR_HANDLING(x) \
entry = GDATA_ENTRY (gdata_parsable_new_from_json (GDATA_TYPE_ENTRY,x, -1, &error));\
g_assert_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR);\
g_assert (entry == NULL);\
g_clear_error (&error)
#define TEST_JSON_ERROR_HANDLING_PARSER(x) \
entry = GDATA_ENTRY (gdata_parsable_new_from_json (GDATA_TYPE_ENTRY,x, -1, &error));\
g_assert_error (error, GDATA_PARSER_ERROR, GDATA_PARSER_ERROR_PARSING_STRING);\
g_assert (entry == NULL);\
g_clear_error (&error)
/* General structure. */
TEST_JSON_ERROR_HANDLING_PARSER ("[true,false,true]"); /* root node is not an object */
TEST_JSON_ERROR_HANDLING_PARSER ("false"); /* root node is not an object */
TEST_JSON_ERROR_HANDLING_PARSER ("invalid json"); /* totally invalid JSON */
/* id */
TEST_JSON_ERROR_HANDLING ("{\"id\":\"\"}"); /* empty */
TEST_JSON_ERROR_HANDLING ("{\"id\":null}"); /* invalid type */
/* updated */
TEST_JSON_ERROR_HANDLING ("{\"updated\":\"not correct\"}"); /* incorrect format */
TEST_JSON_ERROR_HANDLING ("{\"updated\":false}"); /* invalid type */
TEST_JSON_ERROR_HANDLING ("{\"updated\":\"\"}"); /* empty */
/* title */
TEST_JSON_ERROR_HANDLING ("{\"title\":false}"); /* invalid type */
/* etag */
TEST_JSON_ERROR_HANDLING ("{\"etag\":\"\"}"); /* empty */
TEST_JSON_ERROR_HANDLING ("{\"etag\":false}"); /* invalid type */
/* selfLink */
TEST_JSON_ERROR_HANDLING ("{\"selfLink\":\"\"}"); /* empty */
TEST_JSON_ERROR_HANDLING ("{\"selfLink\":false}"); /* invalid type */
/* kind */
TEST_JSON_ERROR_HANDLING ("{\"kind\":\"\"}"); /* empty */
TEST_JSON_ERROR_HANDLING ("{\"kind\":false}"); /* invalid type */
#undef TEST_JSON_ERROR_HANDLING_PARSER
#undef TEST_JSON_ERROR_HANDLING
}
static void
test_entry_escaping (void)
{
GDataEntry *entry;
GError *error = NULL;
/* Since we can't construct a GDataEntry directly, we need to parse it from XML */
entry = GDATA_ENTRY (gdata_parsable_new_from_xml (GDATA_TYPE_ENTRY,
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom'>"
"<title type='text'>Escaped content & stuff</title>"
"<id>http://foo.com/?foo&bar</id>"
"<updated>2010-12-10T17:21:24Z</updated>"
"<published>2010-12-10T17:21:24Z</published>"
"<summary type='text'>Summary & stuff</summary>"
"<rights>Free & open source</rights>"
"<content type='text'>Content & things.</content>"
"</entry>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_ENTRY (entry));
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (entry,
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005'>"
"<title type='text'>Escaped content & stuff</title>"
"<id>http://foo.com/?foo&bar</id>"
"<updated>2010-12-10T17:21:24Z</updated>"
"<published>2010-12-10T17:21:24Z</published>"
"<summary type='text'>Summary & stuff</summary>"
"<rights>Free & open source</rights>"
"<content type='text'>Content & things.</content>"
"</entry>");
g_object_unref (entry);
/* Repeat with content given by a URI */
entry = GDATA_ENTRY (gdata_parsable_new_from_xml (GDATA_TYPE_ENTRY,
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom'>"
"<title type='text'>Escaped content & stuff</title>"
"<content type='text/plain' src='http://foo.com?foo&bar'/>"
"</entry>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_ENTRY (entry));
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (entry,
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005'>"
"<title type='text'>Escaped content & stuff</title>"
"<content type='text/plain' src='http://foo.com?foo&bar'/>"
"</entry>");
g_object_unref (entry);
}
static void
test_entry_links_remove (void)
{
GDataEntry *entry;
GDataLink *link_, *link2_;
GError *error = NULL;
/* Since we can't construct a GDataEntry directly, we need to parse it from XML. */
entry = GDATA_ENTRY (gdata_parsable_new_from_xml (GDATA_TYPE_ENTRY,
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom'>"
"<title type='text'>Escaped content & stuff</title>"
"<id>http://foo.com/?foo&bar</id>"
"<updated>2010-12-10T17:21:24Z</updated>"
"<published>2010-12-10T17:21:24Z</published>"
"<summary type='text'>Summary & stuff</summary>"
"<rights>Free & open source</rights>"
"<content type='text'>Content & things.</content>"
"</entry>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_ENTRY (entry));
link_ = gdata_link_new ("http://example.com/", GDATA_LINK_RELATED);
/* Add a link. */
gdata_entry_add_link (entry, link_);
g_assert (gdata_entry_look_up_link (entry, GDATA_LINK_RELATED) == link_);
/* Remove the link. */
g_assert (gdata_entry_remove_link (entry, link_) == TRUE);
g_assert (gdata_entry_look_up_link (entry, GDATA_LINK_RELATED) == NULL);
/* Attempt to remove a non-existent link. */
link2_ = gdata_link_new ("http://foobar.com/", GDATA_LINK_SELF);
g_assert (gdata_entry_remove_link (entry, link2_) == FALSE);
g_object_unref (link2_);
g_object_unref (link_);
g_object_unref (entry);
}
static void
test_feed_parse_xml (void)
{
GDataFeed *feed;
GDataEntry *entry;
GDataLink *_link; /* stupid unistd.h */
GList *list;
gchar *title, *subtitle, *id, *etag, *logo, *icon, *rights;
gint64 updated, updated2;
GDataGenerator *generator;
guint items_per_page, start_index, total_results;
GError *error = NULL;
feed = GDATA_FEED (gdata_parsable_new_from_xml (GDATA_TYPE_FEED,
"<feed xmlns='http://www.w3.org/2005/Atom' "
"xmlns:openSearch='http://a9.com/-/spec/opensearch/1.1/' "
"xmlns:gd='http://schemas.google.com/g/2005' "
"gd:etag='W/\"D08FQn8-eil7ImA9WxZbFEw.\"'>"
"<id>http://example.com/id</id>"
"<updated>2009-02-25T14:07:37.880860Z</updated>"
"<title type='text'>Test feed</title>"
"<subtitle type='text'>Test subtitle</subtitle>"
"<logo>http://example.com/logo.png</logo>"
"<icon>http://example.com/icon.png</icon>"
"<link rel='alternate' type='text/html' href='http://alternate.example.com/'/>"
"<link rel='http://schemas.google.com/g/2005#feed' type='application/atom+xml' href='http://example.com/id'/>"
"<link rel='http://schemas.google.com/g/2005#post' type='application/atom+xml' href='http://example.com/post'/>"
"<link rel='self' type='application/atom+xml' href='http://example.com/id'/>"
"<category scheme='http://example.com/categories' term='feed'/>"
"<rights>public</rights>"
"<author>"
"<name>Joe Smith</name>"
"<email>j.smith@example.com</email>"
"</author>"
"<generator version='0.6' uri='http://example.com/'>Example Generator</generator>"
"<openSearch:totalResults>2</openSearch:totalResults>"
"<openSearch:startIndex>1</openSearch:startIndex>"
"<openSearch:itemsPerPage>50</openSearch:itemsPerPage>"
"<entry>"
"<id>entry1</id>"
"<title type='text'>Testing unhandled XML</title>"
"<updated>2009-01-25T14:07:37.880860Z</updated>"
"<published>2009-01-23T14:06:37.880860Z</published>"
"<content type='text'>Here we test unhandled XML elements.</content>"
"</entry>"
"<entry>"
"<id>entry2</id>"
"<title type='text'>Testing unhandled XML 2</title>"
"<updated>2009-02-25T14:07:37.880860Z</updated>"
"<published>2009-02-23T14:06:37.880860Z</published>"
"<content type='text'>Here we test unhandled XML elements again.</content>"
"</entry>"
"<foobar>Test unhandled elements!</foobar>"
"</feed>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_FEED (feed));
g_clear_error (&error);
/* Check the feed's properties */
g_object_get (G_OBJECT (feed),
"title", &title,
"subtitle", &subtitle,
"id", &id,
"etag", &etag,
"updated", &updated,
"logo", &logo,
"icon", &icon,
"generator", &generator,
"rights", &rights,
"items-per-page", &items_per_page,
"start-index", &start_index,
"total-results", &total_results,
NULL);
g_assert_cmpstr (title, ==, "Test feed");
g_assert_cmpstr (subtitle, ==, "Test subtitle");
g_assert_cmpstr (id, ==, "http://example.com/id");
g_assert_cmpstr (etag, ==, "W/\"D08FQn8-eil7ImA9WxZbFEw.\"");
g_assert_cmpint (updated, ==, 1235570857);
g_assert_cmpstr (logo, ==, "http://example.com/logo.png");
g_assert_cmpstr (icon, ==, "http://example.com/icon.png");
g_assert_cmpstr (rights, ==, "public");
g_assert (GDATA_IS_GENERATOR (generator));
g_assert_cmpstr (gdata_generator_get_name (generator), ==, "Example Generator");
g_assert_cmpstr (gdata_generator_get_uri (generator), ==, "http://example.com/");
g_assert_cmpstr (gdata_generator_get_version (generator), ==, "0.6");
g_assert_cmpuint (items_per_page, ==, 50);
g_assert_cmpuint (start_index, ==, 1);
g_assert_cmpuint (total_results, ==, 2);
g_free (title);
g_free (subtitle);
g_free (id);
g_free (etag);
g_free (logo);
g_free (icon);
g_free (rights);
g_object_unref (generator);
/* Check the entries */
entry = gdata_feed_look_up_entry (feed, "entry1");
g_assert (GDATA_IS_ENTRY (entry));
entry = gdata_feed_look_up_entry (feed, "this doesn't exist");
g_assert (entry == NULL);
entry = gdata_feed_look_up_entry (feed, "entry2");
g_assert (GDATA_IS_ENTRY (entry));
/* Check the categories */
list = gdata_feed_get_categories (feed);
g_assert (list != NULL);
g_assert_cmpint (g_list_length (list), ==, 1);
g_assert (GDATA_IS_CATEGORY (list->data));
/* Check the links */
list = gdata_feed_get_links (feed);
g_assert (list != NULL);
g_assert_cmpint (g_list_length (list), ==, 4);
g_assert (GDATA_IS_LINK (list->data));
g_assert (GDATA_IS_LINK (list->next->data));
g_assert (GDATA_IS_LINK (list->next->next->data));
g_assert (GDATA_IS_LINK (list->next->next->next->data));
_link = gdata_feed_look_up_link (feed, GDATA_LINK_ALTERNATE);
g_assert (GDATA_IS_LINK (_link));
_link = gdata_feed_look_up_link (feed, "this doesn't exist");
g_assert (_link == NULL);
_link = gdata_feed_look_up_link (feed, "http://schemas.google.com/g/2005#feed");
g_assert (GDATA_IS_LINK (_link));
_link = gdata_feed_look_up_link (feed, "http://schemas.google.com/g/2005#post");
g_assert (GDATA_IS_LINK (_link));
_link = gdata_feed_look_up_link (feed, GDATA_LINK_SELF);
g_assert (GDATA_IS_LINK (_link));
/* Check the authors */
list = gdata_feed_get_authors (feed);
g_assert (list != NULL);
g_assert_cmpint (g_list_length (list), ==, 1);
g_assert (GDATA_IS_AUTHOR (list->data));
/* Check the other properties again, the more normal way this time */
g_assert_cmpstr (gdata_feed_get_title (feed), ==, "Test feed");
g_assert_cmpstr (gdata_feed_get_subtitle (feed), ==, "Test subtitle");
g_assert_cmpstr (gdata_feed_get_id (feed), ==, "http://example.com/id");
g_assert_cmpstr (gdata_feed_get_etag (feed), ==, "W/\"D08FQn8-eil7ImA9WxZbFEw.\"");
updated2 = gdata_feed_get_updated (feed);
g_assert_cmpint (updated2, ==, 1235570857);
g_assert_cmpstr (gdata_feed_get_logo (feed), ==, "http://example.com/logo.png");
g_assert_cmpstr (gdata_feed_get_icon (feed), ==, "http://example.com/icon.png");
g_assert_cmpstr (gdata_feed_get_rights (feed), ==, "public");
generator = gdata_feed_get_generator (feed);
g_assert (GDATA_IS_GENERATOR (generator));
g_assert_cmpstr (gdata_generator_get_name (generator), ==, "Example Generator");
g_assert_cmpstr (gdata_generator_get_uri (generator), ==, "http://example.com/");
g_assert_cmpstr (gdata_generator_get_version (generator), ==, "0.6");
g_assert_cmpuint (gdata_feed_get_items_per_page (feed), ==, 50);
g_assert_cmpuint (gdata_feed_get_start_index (feed), ==, 1);
g_assert_cmpuint (gdata_feed_get_total_results (feed), ==, 2);
g_object_unref (feed);
}
static void
test_feed_error_handling (void)
{
GDataFeed *feed;
GError *error = NULL;
#define TEST_XML_ERROR_HANDLING(x) feed = GDATA_FEED (gdata_parsable_new_from_xml (GDATA_TYPE_FEED, \
"<feed xmlns='http://www.w3.org/2005/Atom' xmlns:openSearch='http://a9.com/-/spec/opensearch/1.1/'>"\
x\
"</feed>", -1, &error));\
g_assert_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR);\
g_assert (feed == NULL);\
g_clear_error (&error)
/* entry */
TEST_XML_ERROR_HANDLING ("<entry><updated>this isn't a date</updated></entry>"); /* invalid entry */
/* title */
TEST_XML_ERROR_HANDLING ("<title>First title</title><title>Second title</title>"); /* duplicate title */
#if 0
/* FIXME: Removed due to the YouTube comments feed not being a valid Atom feed.
* See: https://code.google.com/p/gdata-issues/issues/detail?id=2908
* and: https://bugzilla.gnome.org/show_bug.cgi?id=679072 */
TEST_XML_ERROR_HANDLING ("<id>ID</id><updated>2009-01-25T14:07:37.880860Z</updated>"); /* missing title */
#endif
/* subtitle */
TEST_XML_ERROR_HANDLING ("<subtitle>First subtitle</subtitle><subtitle>Second subtitle</subtitle>"); /* duplicate subtitle */
/* id */
TEST_XML_ERROR_HANDLING ("<id>First ID</id><id>Second ID</id>"); /* duplicate ID */
TEST_XML_ERROR_HANDLING ("<title>Title</title><updated>2009-01-25T14:07:37.880860Z</updated>"); /* missing ID */
/* updated */
TEST_XML_ERROR_HANDLING ("<updated>2009-01-25T14:07:37.880860Z</updated>"
"<updated>2009-01-25T14:07:37.880860Z</updated>"); /* duplicate updated */
TEST_XML_ERROR_HANDLING ("<updated>not a date</updated>"); /* invalid date */
TEST_XML_ERROR_HANDLING ("<title>Title</title><id>ID</id>"); /* missing updated */
/* category */
TEST_XML_ERROR_HANDLING ("<category/>"); /* invalid category */
/* logo */
TEST_XML_ERROR_HANDLING ("<logo>First logo</logo><logo>Second logo</logo>"); /* duplicate logo */
/* icon */
TEST_XML_ERROR_HANDLING ("<icon>First icon</icon><icon>Second icon</icon>"); /* duplicate icon */
/* link */
TEST_XML_ERROR_HANDLING ("<link/>"); /* invalid link */
/* author */
TEST_XML_ERROR_HANDLING ("<author/>"); /* invalid author */
/* generator */
TEST_XML_ERROR_HANDLING ("<generator>First generator</generator><generator>Second generator</generator>"); /* duplicate generator */
TEST_XML_ERROR_HANDLING ("<generator uri=''/>"); /* invalid generator */
/* openSearch:totalResults */
TEST_XML_ERROR_HANDLING ("<openSearch:totalResults>5</openSearch:totalResults>"
"<openSearch:totalResults>3</openSearch:totalResults>"); /* duplicate totalResults */
TEST_XML_ERROR_HANDLING ("<openSearch:totalResults></openSearch:totalResults>"); /* missing content */
TEST_XML_ERROR_HANDLING ("<openSearch:totalResults>this isn't a number!</openSearch:totalResults>"); /* invalid number */
/* openSearch:startIndex */
TEST_XML_ERROR_HANDLING ("<openSearch:startIndex>5</openSearch:startIndex>"
"<openSearch:startIndex>3</openSearch:startIndex>"); /* duplicate startIndex */
TEST_XML_ERROR_HANDLING ("<openSearch:startIndex></openSearch:startIndex>"); /* missing content */
TEST_XML_ERROR_HANDLING ("<openSearch:startIndex>this isn't a number!</openSearch:startIndex>"); /* invalid number */
/* openSearch:itemsPerPage */
TEST_XML_ERROR_HANDLING ("<openSearch:itemsPerPage>5</openSearch:itemsPerPage>"
"<openSearch:itemsPerPage>3</openSearch:itemsPerPage>"); /* duplicate itemsPerPage */
TEST_XML_ERROR_HANDLING ("<openSearch:itemsPerPage></openSearch:itemsPerPage>"); /* missing content */
TEST_XML_ERROR_HANDLING ("<openSearch:itemsPerPage>this isn't a number!</openSearch:itemsPerPage>"); /* invalid number */
#undef TEST_XML_ERROR_HANDLING
}
static void
test_feed_escaping (void)
{
GDataFeed *feed;
GError *error = NULL;
/* Since we can't construct a GDataEntry directly, we need to parse it from XML */
feed = GDATA_FEED (gdata_parsable_new_from_xml (GDATA_TYPE_FEED,
"<?xml version='1.0' encoding='UTF-8'?>"
"<feed xmlns='http://www.w3.org/2005/Atom'>"
"<id>http://foo.com?foo&bar</id>"
"<updated>2010-12-10T17:49:15Z</updated>"
"<title type='text'>Test feed & stuff.</title>"
"</feed>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_FEED (feed));
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (feed,
"<?xml version='1.0' encoding='UTF-8'?>"
"<feed xmlns='http://www.w3.org/2005/Atom'>"
"<title type='text'>Test feed & stuff.</title>"
"<id>http://foo.com?foo&bar</id>"
"<updated>2010-12-10T17:49:15Z</updated>"
"</feed>");
g_object_unref (feed);
}
static void
test_query_categories (void)
{
GDataQuery *query;
gchar *query_uri;
query = gdata_query_new ("foobar");
/* AND */
gdata_query_set_categories (query, "Fritz/Laurie");
query_uri = gdata_query_get_query_uri (query, "http://example.com");
g_assert_cmpstr (query_uri, ==, "http://example.com/-/Fritz/Laurie?q=foobar");
g_free (query_uri);
/* OR */
gdata_query_set_categories (query, "Fritz|Laurie");
query_uri = gdata_query_get_query_uri (query, "http://example.com");
g_assert_cmpstr (query_uri, ==, "http://example.com/-/Fritz%7CLaurie?q=foobar");
g_free (query_uri);
/* Combination */
gdata_query_set_categories (query, "A|-{urn:google.com}B/-C");
query_uri = gdata_query_get_query_uri (query, "http://example.com/gdata_test");
g_assert_cmpstr (query_uri, ==, "http://example.com/gdata_test/-/A%7C-%7Burn%3Agoogle.com%7DB/-C?q=foobar");
g_free (query_uri);
/* Same combination without q param */
gdata_query_set_q (query, NULL);
query_uri = gdata_query_get_query_uri (query, "http://example.com");
g_assert_cmpstr (query_uri, ==, "http://example.com/-/A%7C-%7Burn%3Agoogle.com%7DB/-C");
g_free (query_uri);
g_object_unref (query);
}
static void
test_query_dates (void)
{
GDataQuery *query;
gchar *query_uri;
query = gdata_query_new ("baz");
/* updated-min */
gdata_query_set_updated_min (query, 1373280114); /* 2013-07-08T10:41:54Z */
query_uri = gdata_query_get_query_uri (query, "http://example.com");
g_assert_cmpstr (query_uri, ==, "http://example.com?q=baz&updated-min=2013-07-08T10:41:54Z");
g_free (query_uri);
gdata_query_set_updated_min (query, -1);
/* updated-max */
gdata_query_set_updated_max (query, 1373280114); /* 2013-07-08T10:41:54Z */
query_uri = gdata_query_get_query_uri (query, "http://example.com");
g_assert_cmpstr (query_uri, ==, "http://example.com?q=baz&updated-max=2013-07-08T10:41:54Z");
g_free (query_uri);
gdata_query_set_updated_max (query, -1);
/* published-min */
gdata_query_set_published_min (query, 1373280114); /* 2013-07-08T10:41:54Z */
query_uri = gdata_query_get_query_uri (query, "http://example.com");
g_assert_cmpstr (query_uri, ==, "http://example.com?q=baz&published-min=2013-07-08T10:41:54Z");
g_free (query_uri);
gdata_query_set_published_min (query, -1);
/* published-max */
gdata_query_set_published_max (query, 1373280114); /* 2013-07-08T10:41:54Z */
query_uri = gdata_query_get_query_uri (query, "http://example.com");
g_assert_cmpstr (query_uri, ==, "http://example.com?q=baz&published-max=2013-07-08T10:41:54Z");
g_free (query_uri);
gdata_query_set_published_max (query, -1);
g_object_unref (query);
}
static void
test_query_strict (void)
{
GDataQuery *query;
gchar *query_uri;
query = gdata_query_new ("bar");
gdata_query_set_is_strict (query, TRUE);
query_uri = gdata_query_get_query_uri (query, "http://example.com");
g_assert_cmpstr (query_uri, ==, "http://example.com?q=bar&strict=true");
g_free (query_uri);
gdata_query_set_is_strict (query, FALSE);
query_uri = gdata_query_get_query_uri (query, "http://example.com");
g_assert_cmpstr (query_uri, ==, "http://example.com?q=bar");
g_free (query_uri);
g_object_unref (query);
}
static void
test_query_pagination (void)
{
GDataQuery *query;
gchar *query_uri;
query = gdata_query_new ("test");
gdata_query_set_max_results (query, 15);
gdata_query_set_etag (query, "etag"); /* this should be cleared by pagination */
query_uri = gdata_query_get_query_uri (query, "http://example.com/");
g_assert_cmpstr (query_uri, ==, "http://example.com/?q=test&max-results=15");
g_free (query_uri);
/* Try the next and previous pages. */
gdata_query_next_page (query);
g_assert (gdata_query_get_etag (query) == NULL);
query_uri = gdata_query_get_query_uri (query, "http://example.com/");
g_assert_cmpstr (query_uri, ==, "http://example.com/?q=test&start-index=16&max-results=15");
g_free (query_uri);
gdata_query_set_etag (query, "etag");
g_assert (gdata_query_previous_page (query) == TRUE);
g_assert (gdata_query_get_etag (query) == NULL);
query_uri = gdata_query_get_query_uri (query, "http://example.com/");
g_assert_cmpstr (query_uri, ==, "http://example.com/?q=test&max-results=15");
g_free (query_uri);
/* Try another previous page. This should fail, and the ETag should be untouched. */
gdata_query_set_etag (query, "etag");
g_assert (gdata_query_previous_page (query) == FALSE);
g_assert_cmpstr (gdata_query_get_etag (query), ==, "etag");
g_object_unref (query);
/* Try the alternate constructor. */
query = gdata_query_new_with_limits ("test", 40, 10);
query_uri = gdata_query_get_query_uri (query, "http://example.com/");
g_assert_cmpstr (query_uri, ==, "http://example.com/?q=test&start-index=40&max-results=10");
g_free (query_uri);
/* Try the next and previous pages again. */
gdata_query_next_page (query);
query_uri = gdata_query_get_query_uri (query, "http://example.com/");
g_assert_cmpstr (query_uri, ==, "http://example.com/?q=test&start-index=50&max-results=10");
g_free (query_uri);
g_assert (gdata_query_previous_page (query) == TRUE);
query_uri = gdata_query_get_query_uri (query, "http://example.com/");
g_assert_cmpstr (query_uri, ==, "http://example.com/?q=test&start-index=40&max-results=10");
g_free (query_uri);
g_assert (gdata_query_previous_page (query) == TRUE);
query_uri = gdata_query_get_query_uri (query, "http://example.com/");
g_assert_cmpstr (query_uri, ==, "http://example.com/?q=test&start-index=30&max-results=10");
g_free (query_uri);
g_object_unref (query);
}
static void
notify_cb (GObject *obj, GParamSpec *pspec, gpointer user_data)
{
gboolean *notification_received = user_data;
g_assert (*notification_received == FALSE);
*notification_received = TRUE;
}
static void
test_query_properties (void)
{
GDataQuery *query;
gboolean notification_received = FALSE;
gulong handler_id;
query = gdata_query_new ("default");
#define CHECK_PROPERTY(cmptype, name_hyphens, name_underscores, default_val, new_val, new_val2, val_type, free_val) \
{ \
val_type val; \
\
handler_id = g_signal_connect (query, "notify::" name_hyphens, (GCallback) notify_cb, ¬ification_received); \
\
g_assert_##cmptype (gdata_query_get_##name_underscores (query), ==, default_val); \
g_object_get (query, name_hyphens, &val, NULL); \
g_assert_##cmptype (val, ==, default_val); \
if (free_val == TRUE) { \
g_free ((gpointer) ((guintptr) val)); \
} \
\
notification_received = FALSE; \
gdata_query_set_##name_underscores (query, new_val); \
g_assert (notification_received == TRUE); \
\
g_assert_##cmptype (gdata_query_get_##name_underscores (query), ==, new_val); \
\
notification_received = FALSE; \
g_object_set (query, name_hyphens, (val_type) new_val2, NULL); \
g_assert (notification_received == TRUE); \
\
g_assert_##cmptype (gdata_query_get_##name_underscores (query), ==, new_val2); \
\
g_signal_handler_disconnect (query, handler_id); \
}
#define CHECK_PROPERTY_STR(name_hyphens, name_underscores, default_val) \
CHECK_PROPERTY (cmpstr, name_hyphens, name_underscores, default_val, "new", "new2", gchar*, TRUE)
#define CHECK_PROPERTY_INT64(name_hyphens, name_underscores, default_val) \
CHECK_PROPERTY (cmpint, name_hyphens, name_underscores, default_val, 123, 5134132, gint64, FALSE)
#define CHECK_PROPERTY_UINT(name_hyphens, name_underscores, default_val) \
CHECK_PROPERTY (cmpuint, name_hyphens, name_underscores, default_val, 535, 123, guint, FALSE)
#define CHECK_PROPERTY_BOOLEAN(name_hyphens, name_underscores, default_val) \
CHECK_PROPERTY (cmpuint, name_hyphens, name_underscores, default_val, TRUE, FALSE, gboolean, FALSE)
CHECK_PROPERTY_STR ("q", q, "default");
CHECK_PROPERTY_STR ("categories", categories, NULL);
CHECK_PROPERTY_STR ("author", author, NULL);
CHECK_PROPERTY_INT64 ("updated-min", updated_min, -1);
CHECK_PROPERTY_INT64 ("updated-max", updated_max, -1);
CHECK_PROPERTY_INT64 ("published-min", published_min, -1);
CHECK_PROPERTY_INT64 ("published-max", published_max, -1);
CHECK_PROPERTY_UINT ("start-index", start_index, 0);
#define gdata_query_get_is_strict gdata_query_is_strict
CHECK_PROPERTY_BOOLEAN ("is-strict", is_strict, FALSE);
#undef gdata_query_get_is_strict
CHECK_PROPERTY_UINT ("max-results", max_results, 0);
CHECK_PROPERTY_STR ("etag", etag, NULL);
#undef CHECK_PROPERTY_BOOLEAN
#undef CHECK_PROPERTY_UINT
#undef CHECK_PROPERTY_INT64
#undef CHECK_PROPERTY_STR
#undef CHECK_PROPERTY
g_object_unref (query);
}
static void
test_query_unicode (void)
{
GDataQuery *query;
gchar *query_uri;
g_test_bug ("602497");
/* Simple query */
query = gdata_query_new ("fööbar‽");
query_uri = gdata_query_get_query_uri (query, "http://example.com");
g_assert_cmpstr (query_uri, ==, "http://example.com?q=f%C3%B6%C3%B6bar%E2%80%BD");
g_free (query_uri);
/* Categories */
gdata_query_set_categories (query, "Ümlauts|¿Questions‽");
query_uri = gdata_query_get_query_uri (query, "http://example.com");
g_assert_cmpstr (query_uri, ==, "http://example.com/-/%C3%9Cmlauts%7C%C2%BFQuestions%E2%80%BD?q=f%C3%B6%C3%B6bar%E2%80%BD");
g_free (query_uri);
/* Author */
gdata_query_set_author (query, "Lørd Brïan Bleßêd");
query_uri = gdata_query_get_query_uri (query, "http://example.com");
g_assert_cmpstr (query_uri, ==, "http://example.com/-/%C3%9Cmlauts%7C%C2%BFQuestions%E2%80%BD?q=f%C3%B6%C3%B6bar%E2%80%BD&author=L%C3%B8rd%20Br%C3%AFan%20Ble%C3%9F%C3%AAd");
g_free (query_uri);
g_object_unref (query);
}
static void
test_query_etag (void)
{
GDataQuery *query = gdata_query_new (NULL);
/* Test that setting any property will unset the ETag */
g_test_bug ("613529");
/* Also check that setting the ETag doesn't unset the ETag! */
gdata_query_set_etag (query, "foobar");
g_assert_cmpstr (gdata_query_get_etag (query), ==, "foobar");
#define CHECK_ETAG(C) \
gdata_query_set_etag (query, "foobar"); \
C; \
g_assert (gdata_query_get_etag (query) == NULL);
CHECK_ETAG (gdata_query_set_q (query, "q"))
CHECK_ETAG (gdata_query_set_categories (query, "shizzle,foobar"))
CHECK_ETAG (gdata_query_set_author (query, "John Smith"))
CHECK_ETAG (gdata_query_set_updated_min (query, -1))
CHECK_ETAG (gdata_query_set_updated_max (query, -1))
CHECK_ETAG (gdata_query_set_published_min (query, -1))
CHECK_ETAG (gdata_query_set_published_max (query, -1))
CHECK_ETAG (gdata_query_set_start_index (query, 5))
CHECK_ETAG (gdata_query_set_is_strict (query, TRUE))
CHECK_ETAG (gdata_query_set_max_results (query, 1000))
CHECK_ETAG (gdata_query_next_page (query))
CHECK_ETAG (g_assert (gdata_query_previous_page (query)))
#undef CHECK_ETAG
g_object_unref (query);
}
static void
test_service_network_error (void)
{
GDataService *service;
#if 0
SoupURI *proxy_uri;
#endif
GError *error = NULL;
/* This is a little hacky, but it should work */
service = g_object_new (GDATA_TYPE_SERVICE, NULL);
/* Try a query which should always fail due to errors resolving the hostname */
g_assert (gdata_service_query (service, NULL, "https://thisshouldnotexist.invalid", NULL, GDATA_TYPE_ENTRY,
NULL, NULL, NULL, &error) == NULL);
g_assert_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_NETWORK_ERROR);
g_clear_error (&error);
/* TODO: We have to disable this test, as libsoup 2.30.2 < x <= 2.32.0 doesn't return SOUP_STATUS_CANT_RESOLVE_PROXY properly any more.
* Filed as bgo#632354. */
#if 0
/* Try one with a bad proxy set */
proxy_uri = soup_uri_new ("https://thisshouldalsonotexist.invalid/proxy");
gdata_service_set_proxy_uri (service, proxy_uri);
soup_uri_free (proxy_uri);
g_assert (gdata_service_query (service, "https://google.com", NULL, GDATA_TYPE_ENTRY, NULL, NULL, NULL, &error) == NULL);
g_assert_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROXY_ERROR);
g_clear_error (&error);
#endif
g_object_unref (service);
}
static void
test_service_locale (void)
{
GDataService *service;
gchar *locale;
/* This is a little hacky, but it should work */
service = g_object_new (GDATA_TYPE_SERVICE, NULL);
/* Just test setting and getting the locale */
g_assert (gdata_service_get_locale (service) == NULL);
gdata_service_set_locale (service, "en_GB");
g_assert_cmpstr (gdata_service_get_locale (service), ==, "en_GB");
g_object_get (service, "locale", &locale, NULL);
g_assert_cmpstr (locale, ==, "en_GB");
g_free (locale);
g_object_unref (service);
}
static void
test_access_rule_get_xml (void)
{
GDataAccessRule *rule, *rule2;
const gchar *content_type;
gchar *xml, *role, *scope_type3, *scope_value3, *key;
gint64 edited, edited2;
const gchar *scope_type, *scope_value, *scope_type2, *scope_value2;
GError *error = NULL;
rule = gdata_access_rule_new ("an-id");
/* Test setting properties directly */
g_object_set (G_OBJECT (rule),
"role", "A role",
"scope-type", "A scope type",
"scope-value", "A scope value",
NULL);
g_assert_cmpstr (gdata_access_rule_get_role (rule), ==, "A role");
gdata_access_rule_get_scope (rule, &scope_type, &scope_value);
g_assert_cmpstr (scope_type, ==, "A scope type");
g_assert_cmpstr (scope_value, ==, "A scope value");
edited = gdata_access_rule_get_edited (rule);
g_assert_cmpuint (edited, >, 0); /* current time */
g_assert_cmpstr (gdata_access_rule_get_key (rule), ==, NULL);
/* Set the properties more conventionally */
gdata_access_rule_set_role (rule, GDATA_ACCESS_ROLE_NONE);
gdata_access_rule_set_scope (rule, GDATA_ACCESS_SCOPE_USER, "foo@example.com");
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (rule));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the generated XML's OK */
gdata_test_assert_xml (rule,
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' "
"xmlns:gd='http://schemas.google.com/g/2005' "
"xmlns:gAcl='http://schemas.google.com/acl/2007'>"
"<title type='text'>none</title>"
"<id>an-id</id>"
"<category term='http://schemas.google.com/acl/2007#accessRule' scheme='http://schemas.google.com/g/2005#kind'/>"
"<gAcl:role value='none'/>"
"<gAcl:scope type='user' value='foo@example.com'/>"
"</entry>");
/* Check again by re-parsing the XML to a GDataAccessRule */
xml = gdata_parsable_get_xml (GDATA_PARSABLE (rule));
rule2 = GDATA_ACCESS_RULE (gdata_parsable_new_from_xml (GDATA_TYPE_ACCESS_RULE, xml, -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_ACCESS_RULE (rule2));
g_clear_error (&error);
g_free (xml);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (rule2));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
g_assert_cmpstr (gdata_access_rule_get_role (rule), ==, gdata_access_rule_get_role (rule2));
gdata_access_rule_get_scope (rule, &scope_type, &scope_value);
gdata_access_rule_get_scope (rule2, &scope_type2, &scope_value2);
g_assert_cmpstr (scope_type, ==, scope_type2);
g_assert_cmpstr (scope_value, ==, scope_value2);
edited = gdata_access_rule_get_edited (rule2);
g_assert_cmpuint (edited, ==, -1); /* unspecified in XML */
g_assert_cmpstr (gdata_access_rule_get_key (rule), ==, gdata_access_rule_get_key (rule2));
/* Check properties a different way */
g_object_get (G_OBJECT (rule2),
"role", &role,
"scope-type", &scope_type3,
"scope-value", &scope_value3,
"edited", &edited2,
"key", &key,
NULL);
g_assert_cmpstr (role, ==, gdata_access_rule_get_role (rule));
g_assert_cmpstr (scope_type, ==, scope_type3);
g_assert_cmpstr (scope_value, ==, scope_value3);
g_assert_cmpuint (edited2, ==, -1);
g_assert_cmpstr (key, ==, NULL);
g_free (role);
g_free (scope_type3);
g_free (scope_value3);
/* Test that the GDataAccessRule:role and GDataEntry:title properties are linked */
gdata_entry_set_title (GDATA_ENTRY (rule), "Another role");
g_assert_cmpstr (gdata_access_rule_get_role (rule), ==, "Another role");
gdata_access_rule_set_role (rule, GDATA_ACCESS_ROLE_NONE);
g_assert_cmpstr (gdata_entry_get_title (GDATA_ENTRY (rule)), ==, "none");
g_object_unref (rule);
g_object_unref (rule2);
/* Check that a rule with scope type 'default' doesn't have a value.
* See: https://developers.google.com/google-apps/calendar/v2/reference#gacl_reference */
rule = gdata_access_rule_new ("another-id");
gdata_access_rule_set_role (rule, GDATA_ACCESS_ROLE_NONE);
gdata_access_rule_set_scope (rule, GDATA_ACCESS_SCOPE_DEFAULT, NULL);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (rule));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the generated XML's OK */
gdata_test_assert_xml (rule,
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' "
"xmlns:gd='http://schemas.google.com/g/2005' "
"xmlns:gAcl='http://schemas.google.com/acl/2007'>"
"<title type='text'>none</title>"
"<id>another-id</id>"
"<category term='http://schemas.google.com/acl/2007#accessRule' scheme='http://schemas.google.com/g/2005#kind'/>"
"<gAcl:role value='none'/>"
"<gAcl:scope type='default'/>"
"</entry>");
/* Check by re-parsing the XML to a GDataAccessRule */
xml = gdata_parsable_get_xml (GDATA_PARSABLE (rule));
rule2 = GDATA_ACCESS_RULE (gdata_parsable_new_from_xml (GDATA_TYPE_ACCESS_RULE, xml, -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_ACCESS_RULE (rule2));
g_clear_error (&error);
g_free (xml);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (rule2));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
g_assert_cmpstr (gdata_access_rule_get_role (rule), ==, gdata_access_rule_get_role (rule2));
gdata_access_rule_get_scope (rule, &scope_type, &scope_value);
gdata_access_rule_get_scope (rule2, &scope_type2, &scope_value2);
g_assert_cmpstr (scope_type, ==, scope_type2);
g_assert_cmpstr (scope_value, ==, scope_value2);
edited = gdata_access_rule_get_edited (rule2);
g_assert_cmpuint (edited, ==, -1); /* unspecified in XML */
g_object_unref (rule);
g_object_unref (rule2);
}
static void
test_access_rule_get_xml_with_key (void)
{
GDataAccessRule *rule;
gint64 edited;
const gchar *content_type, *scope_type, *scope_value;
GError *error = NULL;
rule = GDATA_ACCESS_RULE (gdata_parsable_new_from_xml (GDATA_TYPE_ACCESS_RULE,
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' "
"xmlns:gd='http://schemas.google.com/g/2005' "
"xmlns:gAcl='http://schemas.google.com/acl/2007'>"
"<title type='text'>none</title>"
"<id>an-id</id>"
"<category term='http://schemas.google.com/acl/2007#accessRule' scheme='http://schemas.google.com/g/2005#kind'/>"
"<gAcl:withKey key='asdasd'><gAcl:role value='none'/></gAcl:withKey>"
"<gAcl:scope type='user' value='foo@example.com'/>"
"</entry>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_ACCESS_RULE (rule));
/* Check the properties. */
g_assert_cmpstr (gdata_access_rule_get_role (rule), ==, "none");
gdata_access_rule_get_scope (rule, &scope_type, &scope_value);
g_assert_cmpstr (scope_type, ==, "user");
g_assert_cmpstr (scope_value, ==, "foo@example.com");
edited = gdata_access_rule_get_edited (rule);
g_assert_cmpuint (edited, >, 0); /* current time */
g_assert_cmpstr (gdata_access_rule_get_key (rule), ==, "asdasd");
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (rule));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same. */
gdata_test_assert_xml (rule,
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' "
"xmlns:gd='http://schemas.google.com/g/2005' "
"xmlns:gAcl='http://schemas.google.com/acl/2007'>"
"<title type='text'>none</title>"
"<id>an-id</id>"
"<category term='http://schemas.google.com/acl/2007#accessRule' scheme='http://schemas.google.com/g/2005#kind'/>"
"<gAcl:withKey key='asdasd'><gAcl:role value='none'/></gAcl:withKey>"
"<gAcl:scope type='user' value='foo@example.com'/>"
"</entry>");
g_object_unref (rule);
}
static void
test_access_rule_error_handling (void)
{
GDataAccessRule *rule;
GError *error = NULL;
#define TEST_XML_ERROR_HANDLING(x) rule = GDATA_ACCESS_RULE (gdata_parsable_new_from_xml (GDATA_TYPE_ACCESS_RULE,\
"<entry xmlns='http://www.w3.org/2005/Atom' xmlns:app='http://www.w3.org/2007/app' xmlns:gAcl='http://schemas.google.com/acl/2007'>"\
x\
"</entry>", -1, &error));\
g_assert_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR);\
g_assert (rule == NULL);\
g_clear_error (&error)
/* role */
TEST_XML_ERROR_HANDLING ("<gAcl:role/>"); /* missing value */
/* scope */
TEST_XML_ERROR_HANDLING ("<gAcl:scope/>"); /* missing type */
TEST_XML_ERROR_HANDLING ("<gAcl:scope type='user'/>"); /* missing value */
TEST_XML_ERROR_HANDLING ("<gAcl:scope type='domain'/>"); /* missing value */
/* edited */
TEST_XML_ERROR_HANDLING ("<app:edited/>"); /* missing date */
TEST_XML_ERROR_HANDLING ("<app:edited>not a date</app:edited>"); /* bad date */
/* withKey */
TEST_XML_ERROR_HANDLING ("<gAcl:withKey><gAcl:role value='none'/></gAcl:withKey>"); /* missing key */
TEST_XML_ERROR_HANDLING ("<gAcl:withKey key='asd'/>"); /* missing role */
TEST_XML_ERROR_HANDLING ("<gAcl:withKey key='asd'><gAcl:role/></gAcl:withKey>"); /* missing role */
#undef TEST_XML_ERROR_HANDLING
}
static void
test_access_rule_escaping (void)
{
GDataAccessRule *rule;
rule = gdata_access_rule_new (NULL);
gdata_access_rule_set_role (rule, "<role>");
gdata_access_rule_set_scope (rule, "<scope>", "<value>");
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (rule,
"<?xml version='1.0' encoding='UTF-8'?>"
"<entry xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' "
"xmlns:gAcl='http://schemas.google.com/acl/2007'>"
"<title type='text'><role></title>"
"<category term='http://schemas.google.com/acl/2007#accessRule' scheme='http://schemas.google.com/g/2005#kind'/>"
"<gAcl:role value='<role>'/>"
"<gAcl:scope type='<scope>' value='<value>'/>"
"</entry>");
g_object_unref (rule);
}
static void
test_comparable (void)
{
GDataComparable *category = GDATA_COMPARABLE (gdata_category_new ("term", "http://scheme", "label"));
/* Test the NULL comparisons */
g_assert_cmpint (gdata_comparable_compare (category, NULL), ==, 1);
g_assert_cmpint (gdata_comparable_compare (NULL, category), ==, -1);
g_assert_cmpint (gdata_comparable_compare (NULL, NULL), ==, 0);
g_assert_cmpint (gdata_comparable_compare (category, category), ==, 0);
g_object_unref (category);
}
static void
test_color_parsing (void)
{
GDataColor color;
/* With hash */
g_assert (gdata_color_from_hexadecimal ("#F99Ff0", &color) == TRUE);
g_assert_cmpuint (color.red, ==, 249);
g_assert_cmpuint (color.green, ==, 159);
g_assert_cmpuint (color.blue, ==, 240);
/* Without hash */
g_assert (gdata_color_from_hexadecimal ("F99Ff0", &color) == TRUE);
g_assert_cmpuint (color.red, ==, 249);
g_assert_cmpuint (color.green, ==, 159);
g_assert_cmpuint (color.blue, ==, 240);
/* Invalid, but correct length */
g_assert (gdata_color_from_hexadecimal ("foobar", &color) == FALSE);
/* Wildly invalid */
g_assert (gdata_color_from_hexadecimal ("this is not a real colour!", &color) == FALSE);
}
static void
test_color_output (void)
{
GDataColor color;
gchar *color_string;
/* General test */
g_assert (gdata_color_from_hexadecimal ("#F99Ff0", &color) == TRUE);
color_string = gdata_color_to_hexadecimal (&color);
g_assert_cmpstr (color_string, ==, "#f99ff0");
g_free (color_string);
/* Boundary tests */
g_assert (gdata_color_from_hexadecimal ("#ffffff", &color) == TRUE);
color_string = gdata_color_to_hexadecimal (&color);
g_assert_cmpstr (color_string, ==, "#ffffff");
g_free (color_string);
g_assert (gdata_color_from_hexadecimal ("#000000", &color) == TRUE);
color_string = gdata_color_to_hexadecimal (&color);
g_assert_cmpstr (color_string, ==, "#000000");
g_free (color_string);
}
/*static void
test_media_thumbnail_parse_time (const gchar *locale)
{
g_test_bug ("584737");
g_test_message ("Testing gdata_media_thumbnail_parse_time in the \"%s\" locale...", locale);
g_assert_cmpstr (setlocale (LC_ALL, locale), ==, locale);
g_assert_cmpint (gdata_media_thumbnail_parse_time ("00:01:42.500"), ==, 102500);
g_assert_cmpint (gdata_media_thumbnail_parse_time ("00:02:45"), ==, 165000);
g_assert_cmpint (gdata_media_thumbnail_parse_time ("12:00:15.000"), ==, 43215000);
g_assert_cmpint (gdata_media_thumbnail_parse_time ("00:00:00"), ==, 0);
g_assert_cmpint (gdata_media_thumbnail_parse_time ("foobar"), ==, -1);
setlocale (LC_ALL, "");
}*/
static void
test_atom_author (void)
{
GDataAuthor *author, *author2;
const gchar *content_type;
gchar *name, *uri, *email_address;
GError *error = NULL;
author = GDATA_AUTHOR (gdata_parsable_new_from_xml (GDATA_TYPE_AUTHOR,
"<author>"
"<name>John Smöth</name>"
"<uri>http://example.com/</uri>"
"<email>john@example.com</email>"
"</author>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_AUTHOR (author));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_author_get_name (author), ==, "John Smöth");
g_assert_cmpstr (gdata_author_get_uri (author), ==, "http://example.com/");
g_assert_cmpstr (gdata_author_get_email_address (author), ==, "john@example.com");
/* Compare it against another identical author */
author2 = gdata_author_new ("John Smöth", "http://example.com/", "john@example.com");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (author), GDATA_COMPARABLE (author2)), ==, 0);
g_object_unref (author2);
/* …and a different author */
author2 = gdata_author_new ("Brian Blessed", NULL, NULL);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (author), GDATA_COMPARABLE (author2)), !=, 0);
g_object_unref (author2);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (author));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (author,
"<?xml version='1.0' encoding='UTF-8'?>"
"<author xmlns='http://www.w3.org/2005/Atom'>"
"<name>John Smöth</name>"
"<uri>http://example.com/</uri>"
"<email>john@example.com</email>"
"</author>");
/* Check the properties */
g_object_get (G_OBJECT (author),
"name", &name,
"uri", &uri,
"email-address", &email_address,
NULL);
g_assert_cmpstr (name, ==, "John Smöth");
g_assert_cmpstr (uri, ==, "http://example.com/");
g_assert_cmpstr (email_address, ==, "john@example.com");
g_free (name);
g_free (uri);
g_free (email_address);
g_object_unref (author);
/* Now parse an author with little information available */
author = GDATA_AUTHOR (gdata_parsable_new_from_xml (GDATA_TYPE_AUTHOR,
"<author>"
"<name>James Johnson</name>"
"</author>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_AUTHOR (author));
g_clear_error (&error);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (author));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the properties */
g_assert_cmpstr (gdata_author_get_name (author), ==, "James Johnson");
g_assert (gdata_author_get_uri (author) == NULL);
g_assert (gdata_author_get_email_address (author) == NULL);
g_object_unref (author);
}
static void
test_atom_author_error_handling (void)
{
GDataAuthor *author;
GError *error = NULL;
#define TEST_XML_ERROR_HANDLING(x) author = GDATA_AUTHOR (gdata_parsable_new_from_xml (GDATA_TYPE_AUTHOR,\
"<author>"\
x\
"</author>", -1, &error));\
g_assert_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR);\
g_assert (author == NULL);\
g_clear_error (&error)
/* name */
TEST_XML_ERROR_HANDLING ("<name>John Smöth</name><name>Not John Smöth</name>"); /* duplicated name */
TEST_XML_ERROR_HANDLING ("<name></name>"); /* empty name */
TEST_XML_ERROR_HANDLING ("<uri>http://example.com/</uri><email>john@example.com</email>"); /* missing name */
/* uri */
TEST_XML_ERROR_HANDLING ("<uri>http://example.com/</uri><uri>http://another-example.com/</uri>"); /* duplicated URI */
/* email */
TEST_XML_ERROR_HANDLING ("<email>john@example.com</email><email>john@another-example.com</email>"); /* duplicated e-mail address */
#undef TEST_XML_ERROR_HANDLING
}
static void
test_atom_author_escaping (void)
{
GDataAuthor *author;
author = gdata_author_new ("First & Last Name", "http://foo.com?foo&bar", "John Smith <john.smith@gmail.com>");
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (author,
"<?xml version='1.0' encoding='UTF-8'?>"
"<author xmlns='http://www.w3.org/2005/Atom'>"
"<name>First & Last Name</name>"
"<uri>http://foo.com?foo&bar</uri>"
"<email>John Smith <john.smith@gmail.com></email>"
"</author>");
g_object_unref (author);
}
static void
test_atom_category (void)
{
GDataCategory *category, *category2;
const gchar *content_type;
gchar *term, *scheme, *label;
GError *error = NULL;
category = GDATA_CATEGORY (gdata_parsable_new_from_xml (GDATA_TYPE_CATEGORY,
"<category term='jokes' scheme='http://foobar.com#categories' label='Jokes & Trivia'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_CATEGORY (category));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_category_get_term (category), ==, "jokes");
g_assert_cmpstr (gdata_category_get_scheme (category), ==, "http://foobar.com#categories");
g_assert_cmpstr (gdata_category_get_label (category), ==, "Jokes & Trivia");
/* Compare it against another identical category */
category2 = gdata_category_new ("jokes", "http://foobar.com#categories", "Jokes & Trivia");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (category), GDATA_COMPARABLE (category2)), ==, 0);
g_object_unref (category2);
/* …and a different category */
category2 = gdata_category_new ("sports", "http://foobar.com#categories", NULL);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (category), GDATA_COMPARABLE (category2)), !=, 0);
g_object_unref (category2);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (category));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (category,
"<?xml version='1.0' encoding='UTF-8'?>"
"<category xmlns='http://www.w3.org/2005/Atom' "
"term='jokes' scheme='http://foobar.com#categories' label='Jokes & Trivia'/>");
/* Check the properties */
g_object_get (G_OBJECT (category),
"term", &term,
"scheme", &scheme,
"label", &label,
NULL);
g_assert_cmpstr (term, ==, "jokes");
g_assert_cmpstr (scheme, ==, "http://foobar.com#categories");
g_assert_cmpstr (label, ==, "Jokes & Trivia");
g_free (term);
g_free (scheme);
g_free (label);
g_object_unref (category);
/* Now parse a category with less information available */
category = GDATA_CATEGORY (gdata_parsable_new_from_xml (GDATA_TYPE_CATEGORY,
"<category term='sports'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_CATEGORY (category));
g_clear_error (&error);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (category));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the properties */
g_assert_cmpstr (gdata_category_get_term (category), ==, "sports");
g_assert (gdata_category_get_scheme (category) == NULL);
g_assert (gdata_category_get_label (category) == NULL);
g_object_unref (category);
/* Try a category with custom content */
category = GDATA_CATEGORY (gdata_parsable_new_from_xml (GDATA_TYPE_CATEGORY,
"<category term='documentary'>"
"<foobar/>"
"<shizzle/>"
"</category>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_CATEGORY (category));
g_clear_error (&error);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (category));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML contains the unknown XML */
gdata_test_assert_xml (category,
"<?xml version='1.0' encoding='UTF-8'?>"
"<category xmlns='http://www.w3.org/2005/Atom' term='documentary'>"
"<foobar/>"
"<shizzle/>"
"</category>");
g_object_unref (category);
}
static void
test_atom_category_error_handling (void)
{
GDataCategory *category;
GError *error = NULL;
/* Missing term */
category = GDATA_CATEGORY (gdata_parsable_new_from_xml (GDATA_TYPE_CATEGORY, "<category/>", -1, &error));
g_assert_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR);
g_assert (category == NULL);
g_clear_error (&error);
}
static void
test_atom_category_escaping (void)
{
GDataCategory *category;
category = gdata_category_new ("<term>", "http://foo.com?foo&bar", "Label & Stuff");
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (category,
"<?xml version='1.0' encoding='UTF-8'?>"
"<category xmlns='http://www.w3.org/2005/Atom' term='<term>' scheme='http://foo.com?foo&bar' "
"label='Label & Stuff'/>");
g_object_unref (category);
}
static void
test_atom_generator (void)
{
GDataGenerator *generator, *generator2;
const gchar *content_type;
gchar *name, *uri, *version;
GError *error = NULL;
generator = GDATA_GENERATOR (gdata_parsable_new_from_xml (GDATA_TYPE_GENERATOR,
"<generator uri='http://example.com/' version='15'>Bach & Son's Generator</generator>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GENERATOR (generator));
g_clear_error (&error);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (generator));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Compare it against another identical generator */
generator2 = GDATA_GENERATOR (gdata_parsable_new_from_xml (GDATA_TYPE_GENERATOR,
"<generator uri='http://example.com/' version='15'>Bach & Son's Generator</generator>", -1, NULL));
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (generator), GDATA_COMPARABLE (generator2)), ==, 0);
g_object_unref (generator2);
/* …and a different generator */
generator2 = GDATA_GENERATOR (gdata_parsable_new_from_xml (GDATA_TYPE_GENERATOR,
"<generator>Different generator</generator>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GENERATOR (generator));
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (generator), GDATA_COMPARABLE (generator2)), !=, 0);
g_object_unref (generator2);
/* Check the properties */
g_assert_cmpstr (gdata_generator_get_name (generator), ==, "Bach & Son's Generator");
g_assert_cmpstr (gdata_generator_get_uri (generator), ==, "http://example.com/");
g_assert_cmpstr (gdata_generator_get_version (generator), ==, "15");
/* Check them a different way too */
g_object_get (G_OBJECT (generator),
"name", &name,
"uri", &uri,
"version", &version,
NULL);
g_assert_cmpstr (name, ==, "Bach & Son's Generator");
g_assert_cmpstr (uri, ==, "http://example.com/");
g_assert_cmpstr (version, ==, "15");
g_free (name);
g_free (uri);
g_free (version);
g_object_unref (generator);
/* Now parse a generator with less information available */
generator = GDATA_GENERATOR (gdata_parsable_new_from_xml (GDATA_TYPE_GENERATOR,
"<generator/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GENERATOR (generator));
g_clear_error (&error);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (generator));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the properties */
g_assert (gdata_generator_get_name (generator) == NULL);
g_assert (gdata_generator_get_uri (generator) == NULL);
g_assert (gdata_generator_get_version (generator) == NULL);
g_object_unref (generator);
}
static void
test_atom_generator_error_handling (void)
{
GDataGenerator *generator;
GError *error = NULL;
/* Empty URI */
generator = GDATA_GENERATOR (gdata_parsable_new_from_xml (GDATA_TYPE_GENERATOR, "<generator uri=''/>", -1, &error));
g_assert_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR);
g_assert (generator == NULL);
g_clear_error (&error);
}
static void
test_atom_link (void)
{
GDataLink *link1, *link2;
gchar *uri, *relation_type, *content_type, *language, *title;
gint length;
GError *error = NULL;
link1 = GDATA_LINK (gdata_parsable_new_from_xml (GDATA_TYPE_LINK,
"<link href='http://example.com/' rel='http://test.com#link-type' type='text/plain' hreflang='de' "
"title='All About Angle Brackets: <, >' length='2000'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_LINK (link1));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_link_get_uri (link1), ==, "http://example.com/");
g_assert_cmpstr (gdata_link_get_relation_type (link1), ==, "http://test.com#link-type");
g_assert_cmpstr (gdata_link_get_content_type (link1), ==, "text/plain");
g_assert_cmpstr (gdata_link_get_language (link1), ==, "de");
g_assert_cmpstr (gdata_link_get_title (link1), ==, "All About Angle Brackets: <, >");
g_assert_cmpint (gdata_link_get_length (link1), ==, 2000);
/* Compare it against another identical link */
link2 = gdata_link_new ("http://example.com/", "http://test.com#link-type");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (link1), GDATA_COMPARABLE (link2)), ==, 0);
gdata_link_set_content_type (link2, "text/plain");
gdata_link_set_language (link2, "de");
gdata_link_set_title (link2, "All About Angle Brackets: <, >");
gdata_link_set_length (link2, 2000);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (link1), GDATA_COMPARABLE (link2)), ==, 0);
/* Try with a dissimilar link */
gdata_link_set_uri (link2, "http://gnome.org/");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (link1), GDATA_COMPARABLE (link2)), !=, 0);
g_object_unref (link2);
g_assert_cmpstr (gdata_parsable_get_content_type (GDATA_PARSABLE (link1)), ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (link1,
"<?xml version='1.0' encoding='UTF-8'?>"
"<link xmlns='http://www.w3.org/2005/Atom' href='http://example.com/' title='All About Angle Brackets: <, >' "
"rel='http://test.com#link-type' type='text/plain' hreflang='de' length='2000'/>");
/* Set some of the properties */
g_object_set (G_OBJECT (link1),
"uri", "http://another-example.com/",
"relation-type", "http://test.com#link-type2",
"content-type", "text/html",
"language", "sv",
"title", "This & That About <Angle Brackets>",
"length", -1,
NULL);
/* Check the properties */
g_object_get (G_OBJECT (link1),
"uri", &uri,
"relation-type", &relation_type,
"content-type", &content_type,
"language", &language,
"title", &title,
"length", &length,
NULL);
g_assert_cmpstr (uri, ==, "http://another-example.com/");
g_assert_cmpstr (relation_type, ==, "http://test.com#link-type2");
g_assert_cmpstr (content_type, ==, "text/html");
g_assert_cmpstr (language, ==, "sv");
g_assert_cmpstr (title, ==, "This & That About <Angle Brackets>");
g_assert_cmpint (length, ==, -1);
g_free (uri);
g_free (relation_type);
g_free (content_type);
g_free (language);
g_free (title);
g_object_unref (link1);
/* Now parse a link with less information available */
link1 = GDATA_LINK (gdata_parsable_new_from_xml (GDATA_TYPE_LINK,
"<link href='http://shizzle.com'>Test Content<foobar/></link>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_LINK (link1));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_link_get_uri (link1), ==, "http://shizzle.com");
g_assert_cmpstr (gdata_link_get_relation_type (link1), ==, "http://www.iana.org/assignments/relation/alternate");
g_assert (gdata_link_get_content_type (link1) == NULL);
g_assert (gdata_link_get_language (link1) == NULL);
g_assert (gdata_link_get_title (link1) == NULL);
g_assert (gdata_link_get_length (link1) == -1);
g_assert_cmpstr (gdata_parsable_get_content_type (GDATA_PARSABLE (link1)), ==, "application/atom+xml");
/* Check the outputted XML contains the unknown XML */
gdata_test_assert_xml (link1,
"<?xml version='1.0' encoding='UTF-8'?>"
"<link xmlns='http://www.w3.org/2005/Atom' href='http://shizzle.com' rel='http://www.iana.org/assignments/relation/alternate'>"
"Test Content<foobar/></link>");
g_object_unref (link1);
}
static void
test_atom_link_error_handling (void)
{
GDataLink *_link; /* stupid unistd.h */
GError *error = NULL;
#define TEST_XML_ERROR_HANDLING(x) _link = GDATA_LINK (gdata_parsable_new_from_xml (GDATA_TYPE_LINK,\
"<link " x "/>", -1, &error));\
g_assert_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR);\
g_assert (_link == NULL);\
g_clear_error (&error)
/* href */
TEST_XML_ERROR_HANDLING (""); /* missing href */
TEST_XML_ERROR_HANDLING ("href=''"); /* empty href */
/* rel */
TEST_XML_ERROR_HANDLING ("href='http://example.com/' rel=''"); /* empty rel */
/* type */
TEST_XML_ERROR_HANDLING ("href='http://example.com/' type=''"); /* empty type */
/* hreflang */
TEST_XML_ERROR_HANDLING ("href='http://example.com/' hreflang=''"); /* empty hreflang */
#undef TEST_XML_ERROR_HANDLING
}
static void
test_atom_link_escaping (void)
{
GDataLink *_link;
_link = gdata_link_new ("http://foo.com?foo&bar", "http://foo.com?foo&relation=bar");
gdata_link_set_content_type (_link, "<content type>");
gdata_link_set_language (_link, "<language>");
gdata_link_set_title (_link, "Title & stuff");
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (_link,
"<?xml version='1.0' encoding='UTF-8'?>"
"<link xmlns='http://www.w3.org/2005/Atom' href='http://foo.com?foo&bar' title='Title & stuff' "
"rel='http://foo.com?foo&relation=bar' type='<content type>' hreflang='<language>'/>");
g_object_unref (_link);
}
static void
test_app_categories (void)
{
GDataAPPCategories *categories;
GList *_categories;
gboolean fixed;
const gchar *content_type;
GError *error = NULL;
categories = GDATA_APP_CATEGORIES (gdata_parsable_new_from_json (GDATA_TYPE_APP_CATEGORIES,
"{"
"'kind': 'youtube#videoCategoryListResponse',"
"'etag': '\"tbWC5XrSXxe1WOAx6MK9z4hHSU8/1v2mrzYSYG6onNLt2qTj13hkQZk\"',"
"'items': ["
"{"
"'kind': 'youtube#videoCategory',"
"'etag': '\"tbWC5XrSXxe1WOAx6MK9z4hHSU8/Xy1mB4_yLrHy_BmKmPBggty2mZQ\"',"
"'id': '1',"
"'snippet': {"
"'channelId': 'UCBR8-60-B28hp2BmDPdntcQ',"
"'title': 'Film & Animation',"
"'assignable': true"
"}"
"},"
"{"
"'kind': 'youtube#videoCategory',"
"'etag': '\"tbWC5XrSXxe1WOAx6MK9z4hHSU8/UZ1oLIIz2dxIhO45ZTFR3a3NyTA\"',"
"'id': '2',"
"'snippet': {"
"'channelId': 'UCBR8-60-B28hp2BmDPdntcQ',"
"'title': 'Autos & Vehicles',"
"'assignable': true"
"}"
"}"
"]"
"}", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_APP_CATEGORIES (categories));
g_clear_error (&error);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (categories));
g_assert_cmpstr (content_type, ==, "application/json");
/* Check the properties */
g_assert (gdata_app_categories_is_fixed (categories) == FALSE);
/* Check them a different way too */
g_object_get (G_OBJECT (categories), "is-fixed", &fixed, NULL);
g_assert (fixed == FALSE);
/* Check the categories and scheme inheritance */
_categories = gdata_app_categories_get_categories (categories);
g_assert_cmpint (g_list_length (_categories), ==, 2);
g_assert (GDATA_IS_CATEGORY (_categories->data));
g_assert_cmpstr (gdata_category_get_scheme (GDATA_CATEGORY (_categories->data)), ==, NULL);
g_assert_cmpstr (gdata_category_get_label (GDATA_CATEGORY (_categories->data)), ==, "Film & Animation");
g_assert (GDATA_IS_CATEGORY (_categories->next->data));
g_assert_cmpstr (gdata_category_get_scheme (GDATA_CATEGORY (_categories->next->data)), ==, NULL);
g_assert_cmpstr (gdata_category_get_label (GDATA_CATEGORY (_categories->next->data)), ==, "Autos & Vehicles");
g_object_unref (categories);
/* Now parse one with less information available */
categories = GDATA_APP_CATEGORIES (gdata_parsable_new_from_json (GDATA_TYPE_APP_CATEGORIES,
"{"
"'kind': 'youtube#videoCategoryListResponse',"
"'items': []"
"}", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_APP_CATEGORIES (categories));
g_clear_error (&error);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (categories));
g_assert_cmpstr (content_type, ==, "application/json");
/* Check the properties */
g_assert (gdata_app_categories_is_fixed (categories) == FALSE);
g_object_unref (categories);
}
static void
test_gd_email_address (void)
{
GDataGDEmailAddress *email, *email2;
GError *error = NULL;
const gchar *content_type;
email = GDATA_GD_EMAIL_ADDRESS (gdata_parsable_new_from_xml (GDATA_TYPE_GD_EMAIL_ADDRESS,
"<gd:email xmlns:gd='http://schemas.google.com/g/2005' label='Personal & Private' rel='http://schemas.google.com/g/2005#home' "
"address='fubar@gmail.com' primary='true' displayName='<John Smith>'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_EMAIL_ADDRESS (email));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gd_email_address_get_address (email), ==, "fubar@gmail.com");
g_assert_cmpstr (gdata_gd_email_address_get_relation_type (email), ==, GDATA_GD_EMAIL_ADDRESS_HOME);
g_assert_cmpstr (gdata_gd_email_address_get_label (email), ==, "Personal & Private");
g_assert_cmpstr (gdata_gd_email_address_get_display_name (email), ==, "<John Smith>");
g_assert (gdata_gd_email_address_is_primary (email) == TRUE);
/* Compare it against another identical address */
email2 = gdata_gd_email_address_new ("fubar@gmail.com", GDATA_GD_EMAIL_ADDRESS_HOME, "Personal & Private", TRUE);
gdata_gd_email_address_set_display_name (email2, "<John Smith>");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (email), GDATA_COMPARABLE (email2)), ==, 0);
/* …and a different one */
gdata_gd_email_address_set_address (email2, "test@example.com");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (email), GDATA_COMPARABLE (email2)), !=, 0);
g_object_unref (email2);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (email));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (email,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:email xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' address='fubar@gmail.com' "
"rel='http://schemas.google.com/g/2005#home' label='Personal & Private' displayName='<John Smith>' "
"primary='true'/>");
g_object_unref (email);
/* Now parse an address with less information available */
email = GDATA_GD_EMAIL_ADDRESS (gdata_parsable_new_from_xml (GDATA_TYPE_GD_EMAIL_ADDRESS,
"<gd:email xmlns:gd='http://schemas.google.com/g/2005' address='test@example.com'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_EMAIL_ADDRESS (email));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gd_email_address_get_address (email), ==, "test@example.com");
g_assert (gdata_gd_email_address_get_relation_type (email) == NULL);
g_assert (gdata_gd_email_address_get_label (email) == NULL);
g_assert (gdata_gd_email_address_get_display_name (email) == NULL);
g_assert (gdata_gd_email_address_is_primary (email) == FALSE);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (email));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML contains the unknown XML */
gdata_test_assert_xml (email,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:email xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' address='test@example.com' "
"primary='false'/>");
g_object_unref (email);
}
static void
test_gd_email_address_escaping (void)
{
GDataGDEmailAddress *email;
g_test_bug ("630350");
email = gdata_gd_email_address_new ("Fubar <fubar@gmail.com>", GDATA_GD_EMAIL_ADDRESS_HOME "?foo&bar", "Personal & Private", TRUE);
gdata_gd_email_address_set_display_name (email, "<John Smith>");
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (email,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:email xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' "
"address='Fubar <fubar@gmail.com>' rel='http://schemas.google.com/g/2005#home?foo&bar' "
"label='Personal & Private' displayName='<John Smith>' primary='true'/>");
g_object_unref (email);
}
static void
test_gd_email_address_comparison (void)
{
GDataGDEmailAddress *email1, *email2;
/* Should only compare equal if addresses are equal. */
email1 = gdata_gd_email_address_new ("foo@example.com", NULL, NULL, TRUE);
email2 = gdata_gd_email_address_new ("foo@example.com", NULL, "label", FALSE);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (email1), GDATA_COMPARABLE (email2)), ==, 0);
gdata_gd_email_address_set_address (email1, "bar@example.com");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (email1), GDATA_COMPARABLE (email2)), !=, 0);
g_object_unref (email2);
g_object_unref (email1);
}
static void
test_gd_im_address (void)
{
GDataGDIMAddress *im, *im2;
GError *error = NULL;
const gchar *content_type;
im = GDATA_GD_IM_ADDRESS (gdata_parsable_new_from_xml (GDATA_TYPE_GD_IM_ADDRESS,
"<gd:im xmlns:gd='http://schemas.google.com/g/2005' protocol='http://schemas.google.com/g/2005#MSN' address='foo@bar.msn.com' "
"rel='http://schemas.google.com/g/2005#home' primary='true'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_IM_ADDRESS (im));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gd_im_address_get_address (im), ==, "foo@bar.msn.com");
g_assert_cmpstr (gdata_gd_im_address_get_protocol (im), ==, GDATA_GD_IM_PROTOCOL_LIVE_MESSENGER);
g_assert_cmpstr (gdata_gd_im_address_get_relation_type (im), ==, GDATA_GD_IM_ADDRESS_HOME);
g_assert (gdata_gd_im_address_get_label (im) == NULL);
g_assert (gdata_gd_im_address_is_primary (im) == TRUE);
/* Compare it against another identical address */
im2 = gdata_gd_im_address_new ("foo@bar.msn.com", GDATA_GD_IM_PROTOCOL_LIVE_MESSENGER, GDATA_GD_IM_ADDRESS_HOME, NULL, TRUE);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (im), GDATA_COMPARABLE (im2)), ==, 0);
/* …and a different one */
gdata_gd_im_address_set_protocol (im2, GDATA_GD_IM_PROTOCOL_GOOGLE_TALK);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (im), GDATA_COMPARABLE (im2)), !=, 0);
g_object_unref (im2);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (im));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (im,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:im xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' "
"address='foo@bar.msn.com' protocol='http://schemas.google.com/g/2005#MSN' "
"rel='http://schemas.google.com/g/2005#home' primary='true'/>");
g_object_unref (im);
/* Now parse an address with less information available */
im = GDATA_GD_IM_ADDRESS (gdata_parsable_new_from_xml (GDATA_TYPE_GD_IM_ADDRESS,
"<gd:im xmlns:gd='http://schemas.google.com/g/2005' label='Other & Miscellaneous' address='foo@baz.example.com'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_IM_ADDRESS (im));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gd_im_address_get_address (im), ==, "foo@baz.example.com");
g_assert (gdata_gd_im_address_get_protocol (im) == NULL);
g_assert (gdata_gd_im_address_get_relation_type (im) == NULL);
g_assert_cmpstr (gdata_gd_im_address_get_label (im), ==, "Other & Miscellaneous");
g_assert (gdata_gd_im_address_is_primary (im) == FALSE);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (im));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML contains the unknown XML */
gdata_test_assert_xml (im,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:im xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' address='foo@baz.example.com' "
"label='Other & Miscellaneous' primary='false'/>");
g_object_unref (im);
}
static void
test_gd_im_address_escaping (void)
{
GDataGDIMAddress *im;
im = gdata_gd_im_address_new ("Fubar <fubar@gmail.com>", GDATA_GD_IM_PROTOCOL_GOOGLE_TALK "?foo&bar", GDATA_GD_IM_ADDRESS_HOME "?foo&bar",
"Personal & Private", TRUE);
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (im,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:im xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' "
"address='Fubar <fubar@gmail.com>' protocol='http://schemas.google.com/g/2005#GOOGLE_TALK?foo&bar' "
"rel='http://schemas.google.com/g/2005#home?foo&bar' label='Personal & Private' primary='true'/>");
g_object_unref (im);
}
static void
test_gd_im_address_comparison (void)
{
GDataGDIMAddress *im_address1, *im_address2;
/* Should only compare equal if address and protocol are both equal. */
im_address1 = gdata_gd_im_address_new ("foo@example.com", GDATA_GD_IM_PROTOCOL_LIVE_MESSENGER, NULL, NULL, TRUE);
im_address2 = gdata_gd_im_address_new ("foo@example.com", GDATA_GD_IM_PROTOCOL_LIVE_MESSENGER, NULL, "label", FALSE);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (im_address1), GDATA_COMPARABLE (im_address2)), ==, 0);
/* Different addresses, same protocol. */
gdata_gd_im_address_set_address (im_address1, "bar@example.com");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (im_address1), GDATA_COMPARABLE (im_address2)), !=, 0);
/* Same address, different protocols. */
gdata_gd_im_address_set_address (im_address1, "foo@example.com");
gdata_gd_im_address_set_protocol (im_address1, GDATA_GD_IM_PROTOCOL_JABBER);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (im_address1), GDATA_COMPARABLE (im_address2)), !=, 0);
g_object_unref (im_address2);
g_object_unref (im_address1);
}
static void
test_gd_name (void)
{
GDataGDName *name, *name2;
GError *error = NULL;
const gchar *content_type;
name = GDATA_GD_NAME (gdata_parsable_new_from_xml (GDATA_TYPE_GD_NAME,
"<gd:name xmlns:gd='http://schemas.google.com/g/2005'>"
"<gd:givenName>Brian</gd:givenName>"
"<gd:additionalName>Charles</gd:additionalName>"
"<gd:familyName>Blessed</gd:familyName>"
"<gd:namePrefix>Mr</gd:namePrefix>"
"<gd:nameSuffix>ABC</gd:nameSuffix>"
"<gd:fullName>Mr Brian Charles Blessed, ABC</gd:fullName>"
"</gd:name>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_NAME (name));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gd_name_get_given_name (name), ==, "Brian");
g_assert_cmpstr (gdata_gd_name_get_additional_name (name), ==, "Charles");
g_assert_cmpstr (gdata_gd_name_get_family_name (name), ==, "Blessed");
g_assert_cmpstr (gdata_gd_name_get_prefix (name), ==, "Mr");
g_assert_cmpstr (gdata_gd_name_get_suffix (name), ==, "ABC");
g_assert_cmpstr (gdata_gd_name_get_full_name (name), ==, "Mr Brian Charles Blessed, ABC");
/* Compare it against another identical name */
name2 = gdata_gd_name_new ("Brian", "Blessed");
gdata_gd_name_set_additional_name (name2, "Charles");
gdata_gd_name_set_prefix (name2, "Mr");
gdata_gd_name_set_suffix (name2, "ABC");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (name), GDATA_COMPARABLE (name2)), ==, 0);
/* …and a different one */
gdata_gd_name_set_prefix (name2, "Mrs");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (name), GDATA_COMPARABLE (name2)), !=, 0);
g_object_unref (name2);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (name));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (name,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:name xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005'>"
"<gd:givenName>Brian</gd:givenName>"
"<gd:additionalName>Charles</gd:additionalName>"
"<gd:familyName>Blessed</gd:familyName>"
"<gd:namePrefix>Mr</gd:namePrefix>"
"<gd:nameSuffix>ABC</gd:nameSuffix>"
"<gd:fullName>Mr Brian Charles Blessed, ABC</gd:fullName>"
"</gd:name>");
g_object_unref (name);
/* Now parse an address with less information available */
name = GDATA_GD_NAME (gdata_parsable_new_from_xml (GDATA_TYPE_GD_NAME,
"<gd:name xmlns:gd='http://schemas.google.com/g/2005'><gd:givenName>Bob</gd:givenName></gd:name>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_NAME (name));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gd_name_get_given_name (name), ==, "Bob");
g_assert (gdata_gd_name_get_additional_name (name) == NULL);
g_assert (gdata_gd_name_get_family_name (name) == NULL);
g_assert (gdata_gd_name_get_prefix (name) == NULL);
g_assert (gdata_gd_name_get_suffix (name) == NULL);
g_assert (gdata_gd_name_get_full_name (name) == NULL);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (name));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is still correct */
gdata_test_assert_xml (name,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:name xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005'>"
"<gd:givenName>Bob</gd:givenName>"
"</gd:name>");
g_object_unref (name);
}
static void
test_gd_name_empty_strings (void)
{
GDataGDName *name;
GError *error = NULL;
g_test_bug ("662290");
/* Test that empty full names get treated as NULL correctly. */
name = GDATA_GD_NAME (gdata_parsable_new_from_xml (GDATA_TYPE_GD_NAME,
"<gd:name xmlns:gd='http://schemas.google.com/g/2005'>"
"<gd:fullName></gd:fullName>"
"</gd:name>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_NAME (name));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gd_name_get_given_name (name), ==, NULL);
g_assert_cmpstr (gdata_gd_name_get_additional_name (name), ==, NULL);
g_assert_cmpstr (gdata_gd_name_get_family_name (name), ==, NULL);
g_assert_cmpstr (gdata_gd_name_get_prefix (name), ==, NULL);
g_assert_cmpstr (gdata_gd_name_get_suffix (name), ==, NULL);
g_assert_cmpstr (gdata_gd_name_get_full_name (name), ==, NULL);
g_object_unref (name);
/* Build a name with an empty string full name and check the serialisation */
name = gdata_gd_name_new ("Georgey", "Porgey");
gdata_gd_name_set_full_name (name, "");
g_assert_cmpstr (gdata_gd_name_get_full_name (name), ==, NULL);
/* Check the outputted XML is the same */
gdata_test_assert_xml (name,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:name xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005'>"
"<gd:givenName>Georgey</gd:givenName>"
"<gd:familyName>Porgey</gd:familyName>"
"</gd:name>");
g_object_unref (name);
}
static void
test_gd_name_comparison (void)
{
GDataGDName *name1, *name2;
/* Names are only equal if the given, additional and family names are all equal, and the prefixes are equal too. */
name1 = gdata_gd_name_new ("Given", "Family");
gdata_gd_name_set_additional_name (name1, "Additional");
gdata_gd_name_set_prefix (name1, "Mrs");
name2 = gdata_gd_name_new ("Given", "Family");
gdata_gd_name_set_additional_name (name2, "Additional");
gdata_gd_name_set_prefix (name2, "Mrs");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (name1), GDATA_COMPARABLE (name2)), ==, 0);
/* Different given names. */
gdata_gd_name_set_given_name (name1, "Different");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (name1), GDATA_COMPARABLE (name2)), !=, 0);
/* Different additional names. */
gdata_gd_name_set_given_name (name1, "Given");
gdata_gd_name_set_additional_name (name1, "Different");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (name1), GDATA_COMPARABLE (name2)), !=, 0);
/* Different family names. */
gdata_gd_name_set_additional_name (name1, "Additional");
gdata_gd_name_set_family_name (name1, "Different");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (name1), GDATA_COMPARABLE (name2)), !=, 0);
/* Different prefixes. */
gdata_gd_name_set_family_name (name1, "Family");
gdata_gd_name_set_prefix (name1, "Mr");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (name1), GDATA_COMPARABLE (name2)), !=, 0);
g_object_unref (name2);
g_object_unref (name1);
}
static void
test_gd_organization (void)
{
GDataGDOrganization *org, *org2;
GDataGDWhere *location;
GError *error = NULL;
const gchar *content_type;
org = GDATA_GD_ORGANIZATION (gdata_parsable_new_from_xml (GDATA_TYPE_GD_ORGANIZATION,
"<gd:organization xmlns:gd='http://schemas.google.com/g/2005' rel='http://schemas.google.com/g/2005#work' label='Work & Occupation' "
"primary='true'>"
"<gd:orgName>Google, Inc.</gd:orgName>"
"<gd:orgTitle><Angle Bracketeer></gd:orgTitle>"
"<gd:orgDepartment>Finance</gd:orgDepartment>"
"<gd:orgJobDescription>Doing stuff.</gd:orgJobDescription>"
"<gd:orgSymbol>FOO</gd:orgSymbol>"
"<gd:where valueString='Test location'/>"
"</gd:organization>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_ORGANIZATION (org));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gd_organization_get_name (org), ==, "Google, Inc.");
g_assert_cmpstr (gdata_gd_organization_get_title (org), ==, "<Angle Bracketeer>");
g_assert_cmpstr (gdata_gd_organization_get_relation_type (org), ==, GDATA_GD_ORGANIZATION_WORK);
g_assert_cmpstr (gdata_gd_organization_get_label (org), ==, "Work & Occupation");
g_assert_cmpstr (gdata_gd_organization_get_department (org), ==, "Finance");
g_assert_cmpstr (gdata_gd_organization_get_job_description (org), ==, "Doing stuff.");
g_assert_cmpstr (gdata_gd_organization_get_symbol (org), ==, "FOO");
location = gdata_gd_organization_get_location (org);
g_assert (GDATA_IS_GD_WHERE (location));
g_assert (gdata_gd_organization_is_primary (org) == TRUE);
/* Compare it against another identical organization */
org2 = gdata_gd_organization_new ("Google, Inc.", "<Angle Bracketeer>", GDATA_GD_ORGANIZATION_WORK, "Work & Occupation", TRUE);
gdata_gd_organization_set_department (org2, "Finance");
gdata_gd_organization_set_location (org2, location);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (org), GDATA_COMPARABLE (org2)), ==, 0);
/* …and a different one */
gdata_gd_organization_set_title (org2, "Demoted!");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (org), GDATA_COMPARABLE (org2)), !=, 0);
g_object_unref (org2);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (org));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (org,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:organization xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' "
"rel='http://schemas.google.com/g/2005#work' label='Work & Occupation' primary='true'>"
"<gd:orgName>Google, Inc.</gd:orgName>"
"<gd:orgTitle><Angle Bracketeer></gd:orgTitle>"
"<gd:orgDepartment>Finance</gd:orgDepartment>"
"<gd:orgJobDescription>Doing stuff.</gd:orgJobDescription>"
"<gd:orgSymbol>FOO</gd:orgSymbol>"
"<gd:where valueString='Test location'/>"
"</gd:organization>");
g_object_unref (org);
/* Now parse an organization with less information available */
org = GDATA_GD_ORGANIZATION (gdata_parsable_new_from_xml (GDATA_TYPE_GD_ORGANIZATION,
"<gd:organization xmlns:gd='http://schemas.google.com/g/2005'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_ORGANIZATION (org));
g_clear_error (&error);
/* Check the properties */
g_assert (gdata_gd_organization_get_name (org) == NULL);
g_assert (gdata_gd_organization_get_title (org) == NULL);
g_assert (gdata_gd_organization_get_relation_type (org) == NULL);
g_assert (gdata_gd_organization_get_label (org) == NULL);
g_assert (gdata_gd_organization_is_primary (org) == FALSE);
g_assert (gdata_gd_organization_get_department (org) == NULL);
g_assert (gdata_gd_organization_get_job_description (org) == NULL);
g_assert (gdata_gd_organization_get_symbol (org) == NULL);
g_assert (gdata_gd_organization_get_location (org) == NULL);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (org));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML contains the unknown XML */
gdata_test_assert_xml (org,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:organization xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' primary='false'/>");
g_object_unref (org);
}
static void
test_gd_organization_escaping (void)
{
GDataGDOrganization *org;
org = gdata_gd_organization_new ("Steptoe & Son", "Title & Stuff", GDATA_GD_ORGANIZATION_WORK "?foo&bar", "Personal & Private", TRUE);
gdata_gd_organization_set_department (org, "Department & Stuff");
gdata_gd_organization_set_job_description (org, "Escaping <brackets>.");
gdata_gd_organization_set_symbol (org, "<&>");
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (org,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:organization xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' "
"rel='http://schemas.google.com/g/2005#work?foo&bar' label='Personal & Private' primary='true'>"
"<gd:orgName>Steptoe & Son</gd:orgName>"
"<gd:orgTitle>Title & Stuff</gd:orgTitle>"
"<gd:orgDepartment>Department & Stuff</gd:orgDepartment>"
"<gd:orgJobDescription>Escaping <brackets>.</gd:orgJobDescription>"
"<gd:orgSymbol><&></gd:orgSymbol>"
"</gd:organization>");
g_object_unref (org);
}
static void
test_gd_organization_comparison (void)
{
GDataGDOrganization *org1, *org2;
/* Organisation positions are equal if the name, title and department are all equal. */
org1 = gdata_gd_organization_new ("Name", "Title", NULL, NULL, TRUE);
gdata_gd_organization_set_department (org1, "Department");
org2 = gdata_gd_organization_new ("Name", "Title", NULL, "label", FALSE);
gdata_gd_organization_set_department (org2, "Department");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (org1), GDATA_COMPARABLE (org2)), ==, 0);
/* Different name. */
gdata_gd_organization_set_name (org1, "Different");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (org1), GDATA_COMPARABLE (org2)), !=, 0);
/* Different title. */
gdata_gd_organization_set_name (org1, "Name");
gdata_gd_organization_set_title (org1, "Different");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (org1), GDATA_COMPARABLE (org2)), !=, 0);
/* Different department. */
gdata_gd_organization_set_title (org1, "Title");
gdata_gd_organization_set_department (org1, "Different");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (org1), GDATA_COMPARABLE (org2)), !=, 0);
g_object_unref (org2);
g_object_unref (org1);
}
static void
test_gd_phone_number (void)
{
GDataGDPhoneNumber *phone, *phone2;
GError *error = NULL;
const gchar *content_type;
phone = GDATA_GD_PHONE_NUMBER (gdata_parsable_new_from_xml (GDATA_TYPE_GD_PHONE_NUMBER,
"<gd:phoneNumber xmlns:gd='http://schemas.google.com/g/2005' rel='http://schemas.google.com/g/2005#mobile' "
"label='Personal & business calls only' uri='tel:+12065551212'>+1 206 555 1212</gd:phoneNumber>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_PHONE_NUMBER (phone));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gd_phone_number_get_number (phone), ==, "+1 206 555 1212");
g_assert_cmpstr (gdata_gd_phone_number_get_uri (phone), ==, "tel:+12065551212");
g_assert_cmpstr (gdata_gd_phone_number_get_relation_type (phone), ==, GDATA_GD_PHONE_NUMBER_MOBILE);
g_assert_cmpstr (gdata_gd_phone_number_get_label (phone), ==, "Personal & business calls only");
g_assert (gdata_gd_phone_number_is_primary (phone) == FALSE);
/* Compare it against another identical number */
phone2 = gdata_gd_phone_number_new ("+1 206 555 1212", GDATA_GD_PHONE_NUMBER_MOBILE, "Personal & business calls only",
"tel:+12065551212", FALSE);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (phone), GDATA_COMPARABLE (phone2)), ==, 0);
/* …and a different one */
gdata_gd_phone_number_set_number (phone2, "+1 206 555 1212 666");
gdata_gd_phone_number_set_uri (phone2, NULL);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (phone), GDATA_COMPARABLE (phone2)), !=, 0);
g_object_unref (phone2);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (phone));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (phone,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:phoneNumber xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' "
"uri='tel:+12065551212' rel='http://schemas.google.com/g/2005#mobile' label='Personal & business calls only' "
"primary='false'>+1 206 555 1212</gd:phoneNumber>");
/* Check we trim whitespace properly, and respect Unicode characters */
gdata_gd_phone_number_set_number (phone, " 0123456 (789) ëxt 300 ");
g_assert_cmpstr (gdata_gd_phone_number_get_number (phone), ==, "0123456 (789) ëxt 300");
g_object_unref (phone);
/* Now parse a phone number with less information available, but some extraneous whitespace */
phone = GDATA_GD_PHONE_NUMBER (gdata_parsable_new_from_xml (GDATA_TYPE_GD_PHONE_NUMBER,
"<gd:phoneNumber xmlns:gd='http://schemas.google.com/g/2005'> (425) 555-8080 ext. 72585 \n </gd:phoneNumber>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_PHONE_NUMBER (phone));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gd_phone_number_get_number (phone), ==, "(425) 555-8080 ext. 72585");
g_assert (gdata_gd_phone_number_get_uri (phone) == NULL);
g_assert (gdata_gd_phone_number_get_relation_type (phone) == NULL);
g_assert (gdata_gd_phone_number_get_label (phone) == NULL);
g_assert (gdata_gd_phone_number_is_primary (phone) == FALSE);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (phone));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML contains the unknown XML */
gdata_test_assert_xml (phone,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:phoneNumber xmlns='http://www.w3.org/2005/Atom' "
"xmlns:gd='http://schemas.google.com/g/2005' primary='false'>(425) 555-8080 ext. 72585</gd:phoneNumber>");
g_object_unref (phone);
}
static void
test_gd_phone_number_escaping (void)
{
GDataGDPhoneNumber *phone;
phone = gdata_gd_phone_number_new ("0123456789 <54>", GDATA_GD_PHONE_NUMBER_WORK_MOBILE "?foo&bar", "Personal & Private",
"tel:+012345678954?foo&bar", TRUE);
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (phone,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:phoneNumber xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' "
"uri='tel:+012345678954?foo&bar' rel='http://schemas.google.com/g/2005#work_mobile?foo&bar' "
"label='Personal & Private' primary='true'>0123456789 <54></gd:phoneNumber>");
g_object_unref (phone);
}
static void
test_gd_phone_number_comparison (void)
{
GDataGDPhoneNumber *phone1, *phone2;
/* Phone numbers are equal if the number or the URI matches (NULL URIs cannot match). */
phone1 = gdata_gd_phone_number_new ("123", NULL, NULL, "phone://123", TRUE);
phone2 = gdata_gd_phone_number_new ("123", NULL, "label", "phone://123", FALSE);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (phone1), GDATA_COMPARABLE (phone2)), ==, 0);
/* Same numbers, different URIs. */
gdata_gd_phone_number_set_uri (phone1, "phone://+44123");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (phone1), GDATA_COMPARABLE (phone2)), ==, 0);
/* Different numbers, same URIs. */
gdata_gd_phone_number_set_uri (phone1, "phone://123");
gdata_gd_phone_number_set_number (phone1, "+44123");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (phone1), GDATA_COMPARABLE (phone2)), ==, 0);
/* Different numbers and URIs. */
gdata_gd_phone_number_set_number (phone1, "456");
gdata_gd_phone_number_set_uri (phone1, "phone://456");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (phone1), GDATA_COMPARABLE (phone2)), !=, 0);
/* Different numbers, NULL URIs. */
gdata_gd_phone_number_set_uri (phone1, NULL);
gdata_gd_phone_number_set_uri (phone2, NULL);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (phone1), GDATA_COMPARABLE (phone2)), !=, 0);
/* Same numbers, NULL URIs. */
gdata_gd_phone_number_set_number (phone1, "123");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (phone1), GDATA_COMPARABLE (phone2)), ==, 0);
g_object_unref (phone2);
g_object_unref (phone1);
}
static void
test_gd_postal_address (void)
{
GDataGDPostalAddress *postal, *postal2;
GError *error = NULL;
const gchar *content_type;
postal = GDATA_GD_POSTAL_ADDRESS (gdata_parsable_new_from_xml (GDATA_TYPE_GD_POSTAL_ADDRESS,
"<gd:structuredPostalAddress xmlns:gd='http://schemas.google.com/g/2005' label='Home & Safe House' "
"rel='http://schemas.google.com/g/2005#home' primary='true'>"
"<gd:street>500 West 45th Street</gd:street>"
"<gd:city>New York</gd:city>"
"<gd:postcode>NY 10036</gd:postcode>"
"<gd:country code='US'>United States</gd:country>"
"</gd:structuredPostalAddress>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_POSTAL_ADDRESS (postal));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gd_postal_address_get_street (postal), ==, "500 West 45th Street");
g_assert_cmpstr (gdata_gd_postal_address_get_city (postal), ==, "New York");
g_assert_cmpstr (gdata_gd_postal_address_get_postcode (postal), ==, "NY 10036");
g_assert_cmpstr (gdata_gd_postal_address_get_relation_type (postal), ==, GDATA_GD_POSTAL_ADDRESS_HOME);
g_assert_cmpstr (gdata_gd_postal_address_get_label (postal), ==, "Home & Safe House");
g_assert_cmpstr (gdata_gd_postal_address_get_country (postal), ==, "United States");
g_assert_cmpstr (gdata_gd_postal_address_get_country_code (postal), ==, "US");
g_assert (gdata_gd_postal_address_is_primary (postal) == TRUE);
/* Compare it against another identical address */
postal2 = gdata_gd_postal_address_new (GDATA_GD_POSTAL_ADDRESS_HOME, "Home & Safe House", TRUE);
gdata_gd_postal_address_set_street (postal2, "500 West 45th Street");
gdata_gd_postal_address_set_city (postal2, "New York");
gdata_gd_postal_address_set_postcode (postal2, "NY 10036");
gdata_gd_postal_address_set_country (postal2, "United States", "US");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (postal), GDATA_COMPARABLE (postal2)), ==, 0);
/* …and a different one */
gdata_gd_postal_address_set_city (postal2, "Atlas Mountains");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (postal), GDATA_COMPARABLE (postal2)), !=, 0);
g_object_unref (postal2);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (postal));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (postal,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:structuredPostalAddress xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' "
"rel='http://schemas.google.com/g/2005#home' label='Home & Safe House' primary='true'>"
"<gd:street>500 West 45th Street</gd:street>"
"<gd:city>New York</gd:city>"
"<gd:postcode>NY 10036</gd:postcode>"
"<gd:country code='US'>United States</gd:country>"
"</gd:structuredPostalAddress>");
/* Check we trim whitespace properly, and respect Unicode characters */
gdata_gd_postal_address_set_address (postal, " Schöne Grüße Straße\nGermany ");
g_assert_cmpstr (gdata_gd_postal_address_get_address (postal), ==, "Schöne Grüße Straße\nGermany");
g_object_unref (postal);
/* Now parse an address with less information available */
postal = GDATA_GD_POSTAL_ADDRESS (gdata_parsable_new_from_xml (GDATA_TYPE_GD_POSTAL_ADDRESS,
"<gd:structuredPostalAddress xmlns:gd='http://schemas.google.com/g/2005'><gd:street>f</gd:street></gd:structuredPostalAddress>",
-1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_POSTAL_ADDRESS (postal));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gd_postal_address_get_street (postal), ==, "f");
g_assert (gdata_gd_postal_address_get_relation_type (postal) == NULL);
g_assert (gdata_gd_postal_address_get_label (postal) == NULL);
g_assert (gdata_gd_postal_address_is_primary (postal) == FALSE);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (postal));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML contains the unknown XML */
gdata_test_assert_xml (postal,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:structuredPostalAddress xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' primary='false'>"
"<gd:street>f</gd:street></gd:structuredPostalAddress>");
g_object_unref (postal);
}
static void
test_gd_postal_address_escaping (void)
{
GDataGDPostalAddress *address;
address = gdata_gd_postal_address_new (GDATA_GD_POSTAL_ADDRESS_WORK "?foo&bar", "Personal & Private", TRUE);
gdata_gd_postal_address_set_address (address, "<address>");
gdata_gd_postal_address_set_mail_class (address, GDATA_GD_MAIL_CLASS_BOTH "?foo&bar");
gdata_gd_postal_address_set_usage (address, GDATA_GD_ADDRESS_USAGE_GENERAL "?foo&bar");
gdata_gd_postal_address_set_agent (address, "<agent>");
gdata_gd_postal_address_set_house_name (address, "House & House");
gdata_gd_postal_address_set_street (address, "Church & Main Street");
gdata_gd_postal_address_set_po_box (address, "<515>");
gdata_gd_postal_address_set_neighborhood (address, "<neighbourhood>");
gdata_gd_postal_address_set_city (address, "City <17>");
gdata_gd_postal_address_set_subregion (address, "Subregion <5>");
gdata_gd_postal_address_set_region (address, "<region>");
gdata_gd_postal_address_set_postcode (address, "Postcode & stuff");
gdata_gd_postal_address_set_country (address, "<foo>", "<bar>");
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (address,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:structuredPostalAddress xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' "
"rel='http://schemas.google.com/g/2005#work?foo&bar' label='Personal & Private' "
"mailClass='http://schemas.google.com/g/2005#both?foo&bar' "
"usage='http://schemas.google.com/g/2005#general?foo&bar' primary='true'>"
"<gd:agent><agent></gd:agent>"
"<gd:housename>House & House</gd:housename>"
"<gd:street>Church & Main Street</gd:street>"
"<gd:pobox><515></gd:pobox>"
"<gd:neighborhood><neighbourhood></gd:neighborhood>"
"<gd:city>City <17></gd:city>"
"<gd:subregion>Subregion <5></gd:subregion>"
"<gd:region><region></gd:region>"
"<gd:postcode>Postcode & stuff</gd:postcode>"
"<gd:country code='<bar>'><foo></gd:country>"
"<gd:formattedAddress><address></gd:formattedAddress>"
"</gd:structuredPostalAddress>");
g_object_unref (address);
}
static void
test_gd_postal_address_comparison (void)
{
GDataGDPostalAddress *address1, *address2;
/* Postal addresses compare equal if the street, city, PO box and postcode are all equal. */
address1 = gdata_gd_postal_address_new (NULL, NULL, TRUE);
gdata_gd_postal_address_set_street (address1, "Street");
gdata_gd_postal_address_set_city (address1, "City");
gdata_gd_postal_address_set_po_box (address1, "PO box");
gdata_gd_postal_address_set_postcode (address1, "Postcode");
address2 = gdata_gd_postal_address_new (NULL, "label", FALSE);
gdata_gd_postal_address_set_street (address2, "Street");
gdata_gd_postal_address_set_city (address2, "City");
gdata_gd_postal_address_set_po_box (address2, "PO box");
gdata_gd_postal_address_set_postcode (address2, "Postcode");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (address1), GDATA_COMPARABLE (address2)), ==, 0);
/* Different streets. */
gdata_gd_postal_address_set_street (address1, "Different");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (address1), GDATA_COMPARABLE (address2)), !=, 0);
/* Different cities. */
gdata_gd_postal_address_set_street (address1, "Street");
gdata_gd_postal_address_set_city (address1, "Different");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (address1), GDATA_COMPARABLE (address2)), !=, 0);
/* Different PO box. */
gdata_gd_postal_address_set_city (address1, "City");
gdata_gd_postal_address_set_po_box (address1, "Different");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (address1), GDATA_COMPARABLE (address2)), !=, 0);
/* Different postcode. */
gdata_gd_postal_address_set_po_box (address1, "PO box");
gdata_gd_postal_address_set_postcode (address1, "Different");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (address1), GDATA_COMPARABLE (address2)), !=, 0);
g_object_unref (address2);
g_object_unref (address1);
}
static void
test_gd_reminder (void)
{
GDataGDReminder *reminder, *reminder2;
gint64 _time;
GError *error = NULL;
const gchar *content_type;
reminder = GDATA_GD_REMINDER (gdata_parsable_new_from_xml (GDATA_TYPE_GD_REMINDER,
"<gd:reminder xmlns:gd='http://schemas.google.com/g/2005' days='15'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_REMINDER (reminder));
g_clear_error (&error);
/* Check the properties */
g_assert (gdata_gd_reminder_get_method (reminder) == NULL);
g_assert (gdata_gd_reminder_is_absolute_time (reminder) == FALSE);
g_assert_cmpint (gdata_gd_reminder_get_relative_time (reminder), ==, 15 * 24 * 60);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (reminder));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML */
gdata_test_assert_xml (reminder,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:reminder xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' minutes='21600'/>");
g_object_unref (reminder);
/* Try again with a different property */
reminder = GDATA_GD_REMINDER (gdata_parsable_new_from_xml (GDATA_TYPE_GD_REMINDER,
"<gd:reminder xmlns:gd='http://schemas.google.com/g/2005' hours='15'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_REMINDER (reminder));
g_clear_error (&error);
/* Check the properties */
g_assert (gdata_gd_reminder_get_method (reminder) == NULL);
g_assert (gdata_gd_reminder_is_absolute_time (reminder) == FALSE);
g_assert_cmpint (gdata_gd_reminder_get_relative_time (reminder), ==, 15 * 60);
/* Compare to another reminder */
reminder2 = gdata_gd_reminder_new (NULL, -1, 15 * 60);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (reminder), GDATA_COMPARABLE (reminder2)), ==, 0);
g_object_unref (reminder2);
g_object_unref (reminder);
/* …and another */
reminder = GDATA_GD_REMINDER (gdata_parsable_new_from_xml (GDATA_TYPE_GD_REMINDER,
"<gd:reminder xmlns:gd='http://schemas.google.com/g/2005' minutes='15'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_REMINDER (reminder));
g_clear_error (&error);
/* Check the properties */
g_assert (gdata_gd_reminder_get_method (reminder) == NULL);
g_assert (gdata_gd_reminder_is_absolute_time (reminder) == FALSE);
g_assert_cmpint (gdata_gd_reminder_get_relative_time (reminder), ==, 15);
g_object_unref (reminder);
/* Try again with an absolute time and a method */
reminder = GDATA_GD_REMINDER (gdata_parsable_new_from_xml (GDATA_TYPE_GD_REMINDER,
"<gd:reminder xmlns:gd='http://schemas.google.com/g/2005' method='alert' absoluteTime='2005-06-06T16:55:00-08:00'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_REMINDER (reminder));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gd_reminder_get_method (reminder), ==, GDATA_GD_REMINDER_ALERT);
g_assert (gdata_gd_reminder_is_absolute_time (reminder) == TRUE);
_time = gdata_gd_reminder_get_absolute_time (reminder);
g_assert_cmpint (_time, ==, 1118105700);
/* Compare to another reminder */
reminder2 = gdata_gd_reminder_new (GDATA_GD_REMINDER_ALERT, _time, -1);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (reminder), GDATA_COMPARABLE (reminder2)), ==, 0);
g_object_unref (reminder2);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (reminder));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML */
gdata_test_assert_xml (reminder,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:reminder xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' "
"absoluteTime='2005-06-07T00:55:00Z' method='alert'/>");
g_object_unref (reminder);
}
static void
test_gd_reminder_escaping (void)
{
GDataGDReminder *reminder;
reminder = gdata_gd_reminder_new (GDATA_GD_REMINDER_ALERT "?foo&bar", -1, 15);
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (reminder,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:reminder xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' "
"minutes='15' method='alert?foo&bar'/>");
g_object_unref (reminder);
}
static void
test_gd_reminder_comparison (void)
{
GDataGDReminder *reminder1, *reminder2;
#define ASSERT_COMPARISON(op) \
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (reminder1), GDATA_COMPARABLE (reminder2)), op, 0)
/* Check for equality. */
reminder1 = gdata_gd_reminder_new (GDATA_GD_REMINDER_ALERT, -1, 15);
reminder2 = gdata_gd_reminder_new (GDATA_GD_REMINDER_ALERT, -1, 15);
ASSERT_COMPARISON(==);
/* Different methods, same time type, same time. */
gdata_gd_reminder_set_method (reminder1, GDATA_GD_REMINDER_SMS);
ASSERT_COMPARISON(>);
/* Same method, different time type, same time. */
gdata_gd_reminder_set_method (reminder1, GDATA_GD_REMINDER_ALERT);
gdata_gd_reminder_set_relative_time (reminder1, -1);
gdata_gd_reminder_set_absolute_time (reminder1, 5);
ASSERT_COMPARISON(>);
/* Same method, same time type, different time. */
gdata_gd_reminder_set_absolute_time (reminder1, -1);
gdata_gd_reminder_set_relative_time (reminder1, 20);
ASSERT_COMPARISON(>);
g_object_unref (reminder2);
g_object_unref (reminder1);
#undef ASSERT_COMPARISON
}
static void
test_gd_when (void)
{
GDataGDWhen *when, *when2;
GDataGDReminder *reminder;
GList *reminders;
gint64 _time, _time2;
GError *error = NULL;
const gchar *content_type;
when = GDATA_GD_WHEN (gdata_parsable_new_from_xml (GDATA_TYPE_GD_WHEN,
"<gd:when xmlns:gd='http://schemas.google.com/g/2005' startTime='2005-06-06T17:00:00-08:00' endTime='2005-06-06T18:00:00-08:00'/>",
-1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_WHEN (when));
g_clear_error (&error);
/* Check the properties */
_time = gdata_gd_when_get_start_time (when);
g_assert_cmpint (_time, ==, 1118106000);
_time2 = gdata_gd_when_get_end_time (when);
g_assert_cmpint (_time2, ==, 1118109600);
g_assert (gdata_gd_when_is_date (when) == FALSE);
g_assert (gdata_gd_when_get_value_string (when) == NULL);
g_assert (gdata_gd_when_get_reminders (when) == NULL);
/* Compare it against another identical time */
when2 = gdata_gd_when_new (_time, _time2, FALSE);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (when), GDATA_COMPARABLE (when2)), ==, 0);
/* …and a different one */
_time2 = 100;
gdata_gd_when_set_end_time (when2, _time2);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (when), GDATA_COMPARABLE (when2)), !=, 0);
g_object_unref (when2);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (when));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (when,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:when xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' startTime='2005-06-07T01:00:00Z' "
"endTime='2005-06-07T02:00:00Z'/>");
g_object_unref (when);
/* Now parse a time with different information */
when = GDATA_GD_WHEN (gdata_parsable_new_from_xml (GDATA_TYPE_GD_WHEN,
"<gd:when xmlns:gd='http://schemas.google.com/g/2005' startTime='2005-06-06' endTime='2005-06-08' valueString='This weekend'>"
"<gd:reminder minutes='15'/>"
"<foobar/>"
"</gd:when>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_WHEN (when));
g_clear_error (&error);
/* Check the properties */
_time = gdata_gd_when_get_start_time (when);
g_assert_cmpint (_time, ==, 1118016000);
_time2 = gdata_gd_when_get_end_time (when);
g_assert_cmpint (_time2, ==, 1118188800);
g_assert (gdata_gd_when_is_date (when) == TRUE);
g_assert_cmpstr (gdata_gd_when_get_value_string (when), ==, "This weekend");
reminders = gdata_gd_when_get_reminders (when);
g_assert (reminders != NULL);
g_assert (GDATA_IS_GD_REMINDER (reminders->data));
g_assert (reminders->next == NULL);
g_assert (gdata_gd_reminder_is_absolute_time (GDATA_GD_REMINDER (reminders->data)) == FALSE);
g_assert_cmpint (gdata_gd_reminder_get_relative_time (GDATA_GD_REMINDER (reminders->data)), ==, 15);
/* Add another reminder */
reminder = gdata_gd_reminder_new (GDATA_GD_REMINDER_ALERT, _time, -1);
gdata_gd_when_add_reminder (when, reminder);
g_object_unref (reminder);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (when));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is correct */
gdata_test_assert_xml (when,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:when xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' startTime='2005-06-06' "
"endTime='2005-06-08' valueString='This weekend'>"
"<gd:reminder minutes='15'/>"
"<gd:reminder absoluteTime='2005-06-06T00:00:00Z' method='alert'/>"
"<foobar/>"
"</gd:when>");
g_object_unref (when);
}
static void
test_gd_when_escaping (void)
{
GDataGDWhen *when;
GTimeVal start_time;
g_time_val_from_iso8601 ("2005-06-07T01:00:00Z", &start_time);
when = gdata_gd_when_new (start_time.tv_sec, -1, FALSE);
gdata_gd_when_set_value_string (when, "Value string & stuff!");
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (when,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:when xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' "
"startTime='2005-06-07T01:00:00Z' valueString='Value string & stuff!'/>");
g_object_unref (when);
}
static void
test_gd_when_comparison (void)
{
GDataGDWhen *when1, *when2;
/* Whens are non-equal if one is a date and the other isn't, if their start times differ, or if their end times differ. */
when1 = gdata_gd_when_new (0, 1000, FALSE);
when2 = gdata_gd_when_new (0, 1000, FALSE);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (when1), GDATA_COMPARABLE (when2)), ==, 0);
/* Different date/time type. */
gdata_gd_when_set_is_date (when1, TRUE);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (when1), GDATA_COMPARABLE (when2)), !=, 0);
/* Different start time. */
gdata_gd_when_set_is_date (when1, FALSE);
gdata_gd_when_set_start_time (when1, 500);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (when1), GDATA_COMPARABLE (when2)), !=, 0);
/* Different end time. */
gdata_gd_when_set_start_time (when1, 0);
gdata_gd_when_set_end_time (when1, 15000);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (when1), GDATA_COMPARABLE (when2)), !=, 0);
g_object_unref (when2);
g_object_unref (when1);
}
static void
test_gd_where (void)
{
GDataGDWhere *where, *where2;
GError *error = NULL;
const gchar *content_type;
where = GDATA_GD_WHERE (gdata_parsable_new_from_xml (GDATA_TYPE_GD_WHERE,
"<gd:where xmlns:gd='http://schemas.google.com/g/2005' rel='http://schemas.google.com/g/2005#event.alternate' "
"label='New York Location <videoconference>' valueString='Metropolis'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_WHERE (where));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gd_where_get_relation_type (where), ==, GDATA_GD_WHERE_EVENT_ALTERNATE);
g_assert_cmpstr (gdata_gd_where_get_value_string (where), ==, "Metropolis");
g_assert_cmpstr (gdata_gd_where_get_label (where), ==, "New York Location <videoconference>");
/* Compare it against another identical place */
where2 = gdata_gd_where_new (GDATA_GD_WHERE_EVENT_ALTERNATE, "Metropolis", "New York Location <videoconference>");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (where), GDATA_COMPARABLE (where2)), ==, 0);
/* …and a different one */
gdata_gd_where_set_label (where2, "Atlas Mountains");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (where), GDATA_COMPARABLE (where2)), !=, 0);
g_object_unref (where2);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (where));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (where,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:where xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' "
"label='New York Location <videoconference>' rel='http://schemas.google.com/g/2005#event.alternate' "
"valueString='Metropolis'/>");
g_object_unref (where);
/* Now parse a place with less information available */
where = GDATA_GD_WHERE (gdata_parsable_new_from_xml (GDATA_TYPE_GD_WHERE,
"<gd:where xmlns:gd='http://schemas.google.com/g/2005' valueString='Google Cafeteria <Building 40>'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_WHERE (where));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gd_where_get_value_string (where), ==, "Google Cafeteria <Building 40>");
g_assert (gdata_gd_where_get_relation_type (where) == NULL);
g_assert (gdata_gd_where_get_label (where) == NULL);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (where));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML contains the unknown XML */
gdata_test_assert_xml (where,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:where xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' "
"valueString='Google Cafeteria <Building 40>'/>");
g_object_unref (where);
}
static void
test_gd_where_escaping (void)
{
GDataGDWhere *where;
where = gdata_gd_where_new (GDATA_GD_WHERE_EVENT "?foo&bar", "Value string & stuff!", "<label>");
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (where,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:where xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' "
"label='<label>' rel='http://schemas.google.com/g/2005#event?foo&bar' "
"valueString='Value string & stuff!'/>");
g_object_unref (where);
}
static void
test_gd_where_comparison (void)
{
GDataGDWhere *where1, *where2;
/* Wheres differ if their value or their label differs. */
where1 = gdata_gd_where_new (NULL, "Value", "Label");
where2 = gdata_gd_where_new (GDATA_GD_WHERE_EVENT, "Value", "Label");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (where1), GDATA_COMPARABLE (where2)), ==, 0);
/* Different values. */
gdata_gd_where_set_value_string (where1, "Different");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (where1), GDATA_COMPARABLE (where2)), !=, 0);
/* Different labels. */
gdata_gd_where_set_value_string (where1, "Value");
gdata_gd_where_set_label (where1, "Different");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (where1), GDATA_COMPARABLE (where2)), !=, 0);
g_object_unref (where2);
g_object_unref (where1);
}
static void
test_gd_who (void)
{
GDataGDWho *who, *who2;
GError *error = NULL;
const gchar *content_type;
who = GDATA_GD_WHO (gdata_parsable_new_from_xml (GDATA_TYPE_GD_WHO,
"<gd:who xmlns:gd='http://schemas.google.com/g/2005' rel='http://schemas.google.com/g/2005#message.to' valueString='Elizabeth' "
"email='liz@example.com'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_WHO (who));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gd_who_get_relation_type (who), ==, "http://schemas.google.com/g/2005#message.to");
g_assert_cmpstr (gdata_gd_who_get_value_string (who), ==, "Elizabeth");
g_assert_cmpstr (gdata_gd_who_get_email_address (who), ==, "liz@example.com");
/* Compare it against another identical person */
who2 = gdata_gd_who_new ("http://schemas.google.com/g/2005#message.to", "Elizabeth", "liz@example.com");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (who), GDATA_COMPARABLE (who2)), ==, 0);
/* …and a different one */
gdata_gd_who_set_email_address (who2, "john@example.com");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (who), GDATA_COMPARABLE (who2)), !=, 0);
g_object_unref (who2);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (who));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (who,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:who xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' email='liz@example.com' "
"rel='http://schemas.google.com/g/2005#message.to' valueString='Elizabeth'/>");
g_object_unref (who);
/* Now parse a place with less information available */
who = GDATA_GD_WHO (gdata_parsable_new_from_xml (GDATA_TYPE_GD_WHO,
"<gd:who xmlns:gd='http://schemas.google.com/g/2005'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GD_WHO (who));
g_clear_error (&error);
/* Check the properties */
g_assert (gdata_gd_who_get_value_string (who) == NULL);
g_assert (gdata_gd_who_get_relation_type (who) == NULL);
g_assert (gdata_gd_who_get_email_address (who) == NULL);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (who));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML contains the unknown XML */
gdata_test_assert_xml (who,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:who xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005'/>");
g_object_unref (who);
}
static void
test_gd_who_escaping (void)
{
GDataGDWho *who;
who = gdata_gd_who_new (GDATA_GD_WHO_EVENT_ATTENDEE "?foo&bar", "Value string & stuff!", "John Smith <john.smith@gmail.com>");
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (who,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gd:who xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' "
"email='John Smith <john.smith@gmail.com>' rel='http://schemas.google.com/g/2005#event.attendee?foo&bar' "
"valueString='Value string & stuff!'/>");
g_object_unref (who);
}
static void
test_gd_who_comparison (void)
{
GDataGDWho *who1, *who2;
/* Whos differ if their value strings or e-mail addresses differ. */
who1 = gdata_gd_who_new (NULL, "Jo Bloggs", "email@address");
who2 = gdata_gd_who_new (GDATA_GD_WHO_EVENT_ATTENDEE, "Jo Bloggs", "email@address"); /* who knew indeed? */
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (who1), GDATA_COMPARABLE (who2)), ==, 0);
/* Different value strings. */
gdata_gd_who_set_value_string (who1, "Bridget Smith");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (who1), GDATA_COMPARABLE (who2)), !=, 0);
/* Different e-mail addresses. */
gdata_gd_who_set_value_string (who1, "Jo Bloggs");
gdata_gd_who_set_email_address (who1, "foo@example.com");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (who1), GDATA_COMPARABLE (who2)), !=, 0);
g_object_unref (who2);
g_object_unref (who1);
}
static void
test_media_category (void)
{
GDataMediaCategory *category;
GError *error = NULL;
const gchar *content_type;
category = GDATA_MEDIA_CATEGORY (gdata_parsable_new_from_xml (GDATA_TYPE_MEDIA_CATEGORY,
"<media:category xmlns:media='http://search.yahoo.com/mrss/' scheme='http://dmoz.org' "
"label='Ace Ventura - Pet & Detective'>Arts/Movies/Titles/A/Ace_Ventura_Series/Ace_Ventura_-_Pet_Detective"
"</media:category>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_MEDIA_CATEGORY (category));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_media_category_get_category (category), ==, "Arts/Movies/Titles/A/Ace_Ventura_Series/Ace_Ventura_-_Pet_Detective");
g_assert_cmpstr (gdata_media_category_get_scheme (category), ==, "http://dmoz.org");
g_assert_cmpstr (gdata_media_category_get_label (category), ==, "Ace Ventura - Pet & Detective");
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (category));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (category,
"<?xml version='1.0' encoding='UTF-8'?>"
"<media:category xmlns='http://www.w3.org/2005/Atom' xmlns:media='http://search.yahoo.com/mrss/' "
"scheme='http://dmoz.org' "
"label='Ace Ventura - Pet & Detective'>Arts/Movies/Titles/A/Ace_Ventura_Series/Ace_Ventura_-_Pet_Detective"
"</media:category>");
g_object_unref (category);
/* Now parse one with less information available */
category = GDATA_MEDIA_CATEGORY (gdata_parsable_new_from_xml (GDATA_TYPE_MEDIA_CATEGORY,
"<media:category xmlns:media='http://search.yahoo.com/mrss/'>foo</media:category>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_MEDIA_CATEGORY (category));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_media_category_get_category (category), ==, "foo");
g_assert_cmpstr (gdata_media_category_get_scheme (category), ==, "http://video.search.yahoo.com/mrss/category_schema");
g_assert (gdata_media_category_get_label (category) == NULL);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (category));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (category,
"<?xml version='1.0' encoding='UTF-8'?>"
"<media:category xmlns='http://www.w3.org/2005/Atom' xmlns:media='http://search.yahoo.com/mrss/' "
"scheme='http://video.search.yahoo.com/mrss/category_schema'>foo</media:category>");
g_object_unref (category);
}
static void
test_media_category_escaping (void)
{
GDataMediaCategory *category;
category = gdata_media_category_new ("<category>", "http://foo.com?foo&bar", "Label & stuff");
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (category,
"<?xml version='1.0' encoding='UTF-8'?>"
"<media:category xmlns='http://www.w3.org/2005/Atom' xmlns:media='http://search.yahoo.com/mrss/' "
"scheme='http://foo.com?foo&bar' label='Label & stuff'><category></media:category>");
g_object_unref (category);
}
static void
test_media_content (void)
{
GDataMediaContent *content;
GError *error = NULL;
const gchar *content_type;
content = GDATA_MEDIA_CONTENT (gdata_parsable_new_from_xml (GDATA_TYPE_MEDIA_CONTENT,
"<media:content xmlns:media='http://search.yahoo.com/mrss/' url='http://www.foo.com/movie.mov' fileSize='12216320' "
"type='video/quicktime' medium='video' isDefault='true' expression='nonstop' duration='185' height='200' width='300'/>",
-1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_MEDIA_CONTENT (content));
g_clear_error (&error);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (content));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the properties */
g_assert_cmpstr (gdata_media_content_get_uri (content), ==, "http://www.foo.com/movie.mov");
g_assert_cmpint (gdata_media_content_get_filesize (content), ==, 12216320);
g_assert_cmpstr (gdata_media_content_get_content_type (content), ==, "video/quicktime");
g_assert (gdata_media_content_get_medium (content) == GDATA_MEDIA_VIDEO);
g_assert (gdata_media_content_is_default (content) == TRUE);
g_assert (gdata_media_content_get_expression (content) == GDATA_MEDIA_EXPRESSION_NONSTOP);
g_assert_cmpint (gdata_media_content_get_duration (content), ==, 185);
g_assert_cmpuint (gdata_media_content_get_width (content), ==, 300);
g_assert_cmpuint (gdata_media_content_get_height (content), ==, 200);
/* NOTE: We don't check the outputted XML, since the class currently doesn't have any support for outputting XML */
g_object_unref (content);
/* Now parse one with less information available */
content = GDATA_MEDIA_CONTENT (gdata_parsable_new_from_xml (GDATA_TYPE_MEDIA_CONTENT,
"<media:content xmlns:media='http://search.yahoo.com/mrss/' url='http://foobar.com/'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_MEDIA_CONTENT (content));
g_clear_error (&error);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (content));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the properties */
g_assert_cmpstr (gdata_media_content_get_uri (content), ==, "http://foobar.com/");
g_assert_cmpint (gdata_media_content_get_filesize (content), ==, 0);
g_assert (gdata_media_content_get_content_type (content) == NULL);
g_assert (gdata_media_content_get_medium (content) == GDATA_MEDIA_UNKNOWN);
g_assert (gdata_media_content_is_default (content) == FALSE);
g_assert (gdata_media_content_get_expression (content) == GDATA_MEDIA_EXPRESSION_FULL);
g_assert_cmpint (gdata_media_content_get_duration (content), ==, 0);
g_assert_cmpuint (gdata_media_content_get_width (content), ==, 0);
g_assert_cmpuint (gdata_media_content_get_height (content), ==, 0);
g_object_unref (content);
}
static void
test_media_credit (void)
{
GDataMediaCredit *credit;
GError *error = NULL;
const gchar *content_type;
credit = GDATA_MEDIA_CREDIT (gdata_parsable_new_from_xml (GDATA_TYPE_MEDIA_CREDIT,
"<media:credit xmlns:media='http://search.yahoo.com/mrss/' role='producer' scheme='urn:foobar'>entity name</media:credit>",
-1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_MEDIA_CREDIT (credit));
g_clear_error (&error);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (credit));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the properties */
g_assert_cmpstr (gdata_media_credit_get_credit (credit), ==, "entity name");
g_assert_cmpstr (gdata_media_credit_get_scheme (credit), ==, "urn:foobar");
g_assert_cmpstr (gdata_media_credit_get_role (credit), ==, "producer");
/* NOTE: We don't check the outputted XML, since the class currently doesn't have any support for outputting XML */
g_object_unref (credit);
/* Now parse one with less information available */
credit = GDATA_MEDIA_CREDIT (gdata_parsable_new_from_xml (GDATA_TYPE_MEDIA_CREDIT,
"<media:credit xmlns:media='http://search.yahoo.com/mrss/'>John Smith</media:credit>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_MEDIA_CREDIT (credit));
g_clear_error (&error);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (credit));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the properties */
g_assert_cmpstr (gdata_media_credit_get_credit (credit), ==, "John Smith");
g_assert_cmpstr (gdata_media_credit_get_scheme (credit), ==, "urn:ebu");
g_assert (gdata_media_credit_get_role (credit) == NULL);
g_object_unref (credit);
}
#if 0
/* We can't test GDataMediaGroup, since it isn't currently publicly exposed */
static void
test_media_group (void)
{
GDataMediaGroup *group;
GList *contents, *thumbnails;
GError *error = NULL;
const gchar *content_type;
group = GDATA_MEDIA_GROUP (gdata_parsable_new_from_xml (GDATA_TYPE_MEDIA_GROUP,
"<media:group xmlns:media='http://search.yahoo.com/mrss/'>"
"<media:title>Foobar — shizzle!</media:title>"
"<media:description>This is a description, isn't it‽</media:description>"
"<media:keywords>keywords,are, fun</media:keywords>"
"<media:category scheme='http://dmoz.org' label='Ace Ventura - Pet Detective'>"
"Arts/Movies/Titles/A/Ace_Ventura_Series/Ace_Ventura_-_Pet_Detective</media:category>"
"<media:content url='http://foobar.com/'/>"
"<media:content url='http://www.foo.com/movie.mov' fileSize='12216320' type='video/quicktime' medium='video' isDefault='true' "
"expression='nonstop' duration='185' height='200' width='300'/>"
"<media:credit>John Smith</media:credit>"
"<media:player url='http://www.foo.com/player?id=1111' height='200' width='400'/>"
"<media:restriction relationship='deny'>all</media:restriction>"
"<media:restriction relationship='allow' type='country'>au us</media:restriction>"
"<media:thumbnail url='http://www.foo.com/keyframe.jpg' width='75' height='50' time='12:05:01.123'/>"
"<media:thumbnail url='http://www.foo.com/keyframe0.jpg' time='00:00:00'/>"
"</media:group>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_MEDIA_GROUP (group));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_media_group_get_title (group), ==, "Foobar — shizzle!");
g_assert_cmpstr (gdata_media_group_get_description (group), ==, "This is a description, isn't it‽");
g_assert_cmpstr (gdata_media_group_get_keywords (group), ==, "keywords,are, fun");
g_assert (GDATA_IS_MEDIA_CATEGORY (gdata_media_group_get_category (group)));
g_assert (GDATA_IS_MEDIA_CONTENT (gdata_media_group_look_up_content (group, NULL)));
g_assert (GDATA_IS_MEDIA_CONTENT (gdata_media_group_look_up_content (group, "video/quicktime")));
contents = gdata_media_group_get_contents (group);
g_assert_cmpuint (g_list_length (contents), ==, 2);
g_assert (GDATA_IS_MEDIA_CONTENT (contents->data));
g_assert (GDATA_IS_MEDIA_CONTENT (contents->next->data));
g_assert (GDATA_IS_MEDIA_CREDIT (gdata_media_group_get_credit (group)));
g_assert_cmpstr (gdata_media_group_get_player_uri (group), ==, "http://www.foo.com/player?id=1111");
g_assert (gdata_media_group_is_restricted_in_country (group, "uk") == TRUE);
g_assert (gdata_media_group_is_restricted_in_country (group, "au") == FALSE);
g_assert (gdata_media_group_is_restricted_in_country (group, "us") == FALSE);
thumbnails = gdata_media_group_get_thumbnails (group);
g_assert_cmpuint (g_list_length (thumbnails), ==, 2);
g_assert (GDATA_IS_MEDIA_THUMBNAIL (thumbnails->data));
g_assert (GDATA_IS_MEDIA_THUMBNAIL (thumbnails->next->data));
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (group));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (group,
"<?xml version='1.0' encoding='UTF-8'?>"
"<media:group xmlns:media='http://search.yahoo.com/mrss/'>"
"<media:title>Foobar — shizzle!</media:title>"
"<media:description>This is a description, isn't it‽</media:description>"
"<media:keywords>keywords,are, fun</media:keywords>"
"<media:category scheme='http://dmoz.org' label='Ace Ventura - Pet Detective'>"
"Arts/Movies/Titles/A/Ace_Ventura_Series/Ace_Ventura_-_Pet_Detective</media:category>"
"<media:content url='http://foobar.com/'/>"
"<media:content url='http://www.foo.com/movie.mov' fileSize='12216320' type='video/quicktime' medium='video' "
"isDefault='true' expression='nonstop' duration='185' height='200' width='300'/>"
"<media:credit>John Smith</media:credit>"
"<media:player url='http://www.foo.com/player?id=1111' height='200' width='400'/>"
"<media:restriction relationship='deny'>all</media:restriction>"
"<media:restriction relationship='allow' type='country'>au us</media:restriction>"
"<media:thumbnail url='http://www.foo.com/keyframe.jpg' width='75' height='50' time='12:05:01.123'/>"
"<media:thumbnail url='http://www.foo.com/keyframe0.jpg' time='00:00:00'/>"
"</media:group>");
/* Check setting things works */
gdata_media_group_set_title (group, "Test title");
g_assert_cmpstr (gdata_media_group_get_title (group), ==, "Test title");
gdata_media_group_set_title (group, NULL);
g_assert (gdata_media_group_get_title (group) == NULL);
gdata_media_group_set_description (group, "Foobar");
g_assert_cmpstr (gdata_media_group_get_description (group), ==, "Foobar");
gdata_media_group_set_description (group, NULL);
g_assert (gdata_media_group_get_description (group) == NULL);
gdata_media_group_set_keywords (group, "a,b, c");
g_assert_cmpstr (gdata_media_group_get_keywords (group), ==, "a,b, c");
gdata_media_group_set_keywords (group, NULL);
g_assert (gdata_media_group_get_keywords (group) == NULL);
gdata_media_group_set_category (group, NULL);
g_assert (gdata_media_group_get_category (group) == NULL);
g_object_unref (group);
/* Now parse one with less information available */
group = GDATA_MEDIA_GROUP (gdata_parsable_new_from_xml (GDATA_TYPE_MEDIA_GROUP,
"<media:group xmlns:media='http://search.yahoo.com/mrss/'></media:group>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_MEDIA_GROUP (group));
g_clear_error (&error);
/* Check the properties */
g_assert (gdata_media_group_get_title (group) == NULL);
g_assert (gdata_media_group_get_description (group) == NULL);
g_assert (gdata_media_group_get_keywords (group) == NULL);
g_assert (gdata_media_group_get_category (group) == NULL);
g_assert (gdata_media_group_look_up_content (group, NULL) == NULL);
g_assert (gdata_media_group_look_up_content (group, "video/quicktime") == NULL);
g_assert (gdata_media_group_get_contents (group) == NULL);
g_assert (gdata_media_group_get_credit (group) == NULL);
g_assert (gdata_media_group_get_player_uri (group) == NULL);
g_assert (gdata_media_group_is_restricted_in_country (group, "uk") == FALSE);
g_assert (gdata_media_group_is_restricted_in_country (group, "au") == FALSE);
g_assert (gdata_media_group_is_restricted_in_country (group, "us") == FALSE);
g_assert (gdata_media_group_get_thumbnails (group) == NULL);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (group));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (group,
"<?xml version='1.0' encoding='UTF-8'?>"
"<media:group xmlns='http://www.w3.org/2005/Atom' xmlns:media='http://search.yahoo.com/mrss/'></media:group>");
g_object_unref (group);
}
#endif
static void
test_media_thumbnail (void)
{
GDataMediaThumbnail *thumbnail;
GError *error = NULL;
thumbnail = GDATA_MEDIA_THUMBNAIL (gdata_parsable_new_from_xml (GDATA_TYPE_MEDIA_THUMBNAIL,
"<media:thumbnail xmlns:media='http://search.yahoo.com/mrss/' url='http://www.foo.com/keyframe.jpg' width='75' height='50' "
"time='12:05:01.123'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_MEDIA_THUMBNAIL (thumbnail));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_media_thumbnail_get_uri (thumbnail), ==, "http://www.foo.com/keyframe.jpg");
g_assert_cmpuint (gdata_media_thumbnail_get_width (thumbnail), ==, 75);
g_assert_cmpuint (gdata_media_thumbnail_get_height (thumbnail), ==, 50);
g_assert_cmpint (gdata_media_thumbnail_get_time (thumbnail), ==, 43501123);
/* NOTE: We don't check the outputted XML, since the class currently doesn't have any support for outputting XML */
g_object_unref (thumbnail);
/* Now parse one with less information available */
thumbnail = GDATA_MEDIA_THUMBNAIL (gdata_parsable_new_from_xml (GDATA_TYPE_MEDIA_THUMBNAIL,
"<media:thumbnail xmlns:media='http://search.yahoo.com/mrss/' url='http://foobar.com/'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_MEDIA_THUMBNAIL (thumbnail));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_media_thumbnail_get_uri (thumbnail), ==, "http://foobar.com/");
g_assert_cmpuint (gdata_media_thumbnail_get_width (thumbnail), ==, 0);
g_assert_cmpuint (gdata_media_thumbnail_get_height (thumbnail), ==, 0);
g_assert_cmpint (gdata_media_thumbnail_get_time (thumbnail), ==, -1);
g_object_unref (thumbnail);
}
static void
test_gcontact_calendar (void)
{
GDataGContactCalendar *calendar, *calendar2;
GError *error = NULL;
const gchar *content_type;
calendar = GDATA_GCONTACT_CALENDAR (gdata_parsable_new_from_xml (GDATA_TYPE_GCONTACT_CALENDAR,
"<gContact:calendarLink xmlns:gContact='http://schemas.google.com/contact/2008' rel='work' primary='true' "
"href='http://calendar.com/'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GCONTACT_CALENDAR (calendar));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gcontact_calendar_get_uri (calendar), ==, "http://calendar.com/");
g_assert_cmpstr (gdata_gcontact_calendar_get_relation_type (calendar), ==, GDATA_GCONTACT_CALENDAR_WORK);
g_assert (gdata_gcontact_calendar_get_label (calendar) == NULL);
g_assert (gdata_gcontact_calendar_is_primary (calendar) == TRUE);
/* Compare it against another identical calendar */
calendar2 = gdata_gcontact_calendar_new ("http://calendar.com/", GDATA_GCONTACT_CALENDAR_WORK, NULL, TRUE);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (calendar), GDATA_COMPARABLE (calendar2)), ==, 0);
/* …and a different one */
gdata_gcontact_calendar_set_uri (calendar2, "http://calendar.somewhereelse.com/");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (calendar), GDATA_COMPARABLE (calendar2)), !=, 0);
g_object_unref (calendar2);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (calendar));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (calendar,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:calendarLink xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' "
"href='http://calendar.com/' rel='work' primary='true'/>");
g_object_unref (calendar);
/* Now parse a calendar with less information available */
calendar = GDATA_GCONTACT_CALENDAR (gdata_parsable_new_from_xml (GDATA_TYPE_GCONTACT_CALENDAR,
"<gContact:calendarLink xmlns:gContact='http://schemas.google.com/contact/2008' href='http://example.com/' label='<a>'/>",
-1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GCONTACT_CALENDAR (calendar));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gcontact_calendar_get_uri (calendar), ==, "http://example.com/");
g_assert (gdata_gcontact_calendar_get_relation_type (calendar) == NULL);
g_assert_cmpstr (gdata_gcontact_calendar_get_label (calendar), ==, "<a>");
g_assert (gdata_gcontact_calendar_is_primary (calendar) == FALSE);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (calendar));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is still OK */
gdata_test_assert_xml (calendar,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:calendarLink xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' "
"href='http://example.com/' label='<a>' primary='false'/>");
g_object_unref (calendar);
}
static void
test_gcontact_calendar_error_handling (void)
{
GDataGContactCalendar *calendar;
GError *error = NULL;
#define TEST_XML_ERROR_HANDLING(x) calendar = GDATA_GCONTACT_CALENDAR (gdata_parsable_new_from_xml (GDATA_TYPE_GCONTACT_CALENDAR,\
"<gContact:calendarLink xmlns:gContact='http://schemas.google.com/contact/2008' "\
x\
"/>", -1, &error));\
g_assert_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR);\
g_assert (calendar == NULL);\
g_clear_error (&error)
TEST_XML_ERROR_HANDLING ("rel='work'"); /* no href */
TEST_XML_ERROR_HANDLING ("rel='work' href=''"); /* empty href */
TEST_XML_ERROR_HANDLING ("href='http://example.com/'"); /* no rel or label */
TEST_XML_ERROR_HANDLING ("href='http://example.com/' rel=''"); /* empty rel */
TEST_XML_ERROR_HANDLING ("href='http://example.com/' label=''"); /* empty label */
TEST_XML_ERROR_HANDLING ("href='http://example.com/' rel='other' label='Other'"); /* rel and label */
TEST_XML_ERROR_HANDLING ("href='http://example.com/' rel='home' primary='not a boolean'"); /* invalid primary */
#undef TEST_XML_ERROR_HANDLING
}
static void
test_gcontact_calendar_escaping (void)
{
GDataGContactCalendar *calendar;
/* Test with rel */
calendar = gdata_gcontact_calendar_new ("http://foo.com?foo&bar", "http://foo.com?foo&relation=bar", NULL, TRUE);
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (calendar,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:calendarLink xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' "
"href='http://foo.com?foo&bar' rel='http://foo.com?foo&relation=bar' primary='true'/>");
g_object_unref (calendar);
/* Test with label */
calendar = gdata_gcontact_calendar_new ("http://foo.com?foo&bar", NULL, "Label & stuff", FALSE);
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (calendar,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:calendarLink xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' "
"href='http://foo.com?foo&bar' label='Label & stuff' primary='false'/>");
g_object_unref (calendar);
}
static void
test_gcontact_event (void)
{
GDataGContactEvent *event, *event2;
GDate date;
GError *error = NULL;
const gchar *content_type;
event = GDATA_GCONTACT_EVENT (gdata_parsable_new_from_xml (GDATA_TYPE_GCONTACT_EVENT,
"<gContact:event xmlns:gContact='http://schemas.google.com/contact/2008' xmlns:gd='http://schemas.google.com/g/2005' rel='other'>"
"<gd:when startTime='2004-03-12'/>"
"</gContact:event>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GCONTACT_EVENT (event));
g_clear_error (&error);
/* Check the properties */
gdata_gcontact_event_get_date (event, &date);
g_assert (g_date_valid (&date) == TRUE);
g_assert_cmpuint (g_date_get_year (&date), ==, 2004);
g_assert_cmpuint (g_date_get_month (&date), ==, 3);
g_assert_cmpuint (g_date_get_day (&date), ==, 12);
g_assert_cmpstr (gdata_gcontact_event_get_relation_type (event), ==, GDATA_GCONTACT_EVENT_OTHER);
g_assert (gdata_gcontact_event_get_label (event) == NULL);
/* Try creating another event from scratch */
event2 = gdata_gcontact_event_new (&date, GDATA_GCONTACT_EVENT_OTHER, NULL);
g_assert (GDATA_IS_GCONTACT_EVENT (event2));
g_object_unref (event2);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (event));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (event,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:event xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' "
"xmlns:gContact='http://schemas.google.com/contact/2008' rel='other'>"
"<gd:when startTime='2004-03-12'/>"
"</gContact:event>");
g_object_unref (event);
/* Now parse an event with different information available */
event = GDATA_GCONTACT_EVENT (gdata_parsable_new_from_xml (GDATA_TYPE_GCONTACT_EVENT,
"<gContact:event xmlns:gContact='http://schemas.google.com/contact/2008' xmlns:gd='http://schemas.google.com/g/2005' "
"label='<a>'>"
"<gd:when startTime='2000-01-01'/>"
"</gContact:event>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GCONTACT_EVENT (event));
g_clear_error (&error);
/* Check the properties */
gdata_gcontact_event_get_date (event, &date);
g_assert (g_date_valid (&date) == TRUE);
g_assert_cmpuint (g_date_get_year (&date), ==, 2000);
g_assert_cmpuint (g_date_get_month (&date), ==, 1);
g_assert_cmpuint (g_date_get_day (&date), ==, 1);
g_assert (gdata_gcontact_event_get_relation_type (event) == NULL);
g_assert_cmpstr (gdata_gcontact_event_get_label (event), ==, "<a>");
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (event));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is still OK */
gdata_test_assert_xml (event,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:event xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' "
"xmlns:gContact='http://schemas.google.com/contact/2008' label='<a>'>"
"<gd:when startTime='2000-01-01'/>"
"</gContact:event>");
g_object_unref (event);
}
static void
test_gcontact_event_error_handling (void)
{
GDataGContactEvent *event;
GError *error = NULL;
#define TEST_XML_ERROR_HANDLING(x) event = GDATA_GCONTACT_EVENT (gdata_parsable_new_from_xml (GDATA_TYPE_GCONTACT_EVENT,\
"<gContact:event xmlns:gContact='http://schemas.google.com/contact/2008' xmlns:gd='http://schemas.google.com/g/2005' "\
x\
"</gContact:event>", -1, &error));\
g_assert_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR);\
g_assert (event == NULL);\
g_clear_error (&error)
TEST_XML_ERROR_HANDLING ("rel='anniversary'>"); /* no gd:when */
TEST_XML_ERROR_HANDLING ("rel='anniversary'><gd:when/>"); /* no startTime */
TEST_XML_ERROR_HANDLING ("rel='anniversary'><gd:when startTime='foobar'/>"); /* invalid startTime */
TEST_XML_ERROR_HANDLING ("rel='anniversary'><gd:when startTime='2001-12-41'/>");
TEST_XML_ERROR_HANDLING ("rel='anniversary'><gd:when startTime='2010-03-25T22:01Z'/>");
TEST_XML_ERROR_HANDLING ("><gd:when startTime='2000-01-01'/>"); /* no rel or label */
TEST_XML_ERROR_HANDLING ("rel=''><gd:when startTime='2000-01-01'/>"); /* empty rel */
TEST_XML_ERROR_HANDLING ("label=''><gd:when startTime='2000-01-01'/>"); /* empty label */
TEST_XML_ERROR_HANDLING ("rel='other' label='Other'><gd:when startTime='2000-01-01'/>"); /* rel and label */
#undef TEST_XML_ERROR_HANDLING
}
static void
test_gcontact_event_escaping (void)
{
GDataGContactEvent *event;
GDate date;
g_date_clear (&date, 1);
g_date_set_dmy (&date, 1, G_DATE_JANUARY, 2011);
/* Test with rel */
event = gdata_gcontact_event_new (&date, "http://foo.com?foo&relation=bar", NULL);
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (event,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:event xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' "
"xmlns:gContact='http://schemas.google.com/contact/2008' rel='http://foo.com?foo&relation=bar'>"
"<gd:when startTime='2011-01-01'/>"
"</gContact:event>");
g_object_unref (event);
/* Test with label */
event = gdata_gcontact_event_new (&date, NULL, "Label & stuff");
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (event,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:event xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' "
"xmlns:gContact='http://schemas.google.com/contact/2008' label='Label & stuff'>"
"<gd:when startTime='2011-01-01'/>"
"</gContact:event>");
g_object_unref (event);
}
static void
test_gcontact_external_id (void)
{
GDataGContactExternalID *id, *id2;
GError *error = NULL;
const gchar *content_type;
id = GDATA_GCONTACT_EXTERNAL_ID (gdata_parsable_new_from_xml (GDATA_TYPE_GCONTACT_EXTERNAL_ID,
"<gContact:externalId xmlns:gContact='http://schemas.google.com/contact/2008' rel='account' value='5'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GCONTACT_EXTERNAL_ID (id));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gcontact_external_id_get_value (id), ==, "5");
g_assert_cmpstr (gdata_gcontact_external_id_get_relation_type (id), ==, GDATA_GCONTACT_EXTERNAL_ID_ACCOUNT);
g_assert (gdata_gcontact_external_id_get_label (id) == NULL);
/* Compare it against another identical external ID */
id2 = gdata_gcontact_external_id_new ("5", GDATA_GCONTACT_EXTERNAL_ID_ACCOUNT, NULL);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (id), GDATA_COMPARABLE (id2)), ==, 0);
/* …and a different one */
gdata_gcontact_external_id_set_value (id2, "http://identifying.uri");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (id), GDATA_COMPARABLE (id2)), !=, 0);
g_object_unref (id2);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (id));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (id,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:externalId xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' "
"value='5' rel='account'/>");
g_object_unref (id);
/* Now parse an ID with less information available */
id = GDATA_GCONTACT_EXTERNAL_ID (gdata_parsable_new_from_xml (GDATA_TYPE_GCONTACT_EXTERNAL_ID,
"<gContact:externalId xmlns:gContact='http://schemas.google.com/contact/2008' value='' label='<a>'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GCONTACT_EXTERNAL_ID (id));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gcontact_external_id_get_value (id), ==, "");
g_assert (gdata_gcontact_external_id_get_relation_type (id) == NULL);
g_assert_cmpstr (gdata_gcontact_external_id_get_label (id), ==, "<a>");
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (id));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is still OK */
gdata_test_assert_xml (id,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:externalId xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' "
"value='' label='<a>'/>");
g_object_unref (id);
}
static void
test_gcontact_external_id_error_handling (void)
{
GDataGContactExternalID *id;
GError *error = NULL;
#define TEST_XML_ERROR_HANDLING(x) id = GDATA_GCONTACT_EXTERNAL_ID (gdata_parsable_new_from_xml (GDATA_TYPE_GCONTACT_EXTERNAL_ID,\
"<gContact:externalId xmlns:gContact='http://schemas.google.com/contact/2008' "\
x\
"/>", -1, &error));\
g_assert_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR);\
g_assert (id == NULL);\
g_clear_error (&error)
TEST_XML_ERROR_HANDLING ("rel='account'"); /* no value */
TEST_XML_ERROR_HANDLING ("value='foo'"); /* no rel or label */
TEST_XML_ERROR_HANDLING ("value='foo' rel=''"); /* empty rel */
TEST_XML_ERROR_HANDLING ("value='foo' label=''"); /* empty label */
TEST_XML_ERROR_HANDLING ("value='foo' rel='organization' label='Other'"); /* rel and label */
#undef TEST_XML_ERROR_HANDLING
}
static void
test_gcontact_external_id_escaping (void)
{
GDataGContactExternalID *id;
/* Test with rel */
id = gdata_gcontact_external_id_new ("<id>", "http://foo.com?foo&relation=bar", NULL);
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (id,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:externalId xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' "
"value='<id>' rel='http://foo.com?foo&relation=bar'/>");
g_object_unref (id);
/* Test with label */
id = gdata_gcontact_external_id_new ("<id>", NULL, "Label & stuff");
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (id,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:externalId xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' "
"value='<id>' label='Label & stuff'/>");
g_object_unref (id);
}
static void
test_gcontact_jot (void)
{
GDataGContactJot *jot, *jot2;
GError *error = NULL;
const gchar *content_type;
jot = GDATA_GCONTACT_JOT (gdata_parsable_new_from_xml (GDATA_TYPE_GCONTACT_JOT,
"<gContact:jot xmlns:gContact='http://schemas.google.com/contact/2008' rel='user'>They like <angles>.</gContact:jot>",
-1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GCONTACT_JOT (jot));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gcontact_jot_get_relation_type (jot), ==, GDATA_GCONTACT_JOT_USER);
g_assert_cmpstr (gdata_gcontact_jot_get_content (jot), ==, "They like <angles>.");
/* Try creating another jot from scratch */
jot2 = gdata_gcontact_jot_new ("friend,local,oss", GDATA_GCONTACT_JOT_KEYWORDS);
g_assert (GDATA_IS_GCONTACT_JOT (jot2));
g_object_unref (jot2);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (jot));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (jot,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:jot xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' rel='user'>"
"They like <angles>.</gContact:jot>");
g_object_unref (jot);
/* Now parse a jot with different information available */
jot = GDATA_GCONTACT_JOT (gdata_parsable_new_from_xml (GDATA_TYPE_GCONTACT_JOT,
"<gContact:jot xmlns:gContact='http://schemas.google.com/contact/2008' rel='other'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GCONTACT_JOT (jot));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gcontact_jot_get_relation_type (jot), ==, GDATA_GCONTACT_JOT_OTHER);
g_assert (gdata_gcontact_jot_get_content (jot) == NULL);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (jot));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is still OK */
gdata_test_assert_xml (jot,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:jot xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' rel='other'/>");
g_object_unref (jot);
}
static void
test_gcontact_jot_error_handling (void)
{
GDataGContactJot *jot;
GError *error = NULL;
#define TEST_XML_ERROR_HANDLING(x) jot = GDATA_GCONTACT_JOT (gdata_parsable_new_from_xml (GDATA_TYPE_GCONTACT_JOT,\
"<gContact:jot xmlns:gContact='http://schemas.google.com/contact/2008' "\
x\
"</gContact:jot>", -1, &error));\
g_assert_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR);\
g_assert (jot == NULL);\
g_clear_error (&error)
TEST_XML_ERROR_HANDLING (">Content"); /* no rel */
TEST_XML_ERROR_HANDLING ("rel=''>Content"); /* empty rel */
#undef TEST_XML_ERROR_HANDLING
}
static void
test_gcontact_jot_escaping (void)
{
GDataGContactJot *jot;
jot = gdata_gcontact_jot_new ("Content & stuff", "http://foo.com?foo&relation=bar");
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (jot,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:jot xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' "
"rel='http://foo.com?foo&relation=bar'>Content & stuff</gContact:jot>");
g_object_unref (jot);
}
static void
test_gcontact_language (void)
{
GDataGContactLanguage *language, *language2;
GError *error = NULL;
const gchar *content_type;
language = GDATA_GCONTACT_LANGUAGE (gdata_parsable_new_from_xml (GDATA_TYPE_GCONTACT_LANGUAGE,
"<gContact:language xmlns:gContact='http://schemas.google.com/contact/2008' code='en-GB'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GCONTACT_LANGUAGE (language));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gcontact_language_get_code (language), ==, "en-GB");
g_assert (gdata_gcontact_language_get_label (language) == NULL);
/* Compare it against another identical language */
language2 = gdata_gcontact_language_new ("en-GB", NULL);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (language), GDATA_COMPARABLE (language2)), ==, 0);
/* …and a different one */
gdata_gcontact_language_set_code (language2, "sv");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (language), GDATA_COMPARABLE (language2)), !=, 0);
g_object_unref (language2);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (language));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (language,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:language xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' "
"code='en-GB'/>");
g_object_unref (language);
/* Now parse a language with less information available */
language = GDATA_GCONTACT_LANGUAGE (gdata_parsable_new_from_xml (GDATA_TYPE_GCONTACT_LANGUAGE,
"<gContact:language xmlns:gContact='http://schemas.google.com/contact/2008' label='Gobbledegook'/>",
-1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GCONTACT_LANGUAGE (language));
g_clear_error (&error);
/* Check the properties */
g_assert (gdata_gcontact_language_get_code (language) == NULL);
g_assert_cmpstr (gdata_gcontact_language_get_label (language), ==, "Gobbledegook");
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (language));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is still OK */
gdata_test_assert_xml (language,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:language xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' "
"label='Gobbledegook'/>");
g_object_unref (language);
}
static void
test_gcontact_language_error_handling (void)
{
GDataGContactLanguage *language;
GError *error = NULL;
#define TEST_XML_ERROR_HANDLING(x) language = GDATA_GCONTACT_LANGUAGE (gdata_parsable_new_from_xml (GDATA_TYPE_GCONTACT_LANGUAGE,\
"<gContact:language xmlns:gContact='http://schemas.google.com/contact/2008' "\
x\
"/>", -1, &error));\
g_assert_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR);\
g_assert (language == NULL);\
g_clear_error (&error)
TEST_XML_ERROR_HANDLING (""); /* no code or label */
TEST_XML_ERROR_HANDLING ("code=''"); /* empty code */
TEST_XML_ERROR_HANDLING ("label=''"); /* empty label */
TEST_XML_ERROR_HANDLING ("code='en-GB' label='Other'"); /* code and label */
#undef TEST_XML_ERROR_HANDLING
}
static void
test_gcontact_language_escaping (void)
{
GDataGContactLanguage *language;
/* Test with code */
language = gdata_gcontact_language_new ("<code>", NULL);
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (language,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:language xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' "
"code='<code>'/>");
g_object_unref (language);
/* Test with label */
language = gdata_gcontact_language_new (NULL, "Label & stuff");
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (language,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:language xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' "
"label='Label & stuff'/>");
g_object_unref (language);
}
static void
test_gcontact_relation (void)
{
GDataGContactRelation *relation, *relation2;
GError *error = NULL;
const gchar *content_type;
relation = GDATA_GCONTACT_RELATION (gdata_parsable_new_from_xml (GDATA_TYPE_GCONTACT_RELATION,
"<gContact:relation xmlns:gContact='http://schemas.google.com/contact/2008' rel='child'>Fred</gContact:relation>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GCONTACT_RELATION (relation));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gcontact_relation_get_name (relation), ==, "Fred");
g_assert_cmpstr (gdata_gcontact_relation_get_relation_type (relation), ==, GDATA_GCONTACT_RELATION_CHILD);
g_assert (gdata_gcontact_relation_get_label (relation) == NULL);
/* Try creating another relation from scratch */
relation2 = gdata_gcontact_relation_new ("Brian", GDATA_GCONTACT_RELATION_RELATIVE, NULL);
g_assert (GDATA_IS_GCONTACT_RELATION (relation2));
g_object_unref (relation2);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (relation));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (relation,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:relation xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' rel='child'>"
"Fred</gContact:relation>");
g_object_unref (relation);
/* Now parse a relation with different information available */
relation = GDATA_GCONTACT_RELATION (gdata_parsable_new_from_xml (GDATA_TYPE_GCONTACT_RELATION,
"<gContact:relation xmlns:gContact='http://schemas.google.com/contact/2008' label='<a>'>Sid</gContact:relation>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GCONTACT_RELATION (relation));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gcontact_relation_get_name (relation), ==, "Sid");
g_assert (gdata_gcontact_relation_get_relation_type (relation) == NULL);
g_assert_cmpstr (gdata_gcontact_relation_get_label (relation), ==, "<a>");
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (relation));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is still OK */
gdata_test_assert_xml (relation,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:relation xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' "
"label='<a>'>Sid</gContact:relation>");
g_object_unref (relation);
}
static void
test_gcontact_relation_error_handling (void)
{
GDataGContactRelation *relation;
GError *error = NULL;
#define TEST_XML_ERROR_HANDLING(x) relation = GDATA_GCONTACT_RELATION (gdata_parsable_new_from_xml (GDATA_TYPE_GCONTACT_RELATION,\
"<gContact:relation xmlns:gContact='http://schemas.google.com/contact/2008' "\
x\
"</gContact:relation>", -1, &error));\
g_assert_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR);\
g_assert (relation == NULL);\
g_clear_error (&error)
TEST_XML_ERROR_HANDLING ("rel='spouse'>"); /* no name */
TEST_XML_ERROR_HANDLING (">Brian"); /* no rel or label */
TEST_XML_ERROR_HANDLING ("rel=''>Brian"); /* empty rel */
TEST_XML_ERROR_HANDLING ("label=''>Brian"); /* empty label */
TEST_XML_ERROR_HANDLING ("rel='sister' label='Older sister'>Brian"); /* rel and label */
#undef TEST_XML_ERROR_HANDLING
}
static void
test_gcontact_relation_escaping (void)
{
GDataGContactRelation *relation;
/* Test with rel */
relation = gdata_gcontact_relation_new ("First & Last Name", "http://foo.com?foo&relation=bar", NULL);
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (relation,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:relation xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' "
"rel='http://foo.com?foo&relation=bar'>First & Last Name</gContact:relation>");
g_object_unref (relation);
/* Test with label */
relation = gdata_gcontact_relation_new ("First & Last Name", NULL, "Label & stuff");
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (relation,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:relation xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' "
"label='Label & stuff'>First & Last Name</gContact:relation>");
g_object_unref (relation);
}
static void
test_gcontact_website (void)
{
GDataGContactWebsite *website, *website2;
GError *error = NULL;
const gchar *content_type;
website = GDATA_GCONTACT_WEBSITE (gdata_parsable_new_from_xml (GDATA_TYPE_GCONTACT_WEBSITE,
"<gContact:website xmlns:gContact='http://schemas.google.com/contact/2008' href='http://example.com/' rel='work' primary='true' "
"label='<Markup> blog'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GCONTACT_WEBSITE (website));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gcontact_website_get_uri (website), ==, "http://example.com/");
g_assert_cmpstr (gdata_gcontact_website_get_relation_type (website), ==, GDATA_GCONTACT_WEBSITE_WORK);
g_assert_cmpstr (gdata_gcontact_website_get_label (website), ==, "<Markup> blog");
g_assert (gdata_gcontact_website_is_primary (website) == TRUE);
/* Compare it against another identical website */
website2 = gdata_gcontact_website_new ("http://example.com/", GDATA_GCONTACT_WEBSITE_WORK, "<Markup> blog", TRUE);
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (website), GDATA_COMPARABLE (website2)), ==, 0);
/* …and a different one */
gdata_gcontact_website_set_uri (website2, "http://somewhereelse.com/");
g_assert_cmpint (gdata_comparable_compare (GDATA_COMPARABLE (website), GDATA_COMPARABLE (website2)), !=, 0);
g_object_unref (website2);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (website));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is the same */
gdata_test_assert_xml (website,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:website xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' "
"href='http://example.com/' rel='work' label='<Markup> blog' primary='true'/>");
g_object_unref (website);
/* Now parse a website with less information available */
website = GDATA_GCONTACT_WEBSITE (gdata_parsable_new_from_xml (GDATA_TYPE_GCONTACT_WEBSITE,
"<gContact:website xmlns:gContact='http://schemas.google.com/contact/2008' href='http://test.com/' rel='ftp'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GCONTACT_WEBSITE (website));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gcontact_website_get_uri (website), ==, "http://test.com/");
g_assert_cmpstr (gdata_gcontact_website_get_relation_type (website), ==, GDATA_GCONTACT_WEBSITE_FTP);
g_assert (gdata_gcontact_website_get_label (website) == NULL);
g_assert (gdata_gcontact_website_is_primary (website) == FALSE);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (website));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is still OK */
gdata_test_assert_xml (website,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:website xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' "
"href='http://test.com/' rel='ftp' primary='false'/>");
g_object_unref (website);
}
static void
test_gcontact_website_label (void)
{
GDataGContactWebsite *website;
GError *error = NULL;
const gchar *content_type;
g_test_bug ("659016");
/* Parse a website with a label but no rel. */
website = GDATA_GCONTACT_WEBSITE (gdata_parsable_new_from_xml (GDATA_TYPE_GCONTACT_WEBSITE,
"<gContact:website xmlns:gContact='http://schemas.google.com/contact/2008' href='http://test.com/' label='Custom'/>", -1, &error));
g_assert_no_error (error);
g_assert (GDATA_IS_GCONTACT_WEBSITE (website));
g_clear_error (&error);
/* Check the properties */
g_assert_cmpstr (gdata_gcontact_website_get_uri (website), ==, "http://test.com/");
g_assert_cmpstr (gdata_gcontact_website_get_relation_type (website), ==, NULL);
g_assert_cmpstr (gdata_gcontact_website_get_label (website), ==, "Custom");
g_assert (gdata_gcontact_website_is_primary (website) == FALSE);
content_type = gdata_parsable_get_content_type (GDATA_PARSABLE (website));
g_assert_cmpstr (content_type, ==, "application/atom+xml");
/* Check the outputted XML is still OK */
gdata_test_assert_xml (website,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:website xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' "
"href='http://test.com/' label='Custom' primary='false'/>");
g_object_unref (website);
}
static void
test_gcontact_website_error_handling (void)
{
GDataGContactWebsite *website;
GError *error = NULL;
#define TEST_XML_ERROR_HANDLING(x) website = GDATA_GCONTACT_WEBSITE (gdata_parsable_new_from_xml (GDATA_TYPE_GCONTACT_WEBSITE,\
"<gContact:website xmlns:gContact='http://schemas.google.com/contact/2008' "\
x\
"/>", -1, &error));\
g_assert_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR);\
g_assert (website == NULL);\
g_clear_error (&error)
TEST_XML_ERROR_HANDLING ("rel='work'"); /* no href */
TEST_XML_ERROR_HANDLING ("rel='work' href=''"); /* empty href */
TEST_XML_ERROR_HANDLING ("href='http://example.com/'"); /* no rel or label */
TEST_XML_ERROR_HANDLING ("href='http://example.com/' rel=''"); /* empty rel */
TEST_XML_ERROR_HANDLING ("href='http://example.com/' rel='profile' primary='not a boolean'"); /* invalid primary */
#undef TEST_XML_ERROR_HANDLING
}
static void
test_gcontact_website_escaping (void)
{
GDataGContactWebsite *website;
website = gdata_gcontact_website_new ("http://foo.com?foo&bar", "http://foo.com?foo&relation=bar", "Label & stuff", TRUE);
/* Check the outputted XML is escaped properly */
gdata_test_assert_xml (website,
"<?xml version='1.0' encoding='UTF-8'?>"
"<gContact:website xmlns='http://www.w3.org/2005/Atom' xmlns:gContact='http://schemas.google.com/contact/2008' "
"href='http://foo.com?foo&bar' rel='http://foo.com?foo&relation=bar' label='Label & stuff' "
"primary='true'/>");
g_object_unref (website);
}
int
main (int argc, char *argv[])
{
gdata_test_init (argc, argv);
g_test_add_func ("/tests/xml_comparison", test_xml_comparison);
g_test_add_func ("/service/network_error", test_service_network_error);
g_test_add_func ("/service/locale", test_service_locale);
g_test_add_func ("/entry/get_xml", test_entry_get_xml);
g_test_add_func ("/entry/get_json", test_entry_get_json);
g_test_add_func ("/entry/parse_xml", test_entry_parse_xml);
g_test_add_func ("/entry/parse_xml/kind_category", test_entry_parse_xml_kind_category);
g_test_add_func ("/entry/parse_json", test_entry_parse_json);
g_test_add_func ("/entry/error_handling/xml", test_entry_error_handling_xml);
g_test_add_func ("/entry/error_handling/json", test_entry_error_handling_json);
g_test_add_func ("/entry/escaping", test_entry_escaping);
g_test_add_func ("/entry/links/remove", test_entry_links_remove);
g_test_add_func ("/feed/parse_xml", test_feed_parse_xml);
g_test_add_func ("/feed/error_handling", test_feed_error_handling);
g_test_add_func ("/feed/escaping", test_feed_escaping);
g_test_add_func ("/query/categories", test_query_categories);
g_test_add_func ("/query/dates", test_query_dates);
g_test_add_func ("/query/strict", test_query_strict);
g_test_add_func ("/query/pagination", test_query_pagination);
g_test_add_func ("/query/properties", test_query_properties);
g_test_add_func ("/query/unicode", test_query_unicode);
g_test_add_func ("/query/etag", test_query_etag);
g_test_add_func ("/access-rule/get_xml", test_access_rule_get_xml);
g_test_add_func ("/access-rule/get_xml/with_key", test_access_rule_get_xml_with_key);
g_test_add_func ("/access-rule/error_handling", test_access_rule_error_handling);
g_test_add_func ("/access-rule/escaping", test_access_rule_escaping);
g_test_add_func ("/comparable", test_comparable);
g_test_add_func ("/color/parsing", test_color_parsing);
g_test_add_func ("/color/output", test_color_output);
g_test_add_func ("/atom/author", test_atom_author);
g_test_add_func ("/atom/author/error_handling", test_atom_author_error_handling);
g_test_add_func ("/atom/author/escaping", test_atom_author_escaping);
g_test_add_func ("/atom/category", test_atom_category);
g_test_add_func ("/atom/category/error_handling", test_atom_category_error_handling);
g_test_add_func ("/atom/category/escaping", test_atom_category_escaping);
g_test_add_func ("/atom/generator", test_atom_generator);
g_test_add_func ("/atom/generator/error_handling", test_atom_generator_error_handling);
g_test_add_func ("/atom/link", test_atom_link);
g_test_add_func ("/atom/link/error_handling", test_atom_link_error_handling);
g_test_add_func ("/atom/link/escaping", test_atom_link_escaping);
g_test_add_func ("/app/categories", test_app_categories);
g_test_add_func ("/gd/email_address", test_gd_email_address);
g_test_add_func ("/gd/email_address/escaping", test_gd_email_address_escaping);
g_test_add_func ("/gd/email_address/comparison", test_gd_email_address_comparison);
g_test_add_func ("/gd/im_address", test_gd_im_address);
g_test_add_func ("/gd/im_address/escaping", test_gd_im_address_escaping);
g_test_add_func ("/gd/im_address/comparison", test_gd_im_address_comparison);
g_test_add_func ("/gd/name", test_gd_name);
g_test_add_func ("/gd/name/empty_strings", test_gd_name_empty_strings);
g_test_add_func ("/gd/name/comparison", test_gd_name_comparison);
g_test_add_func ("/gd/organization", test_gd_organization);
g_test_add_func ("/gd/organization/escaping", test_gd_organization_escaping);
g_test_add_func ("/gd/organization/comparison", test_gd_organization_comparison);
g_test_add_func ("/gd/phone_number", test_gd_phone_number);
g_test_add_func ("/gd/phone_number/escaping", test_gd_phone_number_escaping);
g_test_add_func ("/gd/phone_number/comparison", test_gd_phone_number_comparison);
g_test_add_func ("/gd/postal_address", test_gd_postal_address);
g_test_add_func ("/gd/postal_address/escaping", test_gd_postal_address_escaping);
g_test_add_func ("/gd/postal_address/comparison", test_gd_postal_address_comparison);
g_test_add_func ("/gd/reminder", test_gd_reminder);
g_test_add_func ("/gd/reminder/escaping", test_gd_reminder_escaping);
g_test_add_func ("/gd/reminder/comparison", test_gd_reminder_comparison);
g_test_add_func ("/gd/when", test_gd_when);
g_test_add_func ("/gd/when/escaping", test_gd_when_escaping);
g_test_add_func ("/gd/when/comparison", test_gd_when_comparison);
g_test_add_func ("/gd/where", test_gd_where);
g_test_add_func ("/gd/where/escaping", test_gd_where_escaping);
g_test_add_func ("/gd/where/comparison", test_gd_where_comparison);
g_test_add_func ("/gd/who", test_gd_who);
g_test_add_func ("/gd/who/escaping", test_gd_who_escaping);
g_test_add_func ("/gd/who/comparison", test_gd_who_comparison);
g_test_add_func ("/media/category", test_media_category);
g_test_add_func ("/media/category/escaping", test_media_category_escaping);
g_test_add_func ("/media/content", test_media_content);
g_test_add_func ("/media/credit", test_media_credit);
/* g_test_add_func ("/media/group", test_media_group); */
g_test_add_func ("/media/thumbnail", test_media_thumbnail);
/*g_test_add_data_func ("/media/thumbnail/parse_time", "", test_media_thumbnail_parse_time);
g_test_add_data_func ("/media/thumbnail/parse_time", "de_DE", test_media_thumbnail_parse_time);*/
g_test_add_func ("/gcontact/calendar", test_gcontact_calendar);
g_test_add_func ("/gcontact/calendar/error_handling", test_gcontact_calendar_error_handling);
g_test_add_func ("/gcontact/calendar/escaping", test_gcontact_calendar_escaping);
g_test_add_func ("/gcontact/event", test_gcontact_event);
g_test_add_func ("/gcontact/event/error_handling", test_gcontact_event_error_handling);
g_test_add_func ("/gcontact/event/escaping", test_gcontact_event_escaping);
g_test_add_func ("/gcontact/external_id", test_gcontact_external_id);
g_test_add_func ("/gcontact/external_id/error_handling", test_gcontact_external_id_error_handling);
g_test_add_func ("/gcontact/external_id/escaping", test_gcontact_external_id_escaping);
g_test_add_func ("/gcontact/jot", test_gcontact_jot);
g_test_add_func ("/gcontact/jot/error_handling", test_gcontact_jot_error_handling);
g_test_add_func ("/gcontact/jot/escaping", test_gcontact_jot_escaping);
g_test_add_func ("/gcontact/language", test_gcontact_language);
g_test_add_func ("/gcontact/language/error_handling", test_gcontact_language_error_handling);
g_test_add_func ("/gcontact/language/escaping", test_gcontact_language_escaping);
g_test_add_func ("/gcontact/relation", test_gcontact_relation);
g_test_add_func ("/gcontact/relation/error_handling", test_gcontact_relation_error_handling);
g_test_add_func ("/gcontact/relation/escaping", test_gcontact_relation_escaping);
g_test_add_func ("/gcontact/website", test_gcontact_website);
g_test_add_func ("/gcontact/website/label", test_gcontact_website_label);
g_test_add_func ("/gcontact/website/error_handling", test_gcontact_website_error_handling);
g_test_add_func ("/gcontact/website/escaping", test_gcontact_website_escaping);
return g_test_run ();
}