Code split into various python modules.

6 files changed, 1488 insertions, 2 deletions

diff --git a/test/exif.py b/test/exif.py
index d32e30d..44ae394 100644
--- a/test/exif.py
+++ b/test/exif.py
@@ -25,7 +25,10 @@
 # ******************************************************************************
 
 import unittest
-from pyexiv2 import ExifTag, ExifValueError, Rational
+
+from pyexiv2.exif import ExifTag, ExifValueError
+from pyexiv2.utils import Rational
+
 import datetime
 
 
diff --git a/test/iptc.py b/test/iptc.py
index ba02599..5473090 100644
--- a/test/iptc.py
+++ b/test/iptc.py
@@ -25,7 +25,10 @@
 # ******************************************************************************
 
 import unittest
-from pyexiv2 import IptcTag, IptcValueError, FixedOffset
+
+from pyexiv2.iptc import IptcTag, IptcValueError
+from pyexiv2.utils import FixedOffset
+
 import datetime
 
 
diff --git a/test/metadata.py b/test/metadata.py
new file mode 100644
index 0000000..af8646f
--- /dev/null
+++ b/test/metadata.py
@@ -0,0 +1,692 @@
+# -*- coding: utf-8 -*-
+
+# ******************************************************************************
+#
+# Copyright (C) 2009 Olivier Tilloy <olivier@tilloy.net>
+#
+# This file is part of the pyexiv2 distribution.
+#
+# pyexiv2 is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# pyexiv2 is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyexiv2; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, 5th Floor, Boston, MA 02110-1301 USA.
+#
+# Author: Olivier Tilloy <olivier@tilloy.net>
+#
+# ******************************************************************************
+
+import unittest
+
+from pyexiv2.metadata import ImageMetadata
+from pyexiv2.exif import ExifTag
+from pyexiv2.iptc import IptcTag
+from pyexiv2.xmp import XmpTag
+
+import datetime
+
+
+class ImageMock(object):
+
+    def __init__(self, filename):
+        self.filename = filename
+        self.read = False
+        self.written = False
+        self.tags = {'exif': {}, 'iptc': {}, 'xmp': {}}
+
+    def readMetadata(self):
+        self.read = True
+
+    def writeMetadata(self):
+        self.written = True
+
+    def exifKeys(self):
+        return self.tags['exif'].keys()
+
+    def getExifTag(self, key):
+        return self.tags['exif'][key]
+
+    def setExifTagValue(self, key, value):
+        self.tags['exif'][key] = value
+
+    def deleteExifTag(self, key):
+        try:
+            del self.tags['exif'][key]
+        except KeyError:
+            pass
+
+    def iptcKeys(self):
+        return self.tags['iptc'].keys()
+
+    def getIptcTag(self, key):
+        return self.tags['iptc'][key]
+
+    def setIptcTagValues(self, key, values):
+        self.tags['iptc'][key] = values
+
+    def deleteIptcTag(self, key):
+        try:
+            del self.tags['iptc'][key]
+        except KeyError:
+            pass
+
+    def xmpKeys(self):
+        return self.tags['xmp'].keys()
+
+    def getXmpTag(self, key):
+        return self.tags['xmp'][key]
+
+    def setXmpTagValue(self, key, value):
+        self.tags['xmp'][key] = value
+
+    def deleteXmpTag(self, key):
+        try:
+            del self.tags['xmp'][key]
+        except KeyError:
+            pass
+
+
+class TestImageMetadata(unittest.TestCase):
+
+    def setUp(self):
+        self.metadata = ImageMetadata('nofile')
+        self.metadata._instantiate_image = lambda filename: ImageMock(filename)
+
+    def _set_exif_tags(self):
+        tags = {}
+        tags['Exif.Image.Make'] = \
+            ('Exif.Image.Make', 'Make', 'Manufacturer', 'blabla', 'Ascii',
+             'EASTMAN KODAK COMPANY', 'EASTMAN KODAK COMPANY')
+        tags['Exif.Image.DateTime'] = \
+            ('Exif.Image.DateTime', 'DateTime', 'Date and Time', 'blabla',
+             'Ascii', '2009:02:09 13:33:20', '2009:02:09 13:33:20')
+        tags['Exif.Photo.ExifVersion'] = \
+            ('Exif.Photo.ExifVersion', 'ExifVersion', 'Exif Version', 'blabla',
+             'Undefined', '48 50 50 49 ', '2.21')
+        self.metadata._image.tags['exif'] = tags
+
+    def _set_iptc_tags(self):
+        tags = {}
+        tags['Iptc.Application2.Caption'] = \
+            ('Iptc.Application2.Caption', 'Caption', 'Caption',
+             'A textual description of the object data.', 'String',
+             ['blabla'])
+        tags['Iptc.Application2.DateCreated'] = \
+            ('Iptc.Application2.DateCreated', 'DateCreated', 'Date Created',
+             'Represented in the form CCYYMMDD to designate the date the ' \
+             'intellectual content of the object data was created rather ' \
+             'than the date of the creation of the physical representation. ' \
+             'Follows ISO 8601 standard.', 'Date', ['2004-07-13'])
+        self.metadata._image.tags['iptc'] = tags
+
+    def _set_xmp_tags(self):
+        tags = {}
+        tags['Xmp.dc.format'] = \
+            ('Xmp.dc.format', 'format', 'Format', 'The file format used when ' \
+             'saving the resource. Tools and applications should set this ' \
+             'property to the save format of the data. It may include ' \
+             'appropriate qualifiers.', 'MIMEType', 'image/jpeg')
+        tags['Xmp.dc.subject'] = \
+            ('Xmp.dc.subject', 'subject', 'Subject', 'An unordered array of ' \
+             'descriptive phrases or keywords that specify the topic of the ' \
+             'content of the resource.', 'bag Text', 'image, test, pyexiv2')
+        tags['Xmp.xmp.CreateDate'] = \
+            ('Xmp.xmp.CreateDate', 'CreateDate', 'Create Date',
+             'The date and time the resource was originally created.', 'Date',
+             '2005-09-07T15:07:40-07:00')
+        tags['Xmp.xmpMM.DocumentID'] = \
+            ('Xmp.xmpMM.DocumentID', 'DocumentID', 'Document ID',
+             'The common identifier for all versions and renditions of a ' \
+             'document. It should be based on a UUID; see Document and ' \
+             'Instance IDs below.', 'URI',
+             'uuid:9A3B7F52214211DAB6308A7391270C13')
+        self.metadata._image.tags['xmp'] = tags
+
+    ######################
+    # Test general methods
+    ######################
+
+    def test_read(self):
+        self.assertEqual(self.metadata._image, None)
+        self.metadata.read()
+        self.failIfEqual(self.metadata._image, None)
+        self.failUnless(self.metadata._image.read)
+
+    def test_write(self):
+        self.metadata.read()
+        self.failIf(self.metadata._image.written)
+        self.metadata.write()
+        self.failUnless(self.metadata._image.written)
+
+    ###########################
+    # Test EXIF-related methods
+    ###########################
+
+    def test_exif_keys(self):
+        self.metadata.read()
+        self._set_exif_tags()
+        self.assertEqual(self.metadata._keys['exif'], None)
+        keys = self.metadata.exif_keys
+        self.assertEqual(len(keys), 3)
+        self.assertEqual(self.metadata._keys['exif'], keys)
+
+    def test_get_exif_tag(self):
+        self.metadata.read()
+        self._set_exif_tags()
+        self.assertEqual(self.metadata._tags['exif'], {})
+        # Get an existing tag
+        key = 'Exif.Image.Make'
+        tag = self.metadata._get_exif_tag(key)
+        self.assertEqual(type(tag), ExifTag)
+        self.assertEqual(tag.metadata, self.metadata)
+        self.assertEqual(self.metadata._tags['exif'][key], tag)
+        # Try to get an nonexistent tag
+        key = 'Exif.Photo.Sharpness'
+        self.failUnlessRaises(KeyError, self.metadata._get_exif_tag, key)
+
+    def test_set_exif_tag_wrong(self):
+        self.metadata.read()
+        self._set_exif_tags()
+        self.assertEqual(self.metadata._tags['exif'], {})
+        # Try to set a tag with wrong type
+        tag = 'Not an exif tag'
+        self.failUnlessRaises(TypeError, self.metadata._set_exif_tag, tag)
+        self.assertEqual(self.metadata._tags['exif'], {})
+
+    def test_set_exif_tag_create(self):
+        self.metadata.read()
+        self._set_exif_tags()
+        self.assertEqual(self.metadata._tags['exif'], {})
+        # Create a new tag
+        tag = ExifTag('Exif.Thumbnail.Orientation', 'Orientation',
+                      'Orientation', 'The image orientation viewed in terms ' \
+                      'of rows and columns.', 'Short', '1', 'top, left')
+        self.assertEqual(tag.metadata, None)
+        self.metadata._set_exif_tag(tag)
+        self.assertEqual(tag.metadata, self.metadata)
+        self.assertEqual(self.metadata._tags['exif'], {tag.key: tag})
+        self.assert_(self.metadata._image.tags['exif'].has_key(tag.key))
+        self.assertEqual(self.metadata._image.tags['exif'][tag.key],
+                         tag.raw_value)
+
+    def test_set_exif_tag_overwrite(self):
+        self.metadata.read()
+        self._set_exif_tags()
+        self.assertEqual(self.metadata._tags['exif'], {})
+        # Overwrite an existing tag
+        tag = ExifTag('Exif.Image.DateTime', 'DateTime', 'Date and Time',
+                      'blabla', 'Ascii', '2009:03:20 20:32:00',
+                      '2009:03:20 20:32:00')
+        self.assertEqual(tag.metadata, None)
+        self.metadata._set_exif_tag(tag)
+        self.assertEqual(tag.metadata, self.metadata)
+        self.assertEqual(self.metadata._tags['exif'], {tag.key: tag})
+        self.assert_(self.metadata._image.tags['exif'].has_key(tag.key))
+        self.assertEqual(self.metadata._image.tags['exif'][tag.key],
+                         tag.raw_value)
+
+    def test_set_exif_tag_overwrite_already_cached(self):
+        self.metadata.read()
+        self._set_exif_tags()
+        self.assertEqual(self.metadata._tags['exif'], {})
+        # Overwrite an existing tag already cached
+        key = 'Exif.Photo.ExifVersion'
+        tag = self.metadata._get_exif_tag(key)
+        self.assertEqual(self.metadata._tags['exif'][key], tag)
+        new_tag = ExifTag(key, 'ExifVersion', 'Exif Version', 'blabla',
+                          'Undefined', '48 50 50 48 ', '2.20')
+        self.assertEqual(new_tag.metadata, None)
+        self.metadata._set_exif_tag(new_tag)
+        self.assertEqual(new_tag.metadata, self.metadata)
+        self.assertEqual(self.metadata._tags['exif'], {key: new_tag})
+        self.assert_(self.metadata._image.tags['exif'].has_key(key))
+        # Special case where the formatted value is used instead of the raw
+        # value.
+        self.assertEqual(self.metadata._image.tags['exif'][key], new_tag.fvalue)
+
+    def test_set_exif_tag_value_inexistent(self):
+        self.metadata.read()
+        self._set_exif_tags()
+        key = 'Exif.Photo.ExposureTime'
+        value = '1/500'
+        self.failUnlessRaises(KeyError, self.metadata._set_exif_tag_value,
+                              key, value)
+
+    def test_set_exif_tag_value_wrong_type(self):
+        self.metadata.read()
+        self._set_exif_tags()
+        key = 'Exif.Image.DateTime'
+        value = datetime.datetime(2009, 3, 24, 9, 37, 36)
+        self.failUnlessRaises(TypeError, self.metadata._set_exif_tag_value,
+                              key, value)
+
+    def test_set_exif_tag_value(self):
+        self.metadata.read()
+        self._set_exif_tags()
+        key = 'Exif.Image.DateTime'
+        tag = self.metadata._get_exif_tag(key)
+        value = '2009:03:24 09:37:36'
+        self.failIfEqual(self.metadata._image.tags['exif'][key], value)
+        self.metadata._set_exif_tag_value(key, value)
+        self.assertEqual(self.metadata._image.tags['exif'][key], value)
+
+    def test_delete_exif_tag_inexistent(self):
+        self.metadata.read()
+        self._set_exif_tags()
+        key = 'Exif.Image.Artist'
+        self.failUnlessRaises(KeyError, self.metadata._delete_exif_tag, key)
+
+    def test_delete_exif_tag_not_cached(self):
+        self.metadata.read()
+        self._set_exif_tags()
+        key = 'Exif.Image.DateTime'
+        self.assertEqual(self.metadata._tags['exif'], {})
+        self.assert_(self.metadata._image.tags['exif'].has_key(key))
+        self.metadata._delete_exif_tag(key)
+        self.assertEqual(self.metadata._tags['exif'], {})
+        self.failIf(self.metadata._image.tags['exif'].has_key(key))
+
+    def test_delete_exif_tag_cached(self):
+        self.metadata.read()
+        self._set_exif_tags()
+        key = 'Exif.Image.DateTime'
+        self.assert_(self.metadata._image.tags['exif'].has_key(key))
+        tag = self.metadata._get_exif_tag(key)
+        self.assertEqual(self.metadata._tags['exif'][key], tag)
+        self.metadata._delete_exif_tag(key)
+        self.assertEqual(self.metadata._tags['exif'], {})
+        self.failIf(self.metadata._image.tags['exif'].has_key(key))
+
+    ###########################
+    # Test IPTC-related methods
+    ###########################
+
+    def test_iptc_keys(self):
+        self.metadata.read()
+        self._set_iptc_tags()
+        self.assertEqual(self.metadata._keys['iptc'], None)
+        keys = self.metadata.iptc_keys
+        self.assertEqual(len(keys), 2)
+        self.assertEqual(self.metadata._keys['iptc'], keys)
+
+    def test_get_iptc_tag(self):
+        self.metadata.read()
+        self._set_iptc_tags()
+        self.assertEqual(self.metadata._tags['iptc'], {})
+        # Get an existing tag
+        key = 'Iptc.Application2.DateCreated'
+        tag = self.metadata._get_iptc_tag(key)
+        self.assertEqual(type(tag), IptcTag)
+        self.assertEqual(tag.metadata, self.metadata)
+        self.assertEqual(self.metadata._tags['iptc'][key], tag)
+        # Try to get an nonexistent tag
+        key = 'Iptc.Application2.Copyright'
+        self.failUnlessRaises(KeyError, self.metadata._get_iptc_tag, key)
+
+    def test_set_iptc_tag_wrong(self):
+        self.metadata.read()
+        self._set_iptc_tags()
+        self.assertEqual(self.metadata._tags['iptc'], {})
+        # Try to set a tag with wrong type
+        tag = 'Not an iptc tag'
+        self.failUnlessRaises(TypeError, self.metadata._set_iptc_tag, tag)
+        self.assertEqual(self.metadata._tags['iptc'], {})
+
+    def test_set_iptc_tag_create(self):
+        self.metadata.read()
+        self._set_iptc_tags()
+        self.assertEqual(self.metadata._tags['iptc'], {})
+        # Create a new tag
+        tag = IptcTag('Iptc.Application2.Writer', 'Writer', 'Writer',
+                      'Identification of the name of the person involved in ' \
+                      'the writing, editing or correcting the object data or ' \
+                      'caption/abstract.', 'String', ['Nobody'])
+        self.assertEqual(tag.metadata, None)
+        self.metadata._set_iptc_tag(tag)
+        self.assertEqual(tag.metadata, self.metadata)
+        self.assertEqual(self.metadata._tags['iptc'], {tag.key: tag})
+        self.assert_(self.metadata._image.tags['iptc'].has_key(tag.key))
+        self.assertEqual(self.metadata._image.tags['iptc'][tag.key],
+                         tag.raw_value)
+
+    def test_set_iptc_tag_overwrite(self):
+        self.metadata.read()
+        self._set_iptc_tags()
+        self.assertEqual(self.metadata._tags['iptc'], {})
+        # Overwrite an existing tag
+        tag = IptcTag('Iptc.Application2.Caption', 'Caption', 'Caption',
+                      'A textual description of the object data.', 'String',
+                      ['A picture.'])
+        self.assertEqual(tag.metadata, None)
+        self.metadata._set_iptc_tag(tag)
+        self.assertEqual(tag.metadata, self.metadata)
+        self.assertEqual(self.metadata._tags['iptc'], {tag.key: tag})
+        self.assert_(self.metadata._image.tags['iptc'].has_key(tag.key))
+        self.assertEqual(self.metadata._image.tags['iptc'][tag.key],
+                         tag.raw_value)
+
+    def test_set_iptc_tag_overwrite_already_cached(self):
+        self.metadata.read()
+        self._set_iptc_tags()
+        self.assertEqual(self.metadata._tags['iptc'], {})
+        # Overwrite an existing tag already cached
+        key = 'Iptc.Application2.Caption'
+        tag = self.metadata._get_iptc_tag(key)
+        self.assertEqual(self.metadata._tags['iptc'][key], tag)
+        new_tag = IptcTag(key, 'Caption', 'Caption',
+                      'A textual description of the object data.', 'String',
+                      ['A picture.'])
+        self.assertEqual(new_tag.metadata, None)
+        self.metadata._set_iptc_tag(new_tag)
+        self.assertEqual(new_tag.metadata, self.metadata)
+        self.assertEqual(self.metadata._tags['iptc'], {key: new_tag})
+        self.assert_(self.metadata._image.tags['iptc'].has_key(key))
+        self.assertEqual(self.metadata._image.tags['iptc'][key],
+                         new_tag.raw_value)
+
+    def test_set_iptc_tag_values_inexistent(self):
+        self.metadata.read()
+        self._set_iptc_tags()
+        key = 'Iptc.Application2.Urgency'
+        values = ['1']
+        self.failUnlessRaises(KeyError, self.metadata._set_iptc_tag_values,
+                              key, values)
+
+    def test_set_iptc_tag_values_wrong_type(self):
+        self.metadata.read()
+        self._set_iptc_tags()
+        key = 'Iptc.Application2.DateCreated'
+        value = '20090324'
+        self.failUnlessRaises(TypeError, self.metadata._set_iptc_tag_values,
+                              key, value)
+        values = [datetime.date(2009, 3, 24)]
+        self.failUnlessRaises(TypeError, self.metadata._set_iptc_tag_values,
+                              key, values)
+
+    def test_set_iptc_tag_values(self):
+        self.metadata.read()
+        self._set_iptc_tags()
+        key = 'Iptc.Application2.DateCreated'
+        tag = self.metadata._get_iptc_tag(key)
+        values = ['2009-04-07']
+        self.failIfEqual(self.metadata._image.tags['iptc'][key], values)
+        self.metadata._set_iptc_tag_values(key, values)
+        self.assertEqual(self.metadata._image.tags['iptc'][key], values)
+
+    def test_delete_iptc_tag_inexistent(self):
+        self.metadata.read()
+        self._set_iptc_tags()
+        key = 'Iptc.Application2.LocationCode'
+        self.failUnlessRaises(KeyError, self.metadata._delete_iptc_tag, key)
+
+    def test_delete_iptc_tag_not_cached(self):
+        self.metadata.read()
+        self._set_iptc_tags()
+        key = 'Iptc.Application2.Caption'
+        self.assertEqual(self.metadata._tags['iptc'], {})
+        self.assert_(self.metadata._image.tags['iptc'].has_key(key))
+        self.metadata._delete_iptc_tag(key)
+        self.assertEqual(self.metadata._tags['iptc'], {})
+        self.failIf(self.metadata._image.tags['iptc'].has_key(key))
+
+    def test_delete_iptc_tag_cached(self):
+        self.metadata.read()
+        self._set_iptc_tags()
+        key = 'Iptc.Application2.Caption'
+        self.assert_(self.metadata._image.tags['iptc'].has_key(key))
+        tag = self.metadata._get_iptc_tag(key)
+        self.assertEqual(self.metadata._tags['iptc'][key], tag)
+        self.metadata._delete_iptc_tag(key)
+        self.assertEqual(self.metadata._tags['iptc'], {})
+        self.failIf(self.metadata._image.tags['iptc'].has_key(key))
+
+    ##########################
+    # Test XMP-related methods
+    ##########################
+
+    def test_xmp_keys(self):
+        self.metadata.read()
+        self._set_xmp_tags()
+        self.assertEqual(self.metadata._keys['xmp'], None)
+        keys = self.metadata.xmp_keys
+        self.assertEqual(len(keys), 4)
+        self.assertEqual(self.metadata._keys['xmp'], keys)
+
+    def test_get_xmp_tag(self):
+        self.metadata.read()
+        self._set_xmp_tags()
+        self.assertEqual(self.metadata._tags['xmp'], {})
+        # Get an existing tag
+        key = 'Xmp.dc.subject'
+        tag = self.metadata._get_xmp_tag(key)
+        self.assertEqual(type(tag), XmpTag)
+        self.assertEqual(tag.metadata, self.metadata)
+        self.assertEqual(self.metadata._tags['xmp'][key], tag)
+        # Try to get an nonexistent tag
+        key = 'Xmp.xmp.Label'
+        self.failUnlessRaises(KeyError, self.metadata._get_xmp_tag, key)
+
+    def test_set_xmp_tag_wrong(self):
+        self.metadata.read()
+        self._set_xmp_tags()
+        self.assertEqual(self.metadata._tags['xmp'], {})
+        # Try to set a tag with wrong type
+        tag = 'Not an xmp tag'
+        self.failUnlessRaises(TypeError, self.metadata._set_xmp_tag, tag)
+        self.assertEqual(self.metadata._tags['xmp'], {})
+
+    def test_set_xmp_tag_create(self):
+        self.metadata.read()
+        self._set_xmp_tags()
+        self.assertEqual(self.metadata._tags['xmp'], {})
+        # Create a new tag
+        tag = XmpTag('Xmp.dc.title', 'title', 'Title', 'The title of the ' \
+                     'document, or the name given to the resource. Typically,' \
+                     ' it will be a name by which the resource is formally ' \
+                     'known.', 'Lang Alt',
+                     'lang="x-default" This is not a title, ' \
+                     'lang="fr-FR" Ceci n\'est pas un titre')
+        self.assertEqual(tag.metadata, None)
+        self.metadata._set_xmp_tag(tag)
+        self.assertEqual(tag.metadata, self.metadata)
+        self.assertEqual(self.metadata._tags['xmp'], {tag.key: tag})
+        self.assert_(self.metadata._image.tags['xmp'].has_key(tag.key))
+        self.assertEqual(self.metadata._image.tags['xmp'][tag.key],
+                         tag.raw_value)
+
+    def test_set_xmp_tag_overwrite(self):
+        self.metadata.read()
+        self._set_xmp_tags()
+        self.assertEqual(self.metadata._tags['xmp'], {})
+        # Overwrite an existing tag
+        tag = XmpTag('Xmp.dc.format', 'format', 'Format', 'The file format ' \
+                     'used when saving the resource. Tools and applications ' \
+                     'should set this property to the save format of the ' \
+                     'data. It may include appropriate qualifiers.',
+                     'MIMEType', 'image/png')
+        self.assertEqual(tag.metadata, None)
+        self.metadata._set_xmp_tag(tag)
+        self.assertEqual(tag.metadata, self.metadata)
+        self.assertEqual(self.metadata._tags['xmp'], {tag.key: tag})
+        self.assert_(self.metadata._image.tags['xmp'].has_key(tag.key))
+        self.assertEqual(self.metadata._image.tags['xmp'][tag.key],
+                         tag.raw_value)
+
+    def test_set_xmp_tag_overwrite_already_cached(self):
+        self.metadata.read()
+        self._set_xmp_tags()
+        self.assertEqual(self.metadata._tags['xmp'], {})
+        # Overwrite an existing tag already cached
+        key = 'Xmp.xmp.CreateDate'
+        tag = self.metadata._get_xmp_tag(key)
+        self.assertEqual(self.metadata._tags['xmp'][key], tag)
+        new_tag = XmpTag(key, 'CreateDate', 'Create Date',
+                         'The date and time the resource was originally ' \
+                         'created.', 'Date', '2009-04-21T20:07+01:00')
+        self.assertEqual(new_tag.metadata, None)
+        self.metadata._set_xmp_tag(new_tag)
+        self.assertEqual(new_tag.metadata, self.metadata)
+        self.assertEqual(self.metadata._tags['xmp'], {key: new_tag})
+        self.assert_(self.metadata._image.tags['xmp'].has_key(key))
+        self.assertEqual(self.metadata._image.tags['xmp'][key],
+                         new_tag.raw_value)
+
+    def test_set_xmp_tag_value_inexistent(self):
+        self.metadata.read()
+        self._set_xmp_tags()
+        key = 'Xmp.xmp.Nickname'
+        value = 'oSoMoN'
+        self.failUnlessRaises(KeyError, self.metadata._set_xmp_tag_value,
+                              key, value)
+
+    def test_set_xmp_tag_value_wrong_type(self):
+        self.metadata.read()
+        self._set_xmp_tags()
+        key = 'Xmp.xmp.CreateDate'
+        value = datetime.datetime(2009, 4, 21, 20, 11, 0)
+        self.failUnlessRaises(TypeError, self.metadata._set_xmp_tag_value,
+                              key, value)
+
+    def test_set_xmp_tag_value(self):
+        self.metadata.read()
+        self._set_xmp_tags()
+        key = 'Xmp.xmp.CreateDate'
+        tag = self.metadata._get_xmp_tag(key)
+        value = '2009-04-21T20:12:47+01:00'
+        self.failIfEqual(self.metadata._image.tags['xmp'][key], value)
+        self.metadata._set_xmp_tag_value(key, value)
+        self.assertEqual(self.metadata._image.tags['xmp'][key], value)
+
+    def test_delete_xmp_tag_inexistent(self):
+        self.metadata.read()
+        self._set_xmp_tags()
+        key = 'Xmp.xmp.CreatorTool'
+        self.failUnlessRaises(KeyError, self.metadata._delete_xmp_tag, key)
+
+    def test_delete_xmp_tag_not_cached(self):
+        self.metadata.read()
+        self._set_xmp_tags()
+        key = 'Xmp.dc.subject'
+        self.assertEqual(self.metadata._tags['xmp'], {})
+        self.assert_(self.metadata._image.tags['xmp'].has_key(key))
+        self.metadata._delete_xmp_tag(key)
+        self.assertEqual(self.metadata._tags['xmp'], {})
+        self.failIf(self.metadata._image.tags['xmp'].has_key(key))
+
+    def test_delete_xmp_tag_cached(self):
+        self.metadata.read()
+        self._set_xmp_tags()
+        key = 'Xmp.dc.subject'
+        self.assert_(self.metadata._image.tags['xmp'].has_key(key))
+        tag = self.metadata._get_xmp_tag(key)
+        self.assertEqual(self.metadata._tags['xmp'][key], tag)
+        self.metadata._delete_xmp_tag(key)
+        self.assertEqual(self.metadata._tags['xmp'], {})
+        self.failIf(self.metadata._image.tags['xmp'].has_key(key))
+
+    ###########################
+    # Test dictionary interface
+    ###########################
+
+    def test_getitem(self):
+        self.metadata.read()
+        self._set_exif_tags()
+        self._set_iptc_tags()
+        self._set_xmp_tags()
+        # Get existing tags
+        key = 'Exif.Photo.ExifVersion'
+        tag = self.metadata[key]
+        self.assertEqual(type(tag), ExifTag)
+        key = 'Iptc.Application2.Caption'
+        tag = self.metadata[key]
+        self.assertEqual(type(tag), IptcTag)
+        key = 'Xmp.xmp.CreateDate'
+        tag = self.metadata[key]
+        self.assertEqual(type(tag), XmpTag)
+        # Try to get nonexistent tags
+        keys = ('Exif.Image.SamplesPerPixel', 'Iptc.Application2.FixtureId',
+                'Xmp.xmp.Rating', 'Wrong.Noluck.Raise')
+        for key in keys:
+            self.failUnlessRaises(KeyError, self.metadata.__getitem__, key)
+
+    def test_setitem(self):
+        self.metadata.read()
+        self._set_exif_tags()
+        self._set_iptc_tags()
+        self._set_xmp_tags()
+        # Set new tags
+        key = 'Exif.Photo.ExposureBiasValue'
+        tag = ExifTag(key, 'ExposureBiasValue', 'Exposure Bias',
+                      'The exposure bias. The units is the APEX value. ' \
+                      'Ordinarily it is given in the range of -99.99 to 99.99.',
+                      'SRational', '0/3', '0')
+        self.metadata[key] = tag
+        self.failUnless(key in self.metadata._tags['exif'])
+        self.failUnlessEqual(self.metadata._tags['exif'][key], tag)
+        key = 'Iptc.Application2.City'
+        tag = IptcTag(key, 'City', 'City', 'Identifies city of object data ' \
+                      'origin according to guidelines established by the ' \
+                      'provider.', 'String', ['Barcelona'])
+        self.metadata[key] = tag
+        self.failUnless(key in self.metadata._tags['iptc'])
+        self.failUnlessEqual(self.metadata._tags['iptc'][key], tag)
+        key = 'Xmp.dc.description'
+        tag = XmpTag(key, 'description', 'Description', 'A textual ' \
+                     'description of the content of the resource. Multiple ' \
+                     'values may be present for different languages.',
+                     'Lang Alt', 'lang="x-default" Sunset picture.')
+        self.metadata[key] = tag
+        self.failUnless(key in self.metadata._tags['xmp'])
+        self.failUnlessEqual(self.metadata._tags['xmp'][key], tag)
+        # Replace existing tags
+        key = 'Exif.Photo.ExifVersion'
+        tag = ExifTag(key, 'ExifVersion', 'Exif Version', 'The version of ' \
+                      'this standard supported. Nonexistence of this field is' \
+                      ' taken to mean nonconformance to the standard.',
+                      'Undefined', '48 50 50 48 ', '2.20')
+        self.metadata[key] = tag
+        self.failUnless(key in self.metadata._tags['exif'])
+        self.failUnlessEqual(self.metadata._tags['exif'][key], tag)
+        key = 'Iptc.Application2.Caption'
+        tag = IptcTag(key, 'Caption', 'Caption', 'A textual description of ' \
+                      'the object data.', 'String', ['Sunset on Barcelona.'])
+        self.metadata[key] = tag
+        self.failUnless(key in self.metadata._tags['iptc'])
+        self.failUnlessEqual(self.metadata._tags['iptc'][key], tag)
+        key = 'Xmp.dc.subject'
+        tag = XmpTag(key, 'subject', 'Subject', 'An unordered array of ' \
+                     'descriptive phrases or keywords that specify the topic ' \
+                     'of the content of the resource.', 'bag Text',
+                     'sunset, Barcelona, beautiful, beach')
+        self.metadata[key] = tag
+        self.failUnless(key in self.metadata._tags['xmp'])
+        self.failUnlessEqual(self.metadata._tags['xmp'][key], tag)
+
+    def test_delitem(self):
+        self.metadata.read()
+        self._set_exif_tags()
+        self._set_iptc_tags()
+        self._set_xmp_tags()
+        # Delete existing tags
+        key = 'Exif.Photo.ExifVersion'
+        del self.metadata[key]
+        self.failIf(key in self.metadata._tags['exif'])
+        key = 'Iptc.Application2.Caption'
+        del self.metadata[key]
+        self.failIf(key in self.metadata._tags['iptc'])
+        key = 'Xmp.xmp.CreateDate'
+        del self.metadata[key]
+        self.failIf(key in self.metadata._tags['xmp'])
+        # Try to delete nonexistent tags
+        keys = ('Exif.Image.SamplesPerPixel', 'Iptc.Application2.FixtureId',
+                'Xmp.xmp.Rating', 'Wrong.Noluck.Raise')
+        for key in keys:
+            self.failUnlessRaises(KeyError, self.metadata.__delitem__, key)
diff --git a/test/notifying_list.py b/test/notifying_list.py
new file mode 100644
index 0000000..e80ec9c
--- /dev/null
+++ b/test/notifying_list.py
@@ -0,0 +1,338 @@
+# -*- coding: utf-8 -*-
+
+# ******************************************************************************
+#
+# Copyright (C) 2009 Olivier Tilloy <olivier@tilloy.net>
+#
+# This file is part of the pyexiv2 distribution.
+#
+# pyexiv2 is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# pyexiv2 is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyexiv2; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, 5th Floor, Boston, MA 02110-1301 USA.
+#
+# Author: Olivier Tilloy <olivier@tilloy.net>
+#
+# ******************************************************************************
+
+import unittest
+from pyexiv2.utils import ListenerInterface, NotifyingList
+import random
+
+
+class SimpleListener(ListenerInterface):
+
+    def __init__(self):
+        self.changes = 0
+
+    def contents_changed(self):
+        self.changes += 1
+
+
+class TestNotifyingList(unittest.TestCase):
+
+    def setUp(self):
+        self.values = NotifyingList([5, 7, 9, 14, 57, 3, 2])
+
+    def test_no_listener(self):
+        # No listener is registered, nothing should happen.
+        self.values[3] = 13
+        del self.values[5]
+        self.values.append(17)
+        self.values.extend([11, 22])
+        self.values.insert(4, 24)
+        self.values.pop()
+        self.values.remove(9)
+        self.values.reverse()
+        self.values.sort()
+        self.values += [8, 4]
+        self.values *= 3
+        self.values[3:4] = [8, 4]
+        del self.values[3:5]
+
+    def test_listener_interface(self):
+        self.values.register_listener(ListenerInterface())
+        self.failUnlessRaises(NotImplementedError,
+                              self.values.__setitem__, 3, 13)
+        self.failUnlessRaises(NotImplementedError, self.values.__delitem__, 5)
+        self.failUnlessRaises(NotImplementedError, self.values.append, 17)
+        self.failUnlessRaises(NotImplementedError, self.values.extend, [11, 22])
+        self.failUnlessRaises(NotImplementedError, self.values.insert, 4, 24)
+        self.failUnlessRaises(NotImplementedError, self.values.pop)
+        self.failUnlessRaises(NotImplementedError, self.values.remove, 9)
+        self.failUnlessRaises(NotImplementedError, self.values.reverse)
+        self.failUnlessRaises(NotImplementedError, self.values.sort)
+        self.failUnlessRaises(NotImplementedError, self.values.__iadd__, [8, 4])
+        self.failUnlessRaises(NotImplementedError, self.values.__imul__, 3)
+        self.failUnlessRaises(NotImplementedError, self.values.__setslice__,
+                              3, 4, [8, 4])
+        self.failUnlessRaises(NotImplementedError, self.values.__delslice__,
+                              3, 5)
+
+    def _register_listeners(self):
+        # Register a random number of listeners
+        listeners = [SimpleListener() for i in xrange(random.randint(3, 20))]
+        for listener in listeners:
+            self.values.register_listener(listener)
+        return listeners
+
+    def test_setitem(self):
+        listeners = self._register_listeners()
+
+        self.values[3] = 13
+        self.failUnlessEqual(self.values, [5, 7, 9, 13, 57, 3, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 1)
+
+        self.failUnlessRaises(IndexError, self.values.__setitem__, 9, 27)
+        self.failUnlessEqual(self.values, [5, 7, 9, 13, 57, 3, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 1)
+
+    def test_delitem(self):
+        listeners = self._register_listeners()
+
+        del self.values[5]
+        self.failUnlessEqual(self.values, [5, 7, 9, 14, 57, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 1)
+
+        self.failUnlessRaises(IndexError, self.values.__delitem__, 9)
+        self.failUnlessEqual(self.values, [5, 7, 9, 14, 57, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 1)
+
+    def test_append(self):
+        listeners = self._register_listeners()
+
+        self.values.append(17)
+        self.failUnlessEqual(self.values, [5, 7, 9, 14, 57, 3, 2, 17])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 1)
+
+    def test_extend(self):
+        listeners = self._register_listeners()
+
+        self.values.extend([11, 22])
+        self.failUnlessEqual(self.values, [5, 7, 9, 14, 57, 3, 2, 11, 22])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 1)
+
+        self.failUnlessRaises(TypeError, self.values.extend, 26)
+        self.failUnlessEqual(self.values, [5, 7, 9, 14, 57, 3, 2, 11, 22])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 1)
+
+    def test_insert(self):
+        listeners = self._register_listeners()
+
+        self.values.insert(4, 24)
+        self.failUnlessEqual(self.values, [5, 7, 9, 14, 24, 57, 3, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 1)
+
+    def test_pop(self):
+        listeners = self._register_listeners()
+
+        self.values.pop()
+        self.failUnlessEqual(self.values, [5, 7, 9, 14, 57, 3])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 1)
+
+        self.values.pop(4)
+        self.failUnlessEqual(self.values, [5, 7, 9, 14, 3])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 2)
+
+        self.values.pop(-2)
+        self.failUnlessEqual(self.values, [5, 7, 9, 3])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 3)
+
+        self.failUnlessRaises(IndexError, self.values.pop, 33)
+        self.failUnlessEqual(self.values, [5, 7, 9, 3])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 3)
+
+    def test_remove(self):
+        listeners = self._register_listeners()
+
+        self.values.remove(9)
+        self.failUnlessEqual(self.values, [5, 7, 14, 57, 3, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 1)
+
+        self.failUnlessRaises(ValueError, self.values.remove, 33)
+        self.failUnlessEqual(self.values, [5, 7, 14, 57, 3, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 1)
+
+    def test_reverse(self):
+        listeners = self._register_listeners()
+
+        self.values.reverse()
+        self.failUnlessEqual(self.values, [2, 3, 57, 14, 9, 7, 5])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 1)
+
+    def test_sort(self):
+        listeners = self._register_listeners()
+
+        self.values.sort()
+        self.failUnlessEqual(self.values, [2, 3, 5, 7, 9, 14, 57])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 1)
+
+        self.values.sort(cmp=lambda x, y: y - x)
+        self.failUnlessEqual(self.values, [57, 14, 9, 7, 5, 3, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 2)
+
+        self.values.sort(key=lambda x: x * x)
+        self.failUnlessEqual(self.values, [2, 3, 5, 7, 9, 14, 57])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 3)
+
+        self.values.sort(reverse=True)
+        self.failUnlessEqual(self.values, [57, 14, 9, 7, 5, 3, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 4)
+
+    def test_iadd(self):
+        listeners = self._register_listeners()
+
+        self.values += [44, 31, 19]
+        self.failUnlessEqual(self.values, [5, 7, 9, 14, 57, 3, 2, 44, 31, 19])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 1)
+
+    def test_imul(self):
+        listeners = self._register_listeners()
+
+        self.values *= 3
+        self.failUnlessEqual(self.values,
+                             [5, 7, 9, 14, 57, 3, 2,
+                              5, 7, 9, 14, 57, 3, 2,
+                              5, 7, 9, 14, 57, 3, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 1)
+
+    def test_setslice(self):
+        listeners = self._register_listeners()
+
+        # Basic slicing (of the form [i:j]): implemented as __setslice__.
+
+        self.values[2:4] = [3, 4]
+        self.failUnlessEqual(self.values, [5, 7, 3, 4, 57, 3, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 1)
+
+        self.values[3:5] = [77, 8, 12]
+        self.failUnlessEqual(self.values, [5, 7, 3, 77, 8, 12, 3, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 2)
+
+        self.values[2:5] = [1, 0]
+        self.failUnlessEqual(self.values, [5, 7, 1, 0, 12, 3, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 3)
+
+        self.values[0:2] = []
+        self.failUnlessEqual(self.values, [1, 0, 12, 3, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 4)
+
+        self.values[2:2] = [7, 5]
+        self.failUnlessEqual(self.values, [1, 0, 7, 5, 12, 3, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 5)
+
+        # With negatives indexes
+
+        self.values[4:-2] = [9]
+        self.failUnlessEqual(self.values, [1, 0, 7, 5, 9, 3, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 6)
+
+        self.values[-2:1] = [6, 4]
+        self.failUnlessEqual(self.values, [1, 0, 7, 5, 9, 6, 4, 3, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 7)
+
+        self.values[-5:-2] = [8]
+        self.failUnlessEqual(self.values, [1, 0, 7, 5, 8, 3, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 8)
+
+        # With missing (implicit) indexes
+
+        self.values[:2] = [4]
+        self.failUnlessEqual(self.values, [4, 7, 5, 8, 3, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 9)
+
+        self.values[4:] = [1]
+        self.failUnlessEqual(self.values, [4, 7, 5, 8, 1])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 10)
+
+        self.values[:] = [5, 7, 9, 14, 57, 3, 2]
+        self.failUnlessEqual(self.values, [5, 7, 9, 14, 57, 3, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 11)
+
+    def test_delslice(self):
+        listeners = self._register_listeners()
+
+        del self.values[2:3]
+        self.failUnlessEqual(self.values, [5, 7, 14, 57, 3, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 1)
+
+        del self.values[2:2]
+        self.failUnlessEqual(self.values, [5, 7, 14, 57, 3, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 1)
+
+        # With negatives indexes
+
+        del self.values[4:-1]
+        self.failUnlessEqual(self.values, [5, 7, 14, 57, 2])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 2)
+
+        del self.values[-1:5]
+        self.failUnlessEqual(self.values, [5, 7, 14, 57])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 3)
+
+        del self.values[-2:-1]
+        self.failUnlessEqual(self.values, [5, 7, 57])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 4)
+
+        # With missing (implicit) indexes
+
+        del self.values[:1]
+        self.failUnlessEqual(self.values, [7, 57])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 5)
+
+        del self.values[1:]
+        self.failUnlessEqual(self.values, [7])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 6)
+
+        del self.values[:]
+        self.failUnlessEqual(self.values, [])
+        for listener in listeners:
+            self.failUnlessEqual(listener.changes, 7)
diff --git a/test/rational.py b/test/rational.py
new file mode 100644
index 0000000..070bf6c
--- /dev/null
+++ b/test/rational.py
@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+
+# ******************************************************************************
+#
+# Copyright (C) 2008-2009 Olivier Tilloy <olivier@tilloy.net>
+#
+# This file is part of the pyexiv2 distribution.
+#
+# pyexiv2 is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# pyexiv2 is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyexiv2; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, 5th Floor, Boston, MA 02110-1301 USA.
+#
+# Author: Olivier Tilloy <olivier@tilloy.net>
+#
+# ******************************************************************************
+
+import unittest
+
+from pyexiv2.utils import Rational
+
+
+class TestRational(unittest.TestCase):
+
+    def test_constructor(self):
+        r = Rational(2, 1)
+        self.assertEqual(r.numerator, 2)
+        self.assertEqual(r.denominator, 1)
+        self.assertRaises(ZeroDivisionError, Rational, 1, 0)
+
+    def test_read_only(self):
+        r = Rational(3, 4)
+        try:
+            r.numerator = 5
+        except AttributeError:
+            pass
+        else:
+            self.fail('Numerator is not read-only.')
+        try:
+            r.denominator = 5
+        except AttributeError:
+            pass
+        else:
+            self.fail('Denominator is not read-only.')
+
+    def test_from_string(self):
+        self.assertEqual(Rational.from_string('4/3'), Rational(4, 3))
+        self.assertEqual(Rational.from_string('-4/3'), Rational(-4, 3))
+        self.assertRaises(ValueError, Rational.from_string, '+3/5')
+        self.assertRaises(ValueError, Rational.from_string, '3 / 5')
+        self.assertRaises(ValueError, Rational.from_string, '3/-5')
+        self.assertRaises(ValueError, Rational.from_string, 'invalid')
+
+    def test_to_string(self):
+        self.assertEqual(str(Rational(3, 5)), '3/5')
+        self.assertEqual(str(Rational(-3, 5)), '-3/5')
+
+    def test_to_float(self):
+        self.assertEqual(Rational(3, 6).to_float(), 0.5)
+        self.assertEqual(Rational(11, 11).to_float(), 1.0)
+        self.assertEqual(Rational(-2, 8).to_float(), -0.25)
+        self.assertEqual(Rational(0, 3).to_float(), 0.0)
+
+    def test_equality(self):
+        r1 = Rational(2, 1)
+        r2 = Rational(2, 1)
+        r3 = Rational(8, 4)
+        r4 = Rational(3, 2)
+        self.assertEqual(r1, r2)
+        self.assertEqual(r1, r3)
+        self.assertNotEqual(r1, r4)
diff --git a/test/xmp.py b/test/xmp.py
new file mode 100644
index 0000000..a61e375
--- /dev/null
+++ b/test/xmp.py
@@ -0,0 +1,370 @@
+# -*- coding: utf-8 -*-
+
+# ******************************************************************************
+#
+# Copyright (C) 2009 Olivier Tilloy <olivier@tilloy.net>
+#
+# This file is part of the pyexiv2 distribution.
+#
+# pyexiv2 is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# pyexiv2 is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyexiv2; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, 5th Floor, Boston, MA 02110-1301 USA.
+#
+# Author: Olivier Tilloy <olivier@tilloy.net>
+#
+# ******************************************************************************
+
+import unittest
+
+from pyexiv2.xmp import XmpTag, XmpValueError
+from pyexiv2.utils import FixedOffset
+
+import datetime
+
+
+class ImageMetadataMock(object):
+
+    tags = {}
+
+    def _set_xmp_tag_value(self, key, value):
+        self.tags[key] = value
+
+    def _delete_xmp_tag(self, key):
+        try:
+            del self.tags[key]
+        except KeyError:
+            pass
+
+
+class TestXmpTag(unittest.TestCase):
+
+    def test_convert_to_python_bag(self):
+        xtype = 'bag Text'
+        # Valid values
+        self.assertEqual(XmpTag._convert_to_python('', xtype), [])
+        self.assertEqual(XmpTag._convert_to_python('One value only', xtype), [u'One value only'])
+        self.assertEqual(XmpTag._convert_to_python('Some, text, keyword, this is a test', xtype),
+                         [u'Some', u'text', u'keyword', u'this is a test'])
+
+    def test_convert_to_string_bag(self):
+        xtype = 'bag Text'
+        # Valid values
+        self.assertEqual(XmpTag._convert_to_string([], xtype), '')
+        self.assertEqual(XmpTag._convert_to_string(['One value only'], xtype), 'One value only')
+        self.assertEqual(XmpTag._convert_to_string([u'One value only'], xtype), 'One value only')
+        self.assertEqual(XmpTag._convert_to_string([u'Some', u'text', u'keyword', u'this is a test'], xtype),
+                         'Some, text, keyword, this is a test')
+        self.assertEqual(XmpTag._convert_to_string(['Some   ', '  text    '], xtype),
+                         'Some   ,   text    ')
+        # Invalid values
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_string, 'invalid', xtype)
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_string, [1, 2, 3], xtype)
+
+    def test_convert_to_python_boolean(self):
+        xtype = 'Boolean'
+        # Valid values
+        self.assertEqual(XmpTag._convert_to_python('True', xtype), True)
+        self.assertEqual(XmpTag._convert_to_python('False', xtype), False)
+        # Invalid values: not converted
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_python, 'invalid', xtype)
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_python, None, xtype)
+
+    def test_convert_to_string_boolean(self):
+        xtype = 'Boolean'
+        # Valid values
+        self.assertEqual(XmpTag._convert_to_string(True, xtype), 'True')
+        self.assertEqual(XmpTag._convert_to_string(False, xtype), 'False')
+        # Invalid values
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_string, 'invalid', xtype)
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_string, None, xtype)
+
+    def test_convert_to_python_date(self):
+        xtype = 'Date'
+        # Valid values
+        self.assertEqual(XmpTag._convert_to_python('1999', xtype),
+                         datetime.date(1999, 1, 1))
+        self.assertEqual(XmpTag._convert_to_python('1999-10', xtype),
+                         datetime.date(1999, 10, 1))
+        self.assertEqual(XmpTag._convert_to_python('1999-10-13', xtype),
+                         datetime.date(1999, 10, 13))
+        self.assertEqual(XmpTag._convert_to_python('1999-10-13T05:03Z', xtype) - \
+                         datetime.datetime(1999, 10, 13, 5, 3, tzinfo=FixedOffset()),
+                         datetime.timedelta(0))
+        self.assertEqual(XmpTag._convert_to_python('1999-10-13T05:03+06:00', xtype) - \
+                         datetime.datetime(1999, 10, 13, 5, 3, tzinfo=FixedOffset('+', 6, 0)),
+                         datetime.timedelta(0))
+        self.assertEqual(XmpTag._convert_to_python('1999-10-13T05:03-06:00', xtype) - \
+                         datetime.datetime(1999, 10, 13, 5, 3, tzinfo=FixedOffset('-', 6, 0)),
+                         datetime.timedelta(0))
+        self.assertEqual(XmpTag._convert_to_python('1999-10-13T05:03:54Z', xtype) - \
+                         datetime.datetime(1999, 10, 13, 5, 3, 54, tzinfo=FixedOffset()),
+                         datetime.timedelta(0))
+        self.assertEqual(XmpTag._convert_to_python('1999-10-13T05:03:54+06:00', xtype) - \
+                         datetime.datetime(1999, 10, 13, 5, 3, 54, tzinfo=FixedOffset('+', 6, 0)),
+                         datetime.timedelta(0))
+        self.assertEqual(XmpTag._convert_to_python('1999-10-13T05:03:54-06:00', xtype) - \
+                         datetime.datetime(1999, 10, 13, 5, 3, 54, tzinfo=FixedOffset('-', 6, 0)),
+                         datetime.timedelta(0))
+        self.assertEqual(XmpTag._convert_to_python('1999-10-13T05:03:54.721Z', xtype) - \
+                         datetime.datetime(1999, 10, 13, 5, 3, 54, 721000, tzinfo=FixedOffset()),
+                         datetime.timedelta(0))
+        self.assertEqual(XmpTag._convert_to_python('1999-10-13T05:03:54.721+06:00', xtype) - \
+                         datetime.datetime(1999, 10, 13, 5, 3, 54, 721000, tzinfo=FixedOffset('+', 6, 0)),
+                         datetime.timedelta(0))
+        self.assertEqual(XmpTag._convert_to_python('1999-10-13T05:03:54.721-06:00', xtype) - \
+                         datetime.datetime(1999, 10, 13, 5, 3, 54, 721000, tzinfo=FixedOffset('-', 6, 0)),
+                         datetime.timedelta(0))
+        # Invalid values
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_python, 'invalid', xtype)
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_python, '11/10/1983', xtype)
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_python, '-1000', xtype)
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_python, '2009-13', xtype)
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_python, '2009-10-32', xtype)
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_python, '2009-10-30T25:12Z', xtype)
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_python, '2009-10-30T23:67Z', xtype)
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_python, '2009-01-22T21', xtype)
+
+    def test_convert_to_string_date(self):
+        xtype = 'Date'
+        # Valid values
+        self.assertEqual(XmpTag._convert_to_string(datetime.date(2009, 2, 4), xtype),
+                         '2009-02-04')
+        self.assertEqual(XmpTag._convert_to_string(datetime.datetime(1999, 10, 13), xtype),
+                         '1999-10-13')
+        self.assertEqual(XmpTag._convert_to_string(datetime.datetime(1999, 10, 13, 5, 3, tzinfo=FixedOffset()), xtype),
+                         '1999-10-13T05:03Z')
+        self.assertEqual(XmpTag._convert_to_string(datetime.datetime(1999, 10, 13, 5, 3, tzinfo=FixedOffset('+', 5, 30)), xtype),
+                         '1999-10-13T05:03+05:30')
+        self.assertEqual(XmpTag._convert_to_string(datetime.datetime(1999, 10, 13, 5, 3, tzinfo=FixedOffset('-', 11, 30)), xtype),
+                         '1999-10-13T05:03-11:30')
+        self.assertEqual(XmpTag._convert_to_string(datetime.datetime(1999, 10, 13, 5, 3, 27, tzinfo=FixedOffset()), xtype),
+                         '1999-10-13T05:03:27Z')
+        self.assertEqual(XmpTag._convert_to_string(datetime.datetime(1999, 10, 13, 5, 3, 27, tzinfo=FixedOffset('+', 5, 30)), xtype),
+                         '1999-10-13T05:03:27+05:30')
+        self.assertEqual(XmpTag._convert_to_string(datetime.datetime(1999, 10, 13, 5, 3, 27, tzinfo=FixedOffset('-', 11, 30)), xtype),
+                         '1999-10-13T05:03:27-11:30')
+        self.assertEqual(XmpTag._convert_to_string(datetime.datetime(1999, 10, 13, 5, 3, 27, 124300, tzinfo=FixedOffset()), xtype),
+                         '1999-10-13T05:03:27.1243Z')
+        self.assertEqual(XmpTag._convert_to_string(datetime.datetime(1999, 10, 13, 5, 3, 27, 124300, tzinfo=FixedOffset('+', 5, 30)), xtype),
+                         '1999-10-13T05:03:27.1243+05:30')
+        self.assertEqual(XmpTag._convert_to_string(datetime.datetime(1999, 10, 13, 5, 3, 27, 124300, tzinfo=FixedOffset('-', 11, 30)), xtype),
+                         '1999-10-13T05:03:27.1243-11:30')
+        # Invalid values
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_string, 'invalid', xtype)
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_string, None, xtype)
+
+    def test_convert_to_python_integer(self):
+        xtype = 'Integer'
+        # Valid values
+        self.assertEqual(XmpTag._convert_to_python('23', xtype), 23)
+        self.assertEqual(XmpTag._convert_to_python('+5628', xtype), 5628)
+        self.assertEqual(XmpTag._convert_to_python('-4', xtype), -4)
+        # Invalid values
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_python, 'abc', xtype)
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_python, '5,64', xtype)
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_python, '47.0001', xtype)
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_python, '1E3', xtype)
+
+    def test_convert_to_string_integer(self):
+        xtype = 'Integer'
+        # Valid values
+        self.assertEqual(XmpTag._convert_to_string(123, xtype), '123')
+        self.assertEqual(XmpTag._convert_to_string(-57, xtype), '-57')
+        # Invalid values
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_string, 'invalid', xtype)
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_string, 3.14, xtype)
+
+    def test_convert_to_python_langalt(self):
+        xtype = 'Lang Alt'
+        # Valid values
+        self.assertEqual(XmpTag._convert_to_python('lang="x-default" some text', xtype),
+                         {'x-default': u'some text'})
+        self.assertEqual(XmpTag._convert_to_python('lang="x-default" some text, lang="fr-FR" du texte', xtype),
+                         {'x-default': u'some text', 'fr-FR': u'du texte'})
+        self.assertEqual(XmpTag._convert_to_python('lang="x-default" some text   ,    lang="fr-FR"   du texte  ', xtype),
+                         {'x-default': u'some text   ', 'fr-FR': u'  du texte  '})
+        self.assertEqual(XmpTag._convert_to_python('lang="x-default" some text, lang="fr-FR" du texte, lang="es-ES" un texto', xtype),
+                         {'x-default': u'some text', 'fr-FR': u'du texte', 'es-ES': u'un texto'})
+        # Invalid values
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_python, 'invalid', xtype)
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_python, 'lang="malformed', xtype)
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_python, 'xlang="x-default" some text', xtype)
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_python, 'lang="x-default" some text, xlang="fr-FR" du texte', xtype)
+
+    def test_convert_to_string_langalt(self):
+        xtype = 'Lang Alt'
+        # Valid values
+        self.assertEqual(XmpTag._convert_to_string({'x-default': 'some text'}, xtype),
+                         'lang="x-default" some text')
+        self.assertEqual(XmpTag._convert_to_string({'x-default': u'some text'}, xtype),
+                         'lang="x-default" some text')
+        self.assertEqual(XmpTag._convert_to_string({'x-default': 'some text', 'fr-FR': 'du texte'}, xtype),
+                         'lang="x-default" some text, lang="fr-FR" du texte')
+        self.assertEqual(XmpTag._convert_to_string({'x-default': u'some text', 'fr-FR': 'du texte'}, xtype),
+                         'lang="x-default" some text, lang="fr-FR" du texte')
+        self.assertEqual(XmpTag._convert_to_string({'x-default': u'some text', 'fr-FR': 'du texte', 'es-ES': 'un texto'}, xtype),
+                         'lang="x-default" some text, lang="es-ES" un texto, lang="fr-FR" du texte')
+        # Invalid values
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_string, 'invalid', xtype)
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_string, {}, xtype)
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_string, {'x-default': 25}, xtype)
+
+    def test_convert_to_python_mimetype(self):
+        xtype = 'MIMEType'
+        # Valid values
+        self.assertEqual(XmpTag._convert_to_python('image/jpeg', xtype),
+                         {'type': 'image', 'subtype': 'jpeg'})
+        self.assertEqual(XmpTag._convert_to_python('video/ogg', xtype),
+                         {'type': 'video', 'subtype': 'ogg'})
+        # Invalid values
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_python, 'invalid', xtype)
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_python, 'image-jpeg', xtype)
+
+    def test_convert_to_string_mimetype(self):
+        xtype = 'MIMEType'
+        # Valid values
+        self.assertEqual(XmpTag._convert_to_string({'type': 'image', 'subtype': 'jpeg'}, xtype), 'image/jpeg')
+        self.assertEqual(XmpTag._convert_to_string({'type': 'video', 'subtype': 'ogg'}, xtype), 'video/ogg')
+        # Invalid values
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_string, 'invalid', xtype)
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_string, {'type': 'image'}, xtype)
+
+    def test_convert_to_python_propername(self):
+        xtype = 'ProperName'
+        # Valid values
+        self.assertEqual(XmpTag._convert_to_python('Gérard', xtype), u'Gérard')
+        self.assertEqual(XmpTag._convert_to_python('Python Software Foundation', xtype), u'Python Software Foundation')
+        # Invalid values
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_python, None, xtype)
+
+    def test_convert_to_string_propername(self):
+        xtype = 'ProperName'
+        # Valid values
+        self.assertEqual(XmpTag._convert_to_string('Gérard', xtype), 'Gérard')
+        self.assertEqual(XmpTag._convert_to_string(u'Gérard', xtype), 'Gérard')
+        self.assertEqual(XmpTag._convert_to_string(u'Python Software Foundation', xtype), 'Python Software Foundation')
+        # Invalid values
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_string, None, xtype)
+
+    def test_convert_to_python_text(self):
+        xtype = 'Text'
+        # Valid values
+        self.assertEqual(XmpTag._convert_to_python('Some text.', xtype), u'Some text.')
+        self.assertEqual(XmpTag._convert_to_python('Some text with exotic chàräctérʐ.', xtype),
+                         u'Some text with exotic chàräctérʐ.')
+        # Invalid values
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_python, None, xtype)
+
+    def test_convert_to_string_text(self):
+        xtype = 'Text'
+        # Valid values
+        self.assertEqual(XmpTag._convert_to_string(u'Some text', xtype), 'Some text')
+        self.assertEqual(XmpTag._convert_to_string(u'Some text with exotic chàräctérʐ.', xtype),
+                         'Some text with exotic chàräctérʐ.')
+        self.assertEqual(XmpTag._convert_to_string('Some text with exotic chàräctérʐ.', xtype),
+                         'Some text with exotic chàräctérʐ.')
+        # Invalid values
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_string, None, xtype)
+
+    def test_convert_to_python_uri(self):
+        xtype = 'URI'
+        # Valid values
+        self.assertEqual(XmpTag._convert_to_python('http://example.com', xtype), 'http://example.com')
+        self.assertEqual(XmpTag._convert_to_python('https://example.com', xtype), 'https://example.com')
+        self.assertEqual(XmpTag._convert_to_python('http://localhost:8000/resource', xtype),
+                         'http://localhost:8000/resource')
+        self.assertEqual(XmpTag._convert_to_python('uuid:9A3B7F52214211DAB6308A7391270C13', xtype),
+                         'uuid:9A3B7F52214211DAB6308A7391270C13')
+
+    def test_convert_to_string_uri(self):
+        xtype = 'URI'
+        # Valid values
+        self.assertEqual(XmpTag._convert_to_string('http://example.com', xtype), 'http://example.com')
+        self.assertEqual(XmpTag._convert_to_string(u'http://example.com', xtype), 'http://example.com')
+        self.assertEqual(XmpTag._convert_to_string('https://example.com', xtype), 'https://example.com')
+        self.assertEqual(XmpTag._convert_to_string('http://localhost:8000/resource', xtype),
+                         'http://localhost:8000/resource')
+        self.assertEqual(XmpTag._convert_to_string('uuid:9A3B7F52214211DAB6308A7391270C13', xtype),
+                         'uuid:9A3B7F52214211DAB6308A7391270C13')
+        # Invalid values
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_string, None, xtype)
+
+    def test_convert_to_python_url(self):
+        xtype = 'URL'
+        # Valid values
+        self.assertEqual(XmpTag._convert_to_python('http://example.com', xtype), 'http://example.com')
+        self.assertEqual(XmpTag._convert_to_python('https://example.com', xtype), 'https://example.com')
+        self.assertEqual(XmpTag._convert_to_python('http://localhost:8000/resource', xtype),
+                         'http://localhost:8000/resource')
+
+    def test_convert_to_string_url(self):
+        xtype = 'URL'
+        # Valid values
+        self.assertEqual(XmpTag._convert_to_string('http://example.com', xtype), 'http://example.com')
+        self.assertEqual(XmpTag._convert_to_string(u'http://example.com', xtype), 'http://example.com')
+        self.assertEqual(XmpTag._convert_to_string('https://example.com', xtype), 'https://example.com')
+        self.assertEqual(XmpTag._convert_to_string('http://localhost:8000/resource', xtype),
+                         'http://localhost:8000/resource')
+        # Invalid values
+        self.failUnlessRaises(XmpValueError, XmpTag._convert_to_string, None, xtype)
+
+    # TODO: other types
+
+
+    def test_set_value_no_metadata(self):
+        tag = XmpTag('Xmp.xmp.ModifyDate', 'ModifyDate', 'Modify Date',
+                     'The date and time the resource was last modified. Note:' \
+                     ' The value of this property is not necessarily the same' \
+                     "as the file's system modification date because it is " \
+                     'set before the file is saved.', 'Date',
+                     '2005-09-07T15:09:51-07:00')
+        old_value = tag.value
+        tag.value = datetime.datetime(2009, 4, 22, 8, 30, 27, tzinfo=FixedOffset())
+        self.failIfEqual(tag.value, old_value)
+
+    def test_set_value_with_metadata(self):
+        tag = XmpTag('Xmp.xmp.ModifyDate', 'ModifyDate', 'Modify Date',
+                     'The date and time the resource was last modified. Note:' \
+                     ' The value of this property is not necessarily the same' \
+                     "as the file's system modification date because it is " \
+                     'set before the file is saved.', 'Date',
+                     '2005-09-07T15:09:51-07:00')
+        tag.metadata = ImageMetadataMock()
+        old_value = tag.value
+        tag.value = datetime.datetime(2009, 4, 22, 8, 30, 27, tzinfo=FixedOffset())
+        self.failIfEqual(tag.value, old_value)
+        self.assertEqual(tag.metadata.tags[tag.key], '2009-04-22T08:30:27Z')
+
+    def test_del_value_no_metadata(self):
+        tag = XmpTag('Xmp.xmp.ModifyDate', 'ModifyDate', 'Modify Date',
+                     'The date and time the resource was last modified. Note:' \
+                     ' The value of this property is not necessarily the same' \
+                     "as the file's system modification date because it is " \
+                     'set before the file is saved.', 'Date',
+                     '2005-09-07T15:09:51-07:00')
+        del tag.value
+        self.failIf(hasattr(tag, 'value'))
+
+    def test_del_value_with_metadata(self):
+        tag = XmpTag('Xmp.xmp.ModifyDate', 'ModifyDate', 'Modify Date',
+                     'The date and time the resource was last modified. Note:' \
+                     ' The value of this property is not necessarily the same' \
+                     "as the file's system modification date because it is " \
+                     'set before the file is saved.', 'Date',
+                     '2005-09-07T15:09:51-07:00')
+        tag.metadata = ImageMetadataMock()
+        tag.metadata._set_xmp_tag_value(tag.key, tag.to_string())
+        self.assertEqual(tag.metadata.tags, {tag.key: '2005-09-07T15:09:51-07:00'})
+        del tag.value
+        self.failIf(hasattr(tag, 'value'))
+        self.failIf(tag.metadata.tags.has_key(tag.key))