#!/usr/bin/python
# -*-*- encoding: utf-8 -*-*-
#
# Copyright (C) 2006 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


__author__ = 'j.s@google.com (Jeff Scudder)'


import sys
import unittest
try:
  from xml.etree import ElementTree
except ImportError:
  from elementtree import ElementTree
import atom
from gdata import test_data
import gdata.test_config as conf


class AuthorTest(unittest.TestCase):
  
  def setUp(self):
    self.author = atom.Author()
    
  def testEmptyAuthorShouldHaveEmptyExtensionsList(self):
    self.assert_(isinstance(self.author.extension_elements, list))
    self.assert_(len(self.author.extension_elements) == 0)
    
  def testNormalAuthorShouldHaveNoExtensionElements(self):
    self.author.name = atom.Name(text='Jeff Scudder')
    self.assert_(self.author.name.text == 'Jeff Scudder')
    self.assert_(len(self.author.extension_elements) == 0)
    new_author = atom.AuthorFromString(self.author.ToString())
    self.assert_(len(self.author.extension_elements) == 0)
    
    self.author.extension_elements.append(atom.ExtensionElement(
        'foo', text='bar'))
    self.assert_(len(self.author.extension_elements) == 1)
    self.assert_(self.author.name.text == 'Jeff Scudder')
    new_author = atom.AuthorFromString(self.author.ToString())
    self.assert_(len(self.author.extension_elements) == 1)
    self.assert_(new_author.name.text == 'Jeff Scudder')

  def testEmptyAuthorToAndFromStringShouldMatch(self):
    string_from_author = self.author.ToString()
    new_author = atom.AuthorFromString(string_from_author)
    string_from_new_author = new_author.ToString()
    self.assert_(string_from_author == string_from_new_author)
    
  def testAuthorWithNameToAndFromStringShouldMatch(self):
    self.author.name = atom.Name()
    self.author.name.text = 'Jeff Scudder'
    string_from_author = self.author.ToString()
    new_author = atom.AuthorFromString(string_from_author)
    string_from_new_author = new_author.ToString()
    self.assert_(string_from_author == string_from_new_author)
    self.assert_(self.author.name.text == new_author.name.text)
  
  def testExtensionElements(self):
    self.author.extension_attributes['foo1'] = 'bar'
    self.author.extension_attributes['foo2'] = 'rab'
    self.assert_(self.author.extension_attributes['foo1'] == 'bar')
    self.assert_(self.author.extension_attributes['foo2'] == 'rab')
    new_author = atom.AuthorFromString(self.author.ToString())
    self.assert_(new_author.extension_attributes['foo1'] == 'bar')
    self.assert_(new_author.extension_attributes['foo2'] == 'rab')
    
  def testConvertFullAuthorToAndFromString(self):
    author = atom.AuthorFromString(test_data.TEST_AUTHOR)
    self.assert_(author.name.text == 'John Doe')
    self.assert_(author.email.text == 'johndoes@someemailadress.com')
    self.assert_(author.uri.text == 'http://www.google.com')
    
    
class EmailTest(unittest.TestCase):
  
  def setUp(self):
    self.email = atom.Email()
    
  def testEmailToAndFromString(self):
    self.email.text = 'This is a test'
    new_email = atom.EmailFromString(self.email.ToString())
    self.assert_(self.email.text == new_email.text)
    self.assert_(self.email.extension_elements == 
        new_email.extension_elements)
    
  
class NameTest(unittest.TestCase):

  def setUp(self):
    self.name = atom.Name()
    
  def testEmptyNameToAndFromStringShouldMatch(self):
    string_from_name = self.name.ToString()
    new_name = atom.NameFromString(string_from_name)
    string_from_new_name = new_name.ToString()
    self.assert_(string_from_name == string_from_new_name)
    
  def testText(self):
    self.assert_(self.name.text is None)
    self.name.text = 'Jeff Scudder'
    self.assert_(self.name.text == 'Jeff Scudder')
    new_name = atom.NameFromString(self.name.ToString())
    self.assert_(new_name.text == self.name.text)
    
  def testExtensionElements(self):
    self.name.extension_attributes['foo'] = 'bar'
    self.assert_(self.name.extension_attributes['foo'] == 'bar')
    new_name = atom.NameFromString(self.name.ToString())
    self.assert_(new_name.extension_attributes['foo'] == 'bar')
    
    
class ExtensionElementTest(unittest.TestCase):
  
  def setUp(self):
    self.ee = atom.ExtensionElement('foo')
    
  def testEmptyEEShouldProduceEmptyString(self):
    pass
    
  def testEEParsesTreeCorrectly(self):
    deep_tree = atom.ExtensionElementFromString(test_data.EXTENSION_TREE)
    self.assert_(deep_tree.tag == 'feed')
    self.assert_(deep_tree.namespace == 'http://www.w3.org/2005/Atom')
    self.assert_(deep_tree.children[0].tag == 'author')
    self.assert_(deep_tree.children[0].namespace == 'http://www.google.com')
    self.assert_(deep_tree.children[0].children[0].tag == 'name')
    self.assert_(deep_tree.children[0].children[0].namespace == 
        'http://www.google.com')
    self.assert_(deep_tree.children[0].children[0].text.strip() == 'John Doe')
    self.assert_(deep_tree.children[0].children[0].children[0].text.strip() ==
        'Bar')
    foo = deep_tree.children[0].children[0].children[0]
    self.assert_(foo.tag == 'foo')
    self.assert_(foo.namespace == 'http://www.google.com')
    self.assert_(foo.attributes['up'] == 'down')
    self.assert_(foo.attributes['yes'] == 'no')
    self.assert_(foo.children == [])
  
  def testEEToAndFromStringShouldMatch(self):
    string_from_ee = self.ee.ToString()
    new_ee = atom.ExtensionElementFromString(string_from_ee)
    string_from_new_ee = new_ee.ToString()
    self.assert_(string_from_ee == string_from_new_ee)
    
    deep_tree = atom.ExtensionElementFromString(test_data.EXTENSION_TREE)    
    string_from_deep_tree = deep_tree.ToString()
    new_deep_tree = atom.ExtensionElementFromString(string_from_deep_tree)
    string_from_new_deep_tree = new_deep_tree.ToString()
    self.assert_(string_from_deep_tree == string_from_new_deep_tree)
    
    
class LinkTest(unittest.TestCase):
  
  def setUp(self):
    self.link = atom.Link()
    
  def testLinkToAndFromString(self):
    self.link.href = 'test href'
    self.link.hreflang = 'english'
    self.link.type = 'text/html'
    self.link.extension_attributes['foo'] = 'bar'
    self.assert_(self.link.href == 'test href')
    self.assert_(self.link.hreflang == 'english')
    self.assert_(self.link.type == 'text/html')
    self.assert_(self.link.extension_attributes['foo'] == 'bar')
    new_link = atom.LinkFromString(self.link.ToString())
    self.assert_(self.link.href == new_link.href)
    self.assert_(self.link.type == new_link.type)
    self.assert_(self.link.hreflang == new_link.hreflang)
    self.assert_(self.link.extension_attributes['foo'] == 
        new_link.extension_attributes['foo'])

  def testLinkType(self):
    test_link = atom.Link(link_type='text/html')
    self.assert_(test_link.type == 'text/html')


class GeneratorTest(unittest.TestCase):

  def setUp(self):
    self.generator = atom.Generator()

  def testGeneratorToAndFromString(self):
    self.generator.uri = 'www.google.com'
    self.generator.version = '1.0'
    self.generator.extension_attributes['foo'] = 'bar'
    self.assert_(self.generator.uri == 'www.google.com')
    self.assert_(self.generator.version == '1.0')
    self.assert_(self.generator.extension_attributes['foo'] == 'bar')
    new_generator = atom.GeneratorFromString(self.generator.ToString())
    self.assert_(self.generator.uri == new_generator.uri)
    self.assert_(self.generator.version == new_generator.version)
    self.assert_(self.generator.extension_attributes['foo'] ==
        new_generator.extension_attributes['foo'])


class TitleTest(unittest.TestCase):

  def setUp(self):
    self.title = atom.Title()

  def testTitleToAndFromString(self):
    self.title.type = 'text'
    self.title.text = 'Less: <'
    self.assert_(self.title.type == 'text')
    self.assert_(self.title.text == 'Less: <')
    new_title = atom.TitleFromString(self.title.ToString())
    self.assert_(self.title.type == new_title.type)
    self.assert_(self.title.text == new_title.text)


class SubtitleTest(unittest.TestCase):

  def setUp(self):
    self.subtitle = atom.Subtitle()

  def testTitleToAndFromString(self):
    self.subtitle.type = 'text'
    self.subtitle.text = 'sub & title'
    self.assert_(self.subtitle.type == 'text')
    self.assert_(self.subtitle.text == 'sub & title')
    new_subtitle = atom.SubtitleFromString(self.subtitle.ToString())
    self.assert_(self.subtitle.type == new_subtitle.type)
    self.assert_(self.subtitle.text == new_subtitle.text)


class SummaryTest(unittest.TestCase):

  def setUp(self):
    self.summary = atom.Summary()

  def testTitleToAndFromString(self):
    self.summary.type = 'text'
    self.summary.text = 'Less: <'
    self.assert_(self.summary.type == 'text')
    self.assert_(self.summary.text == 'Less: <')
    new_summary = atom.SummaryFromString(self.summary.ToString())
    self.assert_(self.summary.type == new_summary.type)
    self.assert_(self.summary.text == new_summary.text)


class CategoryTest(unittest.TestCase):

  def setUp(self):
    self.category = atom.Category()

  def testCategoryToAndFromString(self):
    self.category.term = 'x'
    self.category.scheme = 'y'
    self.category.label = 'z'
    self.assert_(self.category.term == 'x')
    self.assert_(self.category.scheme == 'y')
    self.assert_(self.category.label == 'z')
    new_category = atom.CategoryFromString(self.category.ToString())
    self.assert_(self.category.term == new_category.term)
    self.assert_(self.category.scheme == new_category.scheme)
    self.assert_(self.category.label == new_category.label)


class ContributorTest(unittest.TestCase):

  def setUp(self):
    self.contributor = atom.Contributor()

  def testContributorToAndFromString(self):
    self.contributor.name = atom.Name(text='J Scud')
    self.contributor.email = atom.Email(text='nobody@nowhere')
    self.contributor.uri = atom.Uri(text='http://www.google.com')
    self.assert_(self.contributor.name.text == 'J Scud')
    self.assert_(self.contributor.email.text == 'nobody@nowhere')
    self.assert_(self.contributor.uri.text == 'http://www.google.com')
    new_contributor = atom.ContributorFromString(self.contributor.ToString())
    self.assert_(self.contributor.name.text == new_contributor.name.text)
    self.assert_(self.contributor.email.text == new_contributor.email.text)
    self.assert_(self.contributor.uri.text == new_contributor.uri.text)


class IdTest(unittest.TestCase):

  def setUp(self):
    self.my_id = atom.Id()

  def testIdToAndFromString(self):
    self.my_id.text = 'my nifty id'
    self.assert_(self.my_id.text == 'my nifty id')
    new_id = atom.IdFromString(self.my_id.ToString())
    self.assert_(self.my_id.text == new_id.text)


class IconTest(unittest.TestCase):

  def setUp(self):
    self.icon = atom.Icon()

  def testIconToAndFromString(self):
    self.icon.text = 'my picture'
    self.assert_(self.icon.text == 'my picture')
    new_icon = atom.IconFromString(str(self.icon))
    self.assert_(self.icon.text == new_icon.text)


class LogoTest(unittest.TestCase):

  def setUp(self):
    self.logo = atom.Logo()

  def testLogoToAndFromString(self):
    self.logo.text = 'my logo'
    self.assert_(self.logo.text == 'my logo')
    new_logo = atom.LogoFromString(self.logo.ToString())
    self.assert_(self.logo.text == new_logo.text)


class RightsTest(unittest.TestCase):

  def setUp(self):
    self.rights = atom.Rights()

  def testContributorToAndFromString(self):
    self.rights.text = 'you have the right to remain silent'
    self.rights.type = 'text'
    self.assert_(self.rights.text == 'you have the right to remain silent')
    self.assert_(self.rights.type == 'text')
    new_rights = atom.RightsFromString(self.rights.ToString())
    self.assert_(self.rights.text == new_rights.text)
    self.assert_(self.rights.type == new_rights.type)


class UpdatedTest(unittest.TestCase):

  def setUp(self):
    self.updated = atom.Updated()

  def testUpdatedToAndFromString(self):
    self.updated.text = 'my time'
    self.assert_(self.updated.text == 'my time')
    new_updated = atom.UpdatedFromString(self.updated.ToString())
    self.assert_(self.updated.text == new_updated.text)


class PublishedTest(unittest.TestCase):

  def setUp(self):
    self.published = atom.Published()

  def testPublishedToAndFromString(self):
    self.published.text = 'pub time'
    self.assert_(self.published.text == 'pub time')
    new_published = atom.PublishedFromString(self.published.ToString())
    self.assert_(self.published.text == new_published.text)


class FeedEntryParentTest(unittest.TestCase):
  """The test accesses hidden methods in atom.FeedEntryParent"""

  def testConvertToAndFromElementTree(self):
    # Use entry because FeedEntryParent doesn't have a tag or namespace.
    original = atom.Entry()
    copy = atom.FeedEntryParent()
 
    original.author.append(atom.Author(name=atom.Name(text='J Scud')))
    self.assert_(original.author[0].name.text == 'J Scud')
    self.assert_(copy.author == [])

    original.id = atom.Id(text='test id')
    self.assert_(original.id.text == 'test id')
    self.assert_(copy.id is None)

    copy._HarvestElementTree(original._ToElementTree())
    self.assert_(original.author[0].name.text == copy.author[0].name.text)
    self.assert_(original.id.text == copy.id.text)


class EntryTest(unittest.TestCase):

  def testConvertToAndFromString(self):
    entry = atom.Entry()
    entry.author.append(atom.Author(name=atom.Name(text='js')))
    entry.title = atom.Title(text='my test entry')
    self.assert_(entry.author[0].name.text == 'js')
    self.assert_(entry.title.text == 'my test entry')
    new_entry = atom.EntryFromString(entry.ToString())
    self.assert_(new_entry.author[0].name.text == 'js')
    self.assert_(new_entry.title.text == 'my test entry')

  def testEntryCorrectlyConvertsActualData(self):
    entry = atom.EntryFromString(test_data.XML_ENTRY_1)
    self.assert_(entry.category[0].scheme == 
        'http://base.google.com/categories/itemtypes')
    self.assert_(entry.category[0].term == 'products')
    self.assert_(entry.id.text == '    http://www.google.com/test/id/url   ')
    self.assert_(entry.title.text == 'Testing 2000 series laptop')
    self.assert_(entry.title.type == 'text')
    self.assert_(entry.content.type == 'xhtml')
    #TODO check all other values for the test entry

  def testAppControl(self):
    entry = atom.EntryFromString(test_data.TEST_BASE_ENTRY)
    self.assertEquals(entry.control.draft.text, 'yes')
    self.assertEquals(len(entry.control.extension_elements), 1)
    self.assertEquals(entry.control.extension_elements[0].tag, 'disapproved')


class ControlTest(unittest.TestCase):

  def testConvertToAndFromString(self):
    control = atom.Control()
    control.text = 'some text'
    control.draft = atom.Draft(text='yes')
    self.assertEquals(control.draft.text, 'yes')
    self.assertEquals(control.text, 'some text')
    self.assertEquals(isinstance(control.draft, atom.Draft), True)
    new_control = atom.ControlFromString(str(control))
    self.assertEquals(control.draft.text, new_control.draft.text)
    self.assertEquals(control.text, new_control.text)
    self.assertEquals(isinstance(new_control.draft, atom.Draft), True)


class DraftTest(unittest.TestCase):

  def testConvertToAndFromString(self):
    draft = atom.Draft()
    draft.text = 'maybe'
    draft.extension_attributes['foo'] = 'bar'
    self.assertEquals(draft.text, 'maybe')
    self.assertEquals(draft.extension_attributes['foo'], 'bar')
    new_draft = atom.DraftFromString(str(draft))
    self.assertEquals(draft.text, new_draft.text)
    self.assertEquals(draft.extension_attributes['foo'], 
        new_draft.extension_attributes['foo'])
    
    
    
class SourceTest(unittest.TestCase):

  def testConvertToAndFromString(self):
    source = atom.Source()
    source.author.append(atom.Author(name=atom.Name(text='js')))
    source.title = atom.Title(text='my test source')
    source.generator = atom.Generator(text='gen')
    self.assert_(source.author[0].name.text == 'js')
    self.assert_(source.title.text == 'my test source')
    self.assert_(source.generator.text == 'gen')
    new_source = atom.SourceFromString(source.ToString())
    self.assert_(new_source.author[0].name.text == 'js')
    self.assert_(new_source.title.text == 'my test source')
    self.assert_(new_source.generator.text == 'gen')


class FeedTest(unittest.TestCase):

  def testConvertToAndFromString(self):
    feed = atom.Feed()
    feed.author.append(atom.Author(name=atom.Name(text='js')))
    feed.title = atom.Title(text='my test source')
    feed.generator = atom.Generator(text='gen')
    feed.entry.append(atom.Entry(author=[atom.Author(name=atom.Name(
        text='entry author'))]))
    self.assert_(feed.author[0].name.text == 'js')
    self.assert_(feed.title.text == 'my test source')
    self.assert_(feed.generator.text == 'gen')
    self.assert_(feed.entry[0].author[0].name.text == 'entry author')
    new_feed = atom.FeedFromString(feed.ToString())
    self.assert_(new_feed.author[0].name.text == 'js')
    self.assert_(new_feed.title.text == 'my test source')
    self.assert_(new_feed.generator.text == 'gen')    
    self.assert_(new_feed.entry[0].author[0].name.text == 'entry author')

  def testPreserveEntryOrder(self):
    test_xml = (
        '<feed xmlns="http://www.w3.org/2005/Atom">'
          '<entry><id>0</id></entry>'
          '<entry><id>1</id></entry>'
          '<title>Testing Order</title>'
          '<entry><id>2</id></entry>'
          '<entry><id>3</id></entry>'
          '<entry><id>4</id></entry>'
          '<entry><id>5</id></entry>'
          '<entry><id>6</id></entry>'
          '<entry><id>7</id></entry>'
          '<author/>'
          '<entry><id>8</id></entry>'
          '<id>feed_id</id>'
          '<entry><id>9</id></entry>'
        '</feed>')
    feed = atom.FeedFromString(test_xml)
    for i in xrange(10):
      self.assert_(feed.entry[i].id.text == str(i))
    feed = atom.FeedFromString(feed.ToString())
    for i in xrange(10):
      self.assert_(feed.entry[i].id.text == str(i))
    temp = feed.entry[3]
    feed.entry[3] = feed.entry[4]
    feed.entry[4] = temp
    self.assert_(feed.entry[2].id.text == '2')
    self.assert_(feed.entry[3].id.text == '4')
    self.assert_(feed.entry[4].id.text == '3')
    self.assert_(feed.entry[5].id.text == '5')
    feed = atom.FeedFromString(feed.ToString())
    self.assert_(feed.entry[2].id.text == '2')
    self.assert_(feed.entry[3].id.text == '4')
    self.assert_(feed.entry[4].id.text == '3')
    self.assert_(feed.entry[5].id.text == '5')


class ContentEntryParentTest(unittest.TestCase):
  """The test accesses hidden methods in atom.FeedEntryParent"""

  def setUp(self):
    self.content = atom.Content()

  def testConvertToAndFromElementTree(self):
    self.content.text = 'my content'
    self.content.type = 'text'
    self.content.src = 'my source'
    self.assert_(self.content.text == 'my content')
    self.assert_(self.content.type == 'text')
    self.assert_(self.content.src == 'my source')
    new_content = atom.ContentFromString(self.content.ToString())
    self.assert_(self.content.text == new_content.text)
    self.assert_(self.content.type == new_content.type)
    self.assert_(self.content.src == new_content.src)

  def testContentConstructorSetsSrc(self):
    new_content = atom.Content(src='abcd')
    self.assertEquals(new_content.src, 'abcd')


class PreserveUnkownElementTest(unittest.TestCase):
  """Tests correct preservation of XML elements which are non Atom"""
  
  def setUp(self):
    self.feed = atom.FeedFromString(test_data.GBASE_ATTRIBUTE_FEED)

  def testCaptureOpenSearchElements(self):
    self.assertEquals(self.feed.FindExtensions('totalResults')[0].tag,
        'totalResults')
    self.assertEquals(self.feed.FindExtensions('totalResults')[0].namespace,
        'http://a9.com/-/spec/opensearchrss/1.0/')
    open_search_extensions = self.feed.FindExtensions(
        namespace='http://a9.com/-/spec/opensearchrss/1.0/')
    self.assertEquals(len(open_search_extensions), 3)
    for element in open_search_extensions:
      self.assertEquals(element.namespace, 
          'http://a9.com/-/spec/opensearchrss/1.0/')

  def testCaptureMetaElements(self):
    meta_elements = self.feed.entry[0].FindExtensions(
        namespace='http://base.google.com/ns-metadata/1.0')
    self.assertEquals(len(meta_elements), 1)
    self.assertEquals(meta_elements[0].attributes['count'], '4416629')
    self.assertEquals(len(meta_elements[0].children), 10)

  def testCaptureMetaChildElements(self):
    meta_elements = self.feed.entry[0].FindExtensions(
        namespace='http://base.google.com/ns-metadata/1.0')
    meta_children = meta_elements[0].FindChildren(
        namespace='http://base.google.com/ns-metadata/1.0')
    self.assertEquals(len(meta_children), 10)
    for child in meta_children:
      self.assertEquals(child.tag, 'value')


class LinkFinderTest(unittest.TestCase):
  
  def setUp(self):
    self.entry = atom.EntryFromString(test_data.XML_ENTRY_1)

  def testLinkFinderGetsLicenseLink(self):
    self.assertEquals(isinstance(self.entry.GetLicenseLink(), atom.Link), 
                      True)
    self.assertEquals(self.entry.GetLicenseLink().href,
        'http://creativecommons.org/licenses/by-nc/2.5/rdf')
    self.assertEquals(self.entry.GetLicenseLink().rel, 'license')

  def testLinkFinderGetsAlternateLink(self):
    self.assertEquals(isinstance(self.entry.GetAlternateLink(), atom.Link), 
                      True)
    self.assertEquals(self.entry.GetAlternateLink().href,
        'http://www.provider-host.com/123456789')
    self.assertEquals(self.entry.GetAlternateLink().rel, 'alternate')


class AtomBaseTest(unittest.TestCase):

   def testAtomBaseConvertsExtensions(self):
     # Using Id because it adds no additional members.
     atom_base = atom.Id()
     extension_child = atom.ExtensionElement('foo', namespace='http://ns0.com')
     extension_grandchild = atom.ExtensionElement('bar', 
         namespace='http://ns0.com')
     extension_child.children.append(extension_grandchild)
     atom_base.extension_elements.append(extension_child)
     self.assertEquals(len(atom_base.extension_elements), 1)
     self.assertEquals(len(atom_base.extension_elements[0].children), 1)
     self.assertEquals(atom_base.extension_elements[0].tag, 'foo')
     self.assertEquals(atom_base.extension_elements[0].children[0].tag, 'bar')
     
     element_tree = atom_base._ToElementTree()
     self.assert_(element_tree.find('{http://ns0.com}foo') is not None)
     self.assert_(element_tree.find('{http://ns0.com}foo').find(
         '{http://ns0.com}bar') is not None)


class UtfParsingTest(unittest.TestCase):
  
  def setUp(self):
    self.test_xml = u"""<?xml version="1.0" encoding="utf-8"?>
<entry xmlns='http://www.w3.org/2005/Atom'>
  <id>http://www.google.com/test/id/url</id>
  <title type='\u03B1\u03BB\u03C6\u03B1'>\u03B1\u03BB\u03C6\u03B1</title>
</entry>"""

  def testMemberStringEncoding(self):
    atom_entry = atom.EntryFromString(self.test_xml)
    #self.assertEqual(atom_entry.title.type.encode('utf-8'), 
    #    u'\u03B1\u03BB\u03C6\u03B1'.encode('utf-8'))
    #self.assertEqual(atom_entry.title.text.encode('utf-8'), 
    #    u'\u03B1\u03BB\u03C6\u03B1'.encode('utf-8'))

    # Setting object members to unicode strings is supported even if 
    # MEMBER_STRING_ENCODING is set 'utf-8' (should it be?)
    atom_entry.title.type = u'\u03B1\u03BB\u03C6\u03B1'
    xml = atom_entry.ToString()
    self.assert_(u'\u03B1\u03BB\u03C6\u03B1'.encode('utf-8') in xml)

    # Make sure that we can use plain text when MEMBER_STRING_ENCODING is utf8
    atom_entry.title.type = "plain text"
    atom_entry.title.text = "more text"
    xml = atom_entry.ToString()
    self.assert_("plain text" in xml)
    self.assert_("more text" in xml)

    # Test something else than utf-8
    atom.MEMBER_STRING_ENCODING = 'iso8859_7'
    atom_entry = atom.EntryFromString(self.test_xml)
    self.assert_(atom_entry.title.type == u'\u03B1\u03BB\u03C6\u03B1'.encode(
        'iso8859_7'))
    self.assert_(atom_entry.title.text == u'\u03B1\u03BB\u03C6\u03B1'.encode(
        'iso8859_7'))

    # Test using unicode strings directly for object members
    atom.MEMBER_STRING_ENCODING = unicode
    atom_entry = atom.EntryFromString(self.test_xml)
    self.assert_(atom_entry.title.type == u'\u03B1\u03BB\u03C6\u03B1')
    self.assert_(atom_entry.title.text == u'\u03B1\u03BB\u03C6\u03B1')
    
    # Make sure that we can use plain text when MEMBER_STRING_ENCODING is 
    # unicode
    atom_entry.title.type = "plain text"
    atom_entry.title.text = "more text"
    xml = atom_entry.ToString()
    self.assert_("plain text" in xml)
    self.assert_("more text" in xml)

  def testConvertExampleXML(self):
    try:
      entry = atom.CreateClassFromXMLString(atom.Entry, 
          test_data.GBASE_STRING_ENCODING_ENTRY)
    except UnicodeDecodeError:
      self.fail('Error when converting XML')


class DeprecationDecoratorTest(unittest.TestCase):

  def testDeprecationWarning(self):
    def to_deprecate():
      return 5
    self.assertEqual(to_deprecate.func_name, 'to_deprecate')
    deprecated = atom.deprecated('test')(to_deprecate)
    self.assertNotEqual(to_deprecate, deprecated)
    # After decorating a function as deprecated, the function name should
    # still be the name of the original function.
    self.assertEqual(deprecated.func_name, 'to_deprecate')
    #@atom.deprecated()
    def also_deprecated():
      return 6
    also_deprecated = atom.deprecated()(also_deprecated)
    self.assertEqual(also_deprecated.func_name, 'also_deprecated')


def suite():
  return conf.build_suite([AuthorTest, EmailTest, NameTest, 
      ExtensionElementTest, LinkTest, GeneratorTest, TitleTest, SubtitleTest,
      SummaryTest, IdTest, IconTest, LogoTest, RightsTest, UpdatedTest,
      PublishedTest, FeedEntryParentTest, EntryTest, ContentEntryParentTest,
      PreserveUnkownElementTest, FeedTest, LinkFinderTest, AtomBaseTest, 
      UtfParsingTest, DeprecationDecoratorTest])


if __name__ == '__main__':
  unittest.main()