← Back to branch summary

~osomon/pyexiv2/pyexiv2-0.3

« back to all changes in this revision

Viewing changes to unittest/exif.py

  • Committer: Olivier Tilloy
  • Date: 2009-08-04 07:11:39 UTC
  • Revision ID: olivier@tilloy.net-20090804071139-s7uagg2poday920n
Make ExifTag._convert_to_string an instance method.

Show diffs side-by-side

added added

removed removed

Lines of Context:
unittest/exif.py
69
69
        # Valid values: strings
70
70
        tag = ExifTagMock('Exif.Image.Copyright', type)
71
71
        self.assertEqual(tag._convert_to_python('Some text.'), u'Some text.')
72
 
        self.assertEqual(tag._convert_to_python('Some text with exotic chàräctérʐ.'), u'Some text with exotic chàräctérʐ.')
 
72
        self.assertEqual(tag._convert_to_python('Some text with exotic chàräctérʐ.'),
 
73
                         u'Some text with exotic chàräctérʐ.')
73
74
 
74
75
        # Invalid values: datetimes
75
76
        tag = ExifTagMock('Exif.Image.DateTime', type)
78
79
        self.assertEqual(tag._convert_to_python('2009-12-01'), u'2009-12-01')
79
80
 
80
81
    def test_convert_to_string_ascii(self):
81
 
        xtype = 'Ascii'
 
82
        type = 'Ascii'
 
83
 
82
84
        # Valid values: datetimes
83
 
        self.assertEqual(ExifTag._convert_to_string(datetime.datetime(2009, 03, 01, 12, 54, 28), xtype),
 
85
        tag = ExifTagMock('Exif.Image.DateTime', type)
 
86
        self.assertEqual(tag._convert_to_string(datetime.datetime(2009, 03, 01, 12, 54, 28)),
84
87
                         '2009:03:01 12:54:28')
85
 
        self.assertEqual(ExifTag._convert_to_string(datetime.date(2009, 03, 01), xtype),
 
88
        self.assertEqual(tag._convert_to_string(datetime.date(2009, 03, 01)),
86
89
                         '2009:03:01 00:00:00')
 
90
 
87
91
        # Valid values: strings
88
 
        self.assertEqual(ExifTag._convert_to_string(u'Some text', xtype), 'Some text')
89
 
        self.assertEqual(ExifTag._convert_to_string(u'Some text with exotic chàräctérʐ.', xtype),
90
 
                         'Some text with exotic chàräctérʐ.')
91
 
        self.assertEqual(ExifTag._convert_to_string('Some text with exotic chàräctérʐ.', xtype),
92
 
                         'Some text with exotic chàräctérʐ.')
 
92
        tag = ExifTagMock('Exif.Image.Copyright', type)
 
93
        self.assertEqual(tag._convert_to_string(u'Some text'), 'Some text')
 
94
        self.assertEqual(tag._convert_to_string(u'Some text with exotic chàräctérʐ.'),
 
95
                         'Some text with exotic chàräctérʐ.')
 
96
        self.assertEqual(tag._convert_to_string('Some text with exotic chàräctérʐ.'),
 
97
                         'Some text with exotic chàräctérʐ.')
 
98
 
93
99
        # Invalid values
94
 
        self.failUnlessRaises(ExifValueError, ExifTag._convert_to_string, None, xtype)
 
100
        self.failUnlessRaises(ExifValueError, tag._convert_to_string, None)
95
101
 
96
102
    def test_convert_to_python_byte(self):
97
103
        type = 'Byte'
98
104
 
99
105
        # Valid values
100
 
        tag = ExifTagMock('Exif.Image.DateTime', type)
 
106
        tag = ExifTagMock('Exif.GPSInfo.GPSVersionID', type)
101
107
        self.assertEqual(tag._convert_to_python('D'), 'D')
102
108
 
103
109
    def test_convert_to_string_byte(self):
104
 
        xtype = 'Byte'
 
110
        type = 'Byte'
 
111
 
105
112
        # Valid values
106
 
        self.assertEqual(ExifTag._convert_to_string('Some text', xtype), 'Some text')
107
 
        self.assertEqual(ExifTag._convert_to_string(u'Some text', xtype), 'Some text')
 
113
        tag = ExifTagMock('Exif.GPSInfo.GPSVersionID', type)
 
114
        self.assertEqual(tag._convert_to_string('Some text'), 'Some text')
 
115
        self.assertEqual(tag._convert_to_string(u'Some text'), 'Some text')
 
116
 
108
117
        # Invalid values
109
 
        self.failUnlessRaises(ExifValueError, ExifTag._convert_to_string, None, xtype)
 
118
        self.failUnlessRaises(ExifValueError, tag._convert_to_string, None)
110
119
 
111
120
    def test_convert_to_python_short(self):
112
121
        type = 'Short'
123
132
        self.failUnlessRaises(ExifValueError, tag._convert_to_python, '1E3')
124
133
 
125
134
    def test_convert_to_string_short(self):
126
 
        xtype = 'Short'
 
135
        type = 'Short'
 
136
 
127
137
        # Valid values
128
 
        self.assertEqual(ExifTag._convert_to_string(123, xtype), '123')
 
138
        tag = ExifTagMock('Exif.Image.BitsPerSample', type)
 
139
        self.assertEqual(tag._convert_to_string(123), '123')
 
140
 
129
141
        # Invalid values
130
 
        self.failUnlessRaises(ExifValueError, ExifTag._convert_to_string, -57, xtype)
131
 
        self.failUnlessRaises(ExifValueError, ExifTag._convert_to_string, 'invalid', xtype)
132
 
        self.failUnlessRaises(ExifValueError, ExifTag._convert_to_string, 3.14, xtype)
 
142
        self.failUnlessRaises(ExifValueError, tag._convert_to_string, -57)
 
143
        self.failUnlessRaises(ExifValueError, tag._convert_to_string, 'invalid')
 
144
        self.failUnlessRaises(ExifValueError, tag._convert_to_string, 3.14)
133
145
 
134
146
    def test_convert_to_python_long(self):
135
147
        type = 'Long'
146
158
        self.failUnlessRaises(ExifValueError, tag._convert_to_python, '1E3')
147
159
 
148
160
    def test_convert_to_string_long(self):
149
 
        xtype = 'Long'
 
161
        type = 'Long'
 
162
 
150
163
        # Valid values
151
 
        self.assertEqual(ExifTag._convert_to_string(123, xtype), '123')
152
 
        self.assertEqual(ExifTag._convert_to_string(678024, xtype), '678024')
 
164
        tag = ExifTagMock('Exif.Image.ImageWidth', type)
 
165
        self.assertEqual(tag._convert_to_string(123), '123')
 
166
        self.assertEqual(tag._convert_to_string(678024), '678024')
 
167
 
153
168
        # Invalid values
154
 
        self.failUnlessRaises(ExifValueError, ExifTag._convert_to_string, -57, xtype)
155
 
        self.failUnlessRaises(ExifValueError, ExifTag._convert_to_string, 'invalid', xtype)
156
 
        self.failUnlessRaises(ExifValueError, ExifTag._convert_to_string, 3.14, xtype)
 
169
        self.failUnlessRaises(ExifValueError, tag._convert_to_string, -57)
 
170
        self.failUnlessRaises(ExifValueError, tag._convert_to_string, 'invalid')
 
171
        self.failUnlessRaises(ExifValueError, tag._convert_to_string, 3.14)
157
172
 
158
173
    def test_convert_to_python_slong(self):
159
174
        type = 'SLong'
171
186
        self.failUnlessRaises(ExifValueError, tag._convert_to_python, '1E3')
172
187
 
173
188
    def test_convert_to_string_slong(self):
174
 
        xtype = 'SLong'
 
189
        type = 'SLong'
 
190
 
175
191
        # Valid values
176
 
        self.assertEqual(ExifTag._convert_to_string(123, xtype), '123')
177
 
        self.assertEqual(ExifTag._convert_to_string(678024, xtype), '678024')
178
 
        self.assertEqual(ExifTag._convert_to_string(-437, xtype), '-437')
 
192
        tag = ExifTagMock('Exif.OlympusCs.ManometerReading', type)
 
193
        self.assertEqual(tag._convert_to_string(123), '123')
 
194
        self.assertEqual(tag._convert_to_string(678024), '678024')
 
195
        self.assertEqual(tag._convert_to_string(-437), '-437')
 
196
 
179
197
        # Invalid values
180
 
        self.failUnlessRaises(ExifValueError, ExifTag._convert_to_string, 'invalid', xtype)
181
 
        self.failUnlessRaises(ExifValueError, ExifTag._convert_to_string, 3.14, xtype)
 
198
        self.failUnlessRaises(ExifValueError, tag._convert_to_string, 'invalid')
 
199
        self.failUnlessRaises(ExifValueError, tag._convert_to_string, 3.14)
182
200
 
183
201
    def test_convert_to_python_rational(self):
184
202
        type = 'Rational'
194
212
        self.failUnlessRaises(ExifValueError, tag._convert_to_python, '5/-3')
195
213
 
196
214
    def test_convert_to_string_rational(self):
197
 
        xtype = 'Rational'
 
215
        type = 'Rational'
 
216
 
198
217
        # Valid values
199
 
        self.assertEqual(ExifTag._convert_to_string(Rational(5, 3), xtype), '5/3')
 
218
        tag = ExifTagMock('Exif.Image.XResolution', type)
 
219
        self.assertEqual(tag._convert_to_string(Rational(5, 3)), '5/3')
 
220
 
200
221
        # Invalid values
201
 
        self.failUnlessRaises(ExifValueError, ExifTag._convert_to_string, 'invalid', xtype)
202
 
        self.failUnlessRaises(ExifValueError, ExifTag._convert_to_string, Rational(-5, 3), xtype)
 
222
        self.failUnlessRaises(ExifValueError, tag._convert_to_string, 'invalid')
 
223
        self.failUnlessRaises(ExifValueError,
 
224
                              tag._convert_to_string, Rational(-5, 3))
203
225
 
204
226
    def test_convert_to_python_srational(self):
205
227
        type = 'SRational'
215
237
        self.failUnlessRaises(ExifValueError, tag._convert_to_python, '5/-3')
216
238
 
217
239
    def test_convert_to_string_srational(self):
218
 
        xtype = 'SRational'
 
240
        type = 'SRational'
 
241
 
219
242
        # Valid values
220
 
        self.assertEqual(ExifTag._convert_to_string(Rational(5, 3), xtype), '5/3')
221
 
        self.assertEqual(ExifTag._convert_to_string(Rational(-5, 3), xtype), '-5/3')
 
243
        tag = ExifTagMock('Exif.Image.BaselineExposure', type)
 
244
        self.assertEqual(tag._convert_to_string(Rational(5, 3)), '5/3')
 
245
        self.assertEqual(tag._convert_to_string(Rational(-5, 3)), '-5/3')
 
246
 
222
247
        # Invalid values
223
 
        self.failUnlessRaises(ExifValueError, ExifTag._convert_to_string, 'invalid', xtype)
 
248
        self.failUnlessRaises(ExifValueError, tag._convert_to_string, 'invalid')
224
249
 
225
250
    def test_convert_to_python_undefined(self):
226
251
        type = 'Undefined'
236
261
        self.failUnlessRaises(ExifValueError, tag._convert_to_python, 'abc')
237
262
 
238
263
    def test_convert_to_string_undefined(self):
239
 
        xtype = 'Undefined'
 
264
        type = 'Undefined'
 
265
 
240
266
        # Valid values
241
 
        self.assertEqual(ExifTag._convert_to_string('48 49 48 48 ', xtype), '48 49 48 48 ')
242
 
        self.assertEqual(ExifTag._convert_to_string(u'48 49 48 48 ', xtype), '48 49 48 48 ')
 
267
        tag = ExifTagMock('Exif.Photo.ExifVersion', type)
 
268
        self.assertEqual(tag._convert_to_string('48 49 48 48 '), '48 49 48 48 ')
 
269
        self.assertEqual(tag._convert_to_string(u'48 49 48 48 '), '48 49 48 48 ')
 
270
 
243
271
        # Invalid values
244
 
        self.failUnlessRaises(ExifValueError, ExifTag._convert_to_string, 3, xtype)
 
272
        self.failUnlessRaises(ExifValueError, tag._convert_to_string, 3)
245
273
 
246
274
    def test_set_value_no_metadata(self):
247
275
        tag = ExifTag('Exif.Thumbnail.Orientation', 'Orientation',