zope.i18n 5.1__py3-none-any.whl → 5.2__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (11) hide show
  1. zope/i18n/format.py +1 -1
  2. zope/i18n/testmessagecatalog.py +2 -2
  3. zope/i18n/tests/test_formats.py +603 -714
  4. zope/i18n/tests/test_translationdomain.py +11 -4
  5. {zope.i18n-5.1.dist-info → zope.i18n-5.2.dist-info}/METADATA +14 -3
  6. {zope.i18n-5.1.dist-info → zope.i18n-5.2.dist-info}/RECORD +11 -11
  7. {zope.i18n-5.1.dist-info → zope.i18n-5.2.dist-info}/WHEEL +1 -1
  8. /zope.i18n-5.1-py3.11-nspkg.pth → /zope.i18n-5.2-py3.11-nspkg.pth +0 -0
  9. {zope.i18n-5.1.dist-info → zope.i18n-5.2.dist-info}/LICENSE.txt +0 -0
  10. {zope.i18n-5.1.dist-info → zope.i18n-5.2.dist-info}/namespace_packages.txt +0 -0
  11. {zope.i18n-5.1.dist-info → zope.i18n-5.2.dist-info}/top_level.txt +0 -0
zope/i18n/tests/test_formats.py CHANGED
@@ -74,8 +74,9 @@ class LocaleCalendarStub:
74
74
  week = {'firstDay': 1, 'minDays': 1}
75
75
 
76
76
  def getMonthNames(self):
77
- return [self.months.get(type, (None, None))[0]
78
- for type in range(1, 13)]
77
+ return [
78
+ self.months.get(type, (None, None))[0] for type in range(1, 13)
79
+ ]
79
80
 
80
81
  def getMonthTypeFromName(self, name):
81
82
  for item in self.months.items():
@@ -83,8 +84,9 @@ class LocaleCalendarStub:
83
84
  return item[0]
84
85
 
85
86
  def getMonthAbbreviations(self):
86
- return [self.months.get(type, (None, None))[1]
87
- for type in range(1, 13)]
87
+ return [
88
+ self.months.get(type, (None, None))[1] for type in range(1, 13)
89
+ ]
88
90
 
89
91
  def getMonthTypeFromAbbreviation(self, abbr):
90
92
  for item in self.months.items():
@@ -108,14 +110,14 @@ class TestDateTimePatternParser(TestCase):
108
110
  """Extensive tests for the ICU-based-syntax datetime pattern parser."""
109
111
 
110
112
  def testParseSimpleTimePattern(self):
111
- self.assertEqual(parseDateTimePattern('HH'),
112
- [('H', 2)])
113
- self.assertEqual(parseDateTimePattern('HH:mm'),
114
- [('H', 2), ':', ('m', 2)])
115
- self.assertEqual(parseDateTimePattern('HH:mm:ss'),
116
- [('H', 2), ':', ('m', 2), ':', ('s', 2)])
117
- self.assertEqual(parseDateTimePattern('mm:ss'),
118
- [('m', 2), ':', ('s', 2)])
113
+ self.assertEqual(parseDateTimePattern('HH'), [('H', 2)])
114
+ self.assertEqual(parseDateTimePattern('HH:mm'), [('H', 2), ':',
115
+ ('m', 2)])
116
+ self.assertEqual(parseDateTimePattern('HH:mm:ss'), [('H', 2), ':',
117
+ ('m', 2), ':',
118
+ ('s', 2)])
119
+ self.assertEqual(parseDateTimePattern('mm:ss'), [('m', 2), ':',
120
+ ('s', 2)])
119
121
  self.assertEqual(parseDateTimePattern('H:m:s'),
120
122
  [('H', 1), ':', ('m', 1), ':', ('s', 1)])
121
123
  self.assertEqual(parseDateTimePattern('HHH:mmmm:sssss'),
@@ -126,62 +128,65 @@ class TestDateTimePatternParser(TestCase):
126
128
  self.assertEqual(parseDateTimePattern("H:mm' Uhr 'z"),
127
129
  [('H', 1), ':', ('m', 2), ' Uhr ', ('z', 1)])
128
130
  # German long
129
- self.assertEqual(parseDateTimePattern("HH:mm:ss z"),
130
- [('H', 2), ':', ('m', 2), ':', ('s', 2), ' ',
131
- ('z', 1)])
131
+ self.assertEqual(parseDateTimePattern("HH:mm:ss z"), [('H', 2), ':',
132
+ ('m', 2), ':',
133
+ ('s', 2), ' ',
134
+ ('z', 1)])
132
135
  # German medium
133
- self.assertEqual(parseDateTimePattern("HH:mm:ss"),
134
- [('H', 2), ':', ('m', 2), ':', ('s', 2)])
136
+ self.assertEqual(parseDateTimePattern("HH:mm:ss"), [('H', 2), ':',
137
+ ('m', 2), ':',
138
+ ('s', 2)])
135
139
  # German short
136
- self.assertEqual(parseDateTimePattern("HH:mm"),
137
- [('H', 2), ':', ('m', 2)])
140
+ self.assertEqual(parseDateTimePattern("HH:mm"), [('H', 2), ':',
141
+ ('m', 2)])
138
142
 
139
143
  def testParseRealDate(self):
140
144
  # German full
141
145
  self.assertEqual(parseDateTimePattern("EEEE, d. MMMM yyyy"),
142
- [('E', 4), ', ', ('d', 1), '. ', ('M', 4),
143
- ' ', ('y', 4)])
146
+ [('E', 4), ', ', ('d', 1), '. ', ('M', 4), ' ',
147
+ ('y', 4)])
144
148
  # German long
145
- self.assertEqual(parseDateTimePattern("d. MMMM yyyy"),
146
- [('d', 1), '. ', ('M', 4), ' ', ('y', 4)])
149
+ self.assertEqual(parseDateTimePattern("d. MMMM yyyy"), [('d', 1), '. ',
150
+ ('M', 4), ' ',
151
+ ('y', 4)])
147
152
  # German medium
148
- self.assertEqual(parseDateTimePattern("dd.MM.yyyy"),
149
- [('d', 2), '.', ('M', 2), '.', ('y', 4)])
153
+ self.assertEqual(parseDateTimePattern("dd.MM.yyyy"), [('d', 2), '.',
154
+ ('M', 2), '.',
155
+ ('y', 4)])
150
156
  # German short
151
- self.assertEqual(parseDateTimePattern("dd.MM.yy"),
152
- [('d', 2), '.', ('M', 2), '.', ('y', 2)])
157
+ self.assertEqual(parseDateTimePattern("dd.MM.yy"), [('d', 2), '.',
158
+ ('M', 2), '.',
159
+ ('y', 2)])
153
160
 
154
161
  def testParseRealDateTime(self):
155
162
  # German full
156
163
  self.assertEqual(
157
164
  parseDateTimePattern("EEEE, d. MMMM yyyy H:mm' Uhr 'z"),
158
- [('E', 4), ', ', ('d', 1), '. ', ('M', 4), ' ', ('y', 4),
159
- ' ', ('H', 1), ':', ('m', 2), ' Uhr ', ('z', 1)])
165
+ [('E', 4), ', ', ('d', 1), '. ', ('M', 4), ' ', ('y', 4), ' ',
166
+ ('H', 1), ':', ('m', 2), ' Uhr ', ('z', 1)])
160
167
  # German long
161
- self.assertEqual(
162
- parseDateTimePattern("d. MMMM yyyy HH:mm:ss z"),
163
- [('d', 1), '. ', ('M', 4), ' ', ('y', 4),
164
- ' ', ('H', 2), ':', ('m', 2), ':', ('s', 2), ' ', ('z', 1)])
168
+ self.assertEqual(parseDateTimePattern("d. MMMM yyyy HH:mm:ss z"),
169
+ [('d', 1), '. ', ('M', 4), ' ', ('y', 4), ' ',
170
+ ('H', 2), ':', ('m', 2), ':', ('s', 2), ' ',
171
+ ('z', 1)])
165
172
  # German medium
166
- self.assertEqual(
167
- parseDateTimePattern("dd.MM.yyyy HH:mm:ss"),
168
- [('d', 2), '.', ('M', 2), '.', ('y', 4),
169
- ' ', ('H', 2), ':', ('m', 2), ':', ('s', 2)])
173
+ self.assertEqual(parseDateTimePattern("dd.MM.yyyy HH:mm:ss"),
174
+ [('d', 2), '.', ('M', 2), '.', ('y', 4), ' ',
175
+ ('H', 2), ':', ('m', 2), ':', ('s', 2)])
170
176
  # German short
171
- self.assertEqual(
172
- parseDateTimePattern("dd.MM.yy HH:mm"),
173
- [('d', 2), '.', ('M', 2), '.', ('y', 2),
174
- ' ', ('H', 2), ':', ('m', 2)])
177
+ self.assertEqual(parseDateTimePattern("dd.MM.yy HH:mm"),
178
+ [('d', 2), '.', ('M', 2), '.', ('y', 2), ' ',
179
+ ('H', 2), ':', ('m', 2)])
175
180
 
176
181
  def testParseQuotesInPattern(self):
177
- self.assertEqual(parseDateTimePattern("HH''mm"),
178
- [('H', 2), "'", ('m', 2)])
179
- self.assertEqual(parseDateTimePattern("HH'HHmm'mm"),
180
- [('H', 2), 'HHmm', ('m', 2)])
182
+ self.assertEqual(parseDateTimePattern("HH''mm"), [('H', 2), "'",
183
+ ('m', 2)])
184
+ self.assertEqual(parseDateTimePattern("HH'HHmm'mm"), [('H', 2), 'HHmm',
185
+ ('m', 2)])
181
186
  self.assertEqual(parseDateTimePattern("HH':'''':'mm"),
182
187
  [('H', 2), ":':", ('m', 2)])
183
- self.assertEqual(parseDateTimePattern("HH':' ':'mm"),
184
- [('H', 2), ": :", ('m', 2)])
188
+ self.assertEqual(parseDateTimePattern("HH':' ':'mm"), [('H', 2), ": :",
189
+ ('m', 2)])
185
190
 
186
191
  def testParseDateTimePatternError(self):
187
192
  # Quote not closed
@@ -196,10 +201,7 @@ class TestDateTimePatternParser(TestCase):
196
201
 
197
202
  def testParseDateTimePatternRepeatDateTimeChars(self):
198
203
  result = parseDateTimePattern('aG')
199
- self.assertEqual(
200
- result,
201
- [('a', 1), ('G', 1)]
202
- )
204
+ self.assertEqual(result, [('a', 1), ('G', 1)])
203
205
 
204
206
 
205
207
  class TestBuildDateTimeParseInfo(TestCase):
@@ -245,14 +247,17 @@ class TestBuildDateTimeParseInfo(TestCase):
245
247
  self.assertEqual(self.info(('M', 2)), '([0-9]{2})')
246
248
 
247
249
  def testMonthNames(self):
248
- names = ["Januar", "Februar", "Maerz", "April",
249
- "Mai", "Juni", "Juli", "August", "September", "Oktober",
250
- "November", "Dezember"]
250
+ names = [
251
+ "Januar", "Februar", "Maerz", "April", "Mai", "Juni", "Juli",
252
+ "August", "September", "Oktober", "November", "Dezember"
253
+ ]
251
254
  self.assertEqual(self.info(('M', 4)), '(' + '|'.join(names) + ')')
252
255
 
253
256
  def testMonthAbbr(self):
254
- names = ['Jan', 'Feb', 'Mrz', 'Apr', 'Mai', 'Jun', 'Jul', 'Aug',
255
- 'Sep', 'Okt', 'Nov', 'Dez']
257
+ names = [
258
+ 'Jan', 'Feb', 'Mrz', 'Apr', 'Mai', 'Jun', 'Jul', 'Aug', 'Sep',
259
+ 'Okt', 'Nov', 'Dez'
260
+ ]
256
261
  self.assertEqual(self.info(('M', 3)), '(' + '|'.join(names) + ')')
257
262
 
258
263
  def testWeekdayNumber(self):
@@ -260,8 +265,10 @@ class TestBuildDateTimeParseInfo(TestCase):
260
265
  self.assertEqual(self.info(('E', 2)), '([0-9]{2})')
261
266
 
262
267
  def testWeekdayNames(self):
263
- names = ['Montag', 'Dienstag', 'Mittwoch', 'Donnerstag',
264
- 'Freitag', 'Samstag', 'Sonntag']
268
+ names = [
269
+ 'Montag', 'Dienstag', 'Mittwoch', 'Donnerstag', 'Freitag',
270
+ 'Samstag', 'Sonntag'
271
+ ]
265
272
  self.assertEqual(self.info(('E', 4)), '(' + '|'.join(names) + ')')
266
273
  self.assertEqual(self.info(('E', 5)), '(' + '|'.join(names) + ')')
267
274
  self.assertEqual(self.info(('E', 10)), '(' + '|'.join(names) + ')')
@@ -282,9 +289,8 @@ class TestDateTimeFormat(TestCase):
282
289
 
283
290
  def testParseSimpleDateTime(self):
284
291
  # German short
285
- self.assertEqual(
286
- self.format.parse('02.01.03 21:48', 'dd.MM.yy HH:mm'),
287
- datetime.datetime(2003, 1, 2, 21, 48))
292
+ self.assertEqual(self.format.parse('02.01.03 21:48', 'dd.MM.yy HH:mm'),
293
+ datetime.datetime(2003, 1, 2, 21, 48))
288
294
 
289
295
  def testParseRealDateTime(self):
290
296
  # German medium
@@ -295,18 +301,16 @@ class TestDateTimeFormat(TestCase):
295
301
  # German long
296
302
  # TODO: The parser does not support timezones yet.
297
303
  self.assertEqual(
298
- self.format.parse(
299
- '2. Januar 2003 21:48:01 +100',
300
- 'd. MMMM yyyy HH:mm:ss z'),
304
+ self.format.parse('2. Januar 2003 21:48:01 +100',
305
+ 'd. MMMM yyyy HH:mm:ss z'),
301
306
  pytz.timezone('Europe/Berlin').localize(
302
307
  datetime.datetime(2003, 1, 2, 21, 48, 1)))
303
308
 
304
309
  # German full
305
310
  # TODO: The parser does not support timezones yet.
306
311
  self.assertEqual(
307
- self.format.parse(
308
- 'Donnerstag, 2. Januar 2003 21:48 Uhr +100',
309
- "EEEE, d. MMMM yyyy H:mm' Uhr 'z"),
312
+ self.format.parse('Donnerstag, 2. Januar 2003 21:48 Uhr +100',
313
+ "EEEE, d. MMMM yyyy H:mm' Uhr 'z"),
310
314
  pytz.timezone('Europe/Berlin').localize(
311
315
  datetime.datetime(2003, 1, 2, 21, 48)))
312
316
 
@@ -389,23 +393,21 @@ class TestDateTimeFormat(TestCase):
389
393
  datetime.datetime(2003, 1, 1, 00, 00, 00, 00))
390
394
 
391
395
  def testParseNotObject(self):
392
- self.assertEqual(
393
- ('2017', '01', '01'),
394
- self.format.parse('2017-01-01', 'yyyy-MM-dd', asObject=False))
396
+ self.assertEqual(('2017', '01', '01'),
397
+ self.format.parse('2017-01-01',
398
+ 'yyyy-MM-dd',
399
+ asObject=False))
395
400
 
396
401
  def testParseTwoDigitYearIs20thCentury(self):
397
- self.assertEqual(
398
- datetime.date(1952, 1, 1),
399
- self.format.parse('52-01-01', 'yy-MM-dd'))
402
+ self.assertEqual(datetime.date(1952, 1, 1),
403
+ self.format.parse('52-01-01', 'yy-MM-dd'))
400
404
 
401
405
  # 30 is the cut off
402
- self.assertEqual(
403
- datetime.date(1931, 1, 1),
404
- self.format.parse('31-01-01', 'yy-MM-dd'))
406
+ self.assertEqual(datetime.date(1931, 1, 1),
407
+ self.format.parse('31-01-01', 'yy-MM-dd'))
405
408
 
406
- self.assertEqual(
407
- datetime.date(2030, 1, 1),
408
- self.format.parse('30-01-01', 'yy-MM-dd'))
409
+ self.assertEqual(datetime.date(2030, 1, 1),
410
+ self.format.parse('30-01-01', 'yy-MM-dd'))
409
411
 
410
412
  def testParseAMPMMissing(self):
411
413
  with self.assertRaisesRegex(
@@ -417,105 +419,82 @@ class TestDateTimeFormat(TestCase):
417
419
  # Produces an object without pytz info
418
420
  self.assertEqual(
419
421
  datetime.time(21, 48, 1),
420
- self.format.parse(
421
- '21:48:01 Bad/Timezone',
422
- 'HH:mm:ss zzzz'))
422
+ self.format.parse('21:48:01 Bad/Timezone', 'HH:mm:ss zzzz'))
423
423
 
424
424
  def testParsePyTzTimezone(self):
425
425
  tzinfo = pytz.timezone("US/Central")
426
426
  self.assertEqual(
427
427
  datetime.time(21, 48, 1, tzinfo=tzinfo),
428
- self.format.parse(
429
- '21:48:01 US/Central',
430
- 'HH:mm:ss zzzz'))
428
+ self.format.parse('21:48:01 US/Central', 'HH:mm:ss zzzz'))
431
429
 
432
430
  def testFormatSimpleDateTime(self):
433
431
  # German short
434
432
  self.assertEqual(
435
433
  self.format.format(datetime.datetime(2003, 1, 2, 21, 48),
436
- 'dd.MM.yy HH:mm'),
437
- '02.01.03 21:48')
434
+ 'dd.MM.yy HH:mm'), '02.01.03 21:48')
438
435
 
439
436
  def testFormatRealDateTime(self):
440
437
  tz = pytz.timezone('Europe/Berlin')
441
438
  dt = tz.localize(datetime.datetime(2003, 1, 2, 21, 48, 1))
442
439
  # German medium
443
- self.assertEqual(
444
- self.format.format(dt, 'dd.MM.yyyy HH:mm:ss'),
445
- '02.01.2003 21:48:01')
440
+ self.assertEqual(self.format.format(dt, 'dd.MM.yyyy HH:mm:ss'),
441
+ '02.01.2003 21:48:01')
446
442
 
447
443
  # German long
448
- self.assertEqual(
449
- self.format.format(dt, 'd. MMMM yyyy HH:mm:ss z'),
450
- '2. Januar 2003 21:48:01 +100')
444
+ self.assertEqual(self.format.format(dt, 'd. MMMM yyyy HH:mm:ss z'),
445
+ '2. Januar 2003 21:48:01 +100')
451
446
 
452
447
  # German full
453
448
  self.assertEqual(
454
- self.format.format(
455
- dt, "EEEE, d. MMMM yyyy H:mm' Uhr 'z"),
449
+ self.format.format(dt, "EEEE, d. MMMM yyyy H:mm' Uhr 'z"),
456
450
  'Donnerstag, 2. Januar 2003 21:48 Uhr +100')
457
451
 
458
452
  def testFormatAMPMDateTime(self):
459
453
  self.assertEqual(
460
- self.format.format(
461
- datetime.datetime(2003, 1, 2, 21, 48),
462
- 'dd.MM.yy hh:mm a'),
463
- '02.01.03 09:48 nachm.')
454
+ self.format.format(datetime.datetime(2003, 1, 2, 21, 48),
455
+ 'dd.MM.yy hh:mm a'), '02.01.03 09:48 nachm.')
464
456
 
465
457
  def testFormatAllWeekdays(self):
466
458
  for day in range(1, 8):
467
459
  self.assertEqual(
468
- self.format.format(
469
- datetime.datetime(2003, 1, day + 5, 21, 48),
470
- "EEEE, d. MMMM yyyy H:mm' Uhr 'z"),
471
- '%s, %i. Januar 2003 21:48 Uhr +000' % (
472
- self.format.calendar.days[day][0], day + 5))
460
+ self.format.format(datetime.datetime(2003, 1, day + 5, 21, 48),
461
+ "EEEE, d. MMMM yyyy H:mm' Uhr 'z"),
462
+ '%s, %i. Januar 2003 21:48 Uhr +000' %
463
+ (self.format.calendar.days[day][0], day + 5))
473
464
 
474
465
  def testFormatTimeZone(self):
475
466
  self.assertEqual(
476
- self.format.format(
477
- datetime.datetime(2003, 1, 2, 12, 00), 'z'),
467
+ self.format.format(datetime.datetime(2003, 1, 2, 12, 00), 'z'),
478
468
  '+000')
479
469
  self.assertEqual(
480
- self.format.format(
481
- datetime.datetime(2003, 1, 2, 12, 00), 'zz'),
470
+ self.format.format(datetime.datetime(2003, 1, 2, 12, 00), 'zz'),
482
471
  '+00:00')
483
472
  self.assertEqual(
484
- self.format.format(
485
- datetime.datetime(2003, 1, 2, 12, 00), 'zzz'),
473
+ self.format.format(datetime.datetime(2003, 1, 2, 12, 00), 'zzz'),
486
474
  'UTC')
487
475
  self.assertEqual(
488
- self.format.format(
489
- datetime.datetime(2003, 1, 2, 12, 00), 'zzzz'),
476
+ self.format.format(datetime.datetime(2003, 1, 2, 12, 00), 'zzzz'),
490
477
  'UTC')
491
478
  tz = pytz.timezone('US/Eastern')
492
479
  self.assertEqual(
493
- self.format.format(
494
- tz.localize(datetime.datetime(2003, 1, 2, 12)), 'z'),
495
- '-500')
480
+ self.format.format(tz.localize(datetime.datetime(2003, 1, 2, 12)),
481
+ 'z'), '-500')
496
482
  self.assertEqual(
497
- self.format.format(
498
- tz.localize(datetime.datetime(2003, 1, 2, 12)), 'zz'),
499
- '-05:00')
483
+ self.format.format(tz.localize(datetime.datetime(2003, 1, 2, 12)),
484
+ 'zz'), '-05:00')
500
485
  self.assertEqual(
501
- self.format.format(
502
- tz.localize(datetime.datetime(2003, 1, 2, 12)), 'zzz'),
503
- 'EST')
486
+ self.format.format(tz.localize(datetime.datetime(2003, 1, 2, 12)),
487
+ 'zzz'), 'EST')
504
488
  self.assertEqual(
505
- self.format.format(
506
- tz.localize(datetime.datetime(2003, 1, 2, 12)), 'zzzz'),
507
- 'US/Eastern')
489
+ self.format.format(tz.localize(datetime.datetime(2003, 1, 2, 12)),
490
+ 'zzzz'), 'US/Eastern')
508
491
 
509
492
  def testFormatWeekDay(self):
510
493
  date = datetime.date(2003, 1, 2)
511
- self.assertEqual(self.format.format(date, "E"),
512
- '4')
513
- self.assertEqual(self.format.format(date, "EE"),
514
- '04')
515
- self.assertEqual(self.format.format(date, "EEE"),
516
- 'Do')
517
- self.assertEqual(self.format.format(date, "EEEE"),
518
- 'Donnerstag')
494
+ self.assertEqual(self.format.format(date, "E"), '4')
495
+ self.assertEqual(self.format.format(date, "EE"), '04')
496
+ self.assertEqual(self.format.format(date, "EEE"), 'Do')
497
+ self.assertEqual(self.format.format(date, "EEEE"), 'Donnerstag')
519
498
 
520
499
  # Create custom calendar, which has Sunday as the first day of the
521
500
  # week. I am assigning a totally new dict here, since dicts are
@@ -525,80 +504,47 @@ class TestDateTimeFormat(TestCase):
525
504
  calendar.week = {'firstDay': 7, 'minDays': 1}
526
505
  format = DateTimeFormat(calendar=calendar)
527
506
 
528
- self.assertEqual(format.format(date, "E"),
529
- '5')
530
- self.assertEqual(format.format(date, "EE"),
531
- '05')
507
+ self.assertEqual(format.format(date, "E"), '5')
508
+ self.assertEqual(format.format(date, "EE"), '05')
532
509
 
533
510
  def testFormatDayOfWeekInMonth(self):
534
511
  date = datetime.date(2003, 1, 2)
535
- self.assertEqual(self.format.format(date, "F"),
536
- '1')
537
- self.assertEqual(self.format.format(date, "FF"),
538
- '01')
539
- self.assertEqual(
540
- self.format.format(datetime.date(2003, 1, 9), "F"),
541
- '2')
542
- self.assertEqual(
543
- self.format.format(datetime.date(2003, 1, 16), "F"),
544
- '3')
545
- self.assertEqual(
546
- self.format.format(datetime.date(2003, 1, 23), "F"),
547
- '4')
512
+ self.assertEqual(self.format.format(date, "F"), '1')
513
+ self.assertEqual(self.format.format(date, "FF"), '01')
514
+ self.assertEqual(self.format.format(datetime.date(2003, 1, 9), "F"),
515
+ '2')
516
+ self.assertEqual(self.format.format(datetime.date(2003, 1, 16), "F"),
517
+ '3')
518
+ self.assertEqual(self.format.format(datetime.date(2003, 1, 23), "F"),
519
+ '4')
548
520
 
549
521
  def testFormatWeekInMonth(self):
550
- self.assertEqual(
551
- self.format.format(datetime.date(2003, 1, 3), "W"),
552
- '1')
553
- self.assertEqual(
554
- self.format.format(datetime.date(2003, 1, 3), "WW"),
555
- '01')
556
- self.assertEqual(
557
- self.format.format(datetime.date(2003, 1, 8), "W"),
558
- '2')
559
- self.assertEqual(
560
- self.format.format(datetime.date(2003, 1, 19), "W"),
561
- '3')
562
- self.assertEqual(
563
- self.format.format(datetime.date(2003, 1, 20), "W"),
564
- '4')
565
- self.assertEqual(
566
- self.format.format(datetime.date(2003, 1, 31), "W"),
567
- '5')
522
+ self.assertEqual(self.format.format(datetime.date(2003, 1, 3), "W"),
523
+ '1')
524
+ self.assertEqual(self.format.format(datetime.date(2003, 1, 3), "WW"),
525
+ '01')
526
+ self.assertEqual(self.format.format(datetime.date(2003, 1, 8), "W"),
527
+ '2')
528
+ self.assertEqual(self.format.format(datetime.date(2003, 1, 19), "W"),
529
+ '3')
530
+ self.assertEqual(self.format.format(datetime.date(2003, 1, 20), "W"),
531
+ '4')
532
+ self.assertEqual(self.format.format(datetime.date(2003, 1, 31), "W"),
533
+ '5')
568
534
 
569
535
  def testFormatHourInDayOneTo24(self):
570
- self.assertEqual(
571
- self.format.format(datetime.time(5, 0), "k"),
572
- '5')
573
- self.assertEqual(
574
- self.format.format(datetime.time(5, 0), "kk"),
575
- '05')
576
- self.assertEqual(
577
- self.format.format(datetime.time(0, 0), "k"),
578
- '24')
579
- self.assertEqual(
580
- self.format.format(datetime.time(1, 0), "k"),
581
- '1')
536
+ self.assertEqual(self.format.format(datetime.time(5, 0), "k"), '5')
537
+ self.assertEqual(self.format.format(datetime.time(5, 0), "kk"), '05')
538
+ self.assertEqual(self.format.format(datetime.time(0, 0), "k"), '24')
539
+ self.assertEqual(self.format.format(datetime.time(1, 0), "k"), '1')
582
540
 
583
541
  def testFormatHourInDayZeroToEleven(self):
584
- self.assertEqual(
585
- self.format.format(datetime.time(5, 0), "K"),
586
- '5')
587
- self.assertEqual(
588
- self.format.format(datetime.time(5, 0), "KK"),
589
- '05')
590
- self.assertEqual(
591
- self.format.format(datetime.time(0, 0), "K"),
592
- '0')
593
- self.assertEqual(
594
- self.format.format(datetime.time(12, 0), "K"),
595
- '0')
596
- self.assertEqual(
597
- self.format.format(datetime.time(11, 0), "K"),
598
- '11')
599
- self.assertEqual(
600
- self.format.format(datetime.time(23, 0), "K"),
601
- '11')
542
+ self.assertEqual(self.format.format(datetime.time(5, 0), "K"), '5')
543
+ self.assertEqual(self.format.format(datetime.time(5, 0), "KK"), '05')
544
+ self.assertEqual(self.format.format(datetime.time(0, 0), "K"), '0')
545
+ self.assertEqual(self.format.format(datetime.time(12, 0), "K"), '0')
546
+ self.assertEqual(self.format.format(datetime.time(11, 0), "K"), '11')
547
+ self.assertEqual(self.format.format(datetime.time(23, 0), "K"), '11')
602
548
 
603
549
  def testFormatSimpleHourRepresentation(self):
604
550
  self.assertEqual(
@@ -607,63 +553,45 @@ class TestDateTimeFormat(TestCase):
607
553
  '02.01.03 11:00:00 nachm.')
608
554
  self.assertEqual(
609
555
  self.format.format(datetime.datetime(2003, 1, 2, 2, 00),
610
- 'dd.MM.yy h:mm:ss a'),
611
- '02.01.03 2:00:00 vorm.')
612
- self.assertEqual(
613
- self.format.format(datetime.time(0, 15), 'h:mm a'),
614
- '12:15 vorm.')
615
- self.assertEqual(
616
- self.format.format(datetime.time(1, 15), 'h:mm a'),
617
- '1:15 vorm.')
618
- self.assertEqual(
619
- self.format.format(datetime.time(12, 15), 'h:mm a'),
620
- '12:15 nachm.')
621
- self.assertEqual(
622
- self.format.format(datetime.time(13, 15), 'h:mm a'),
623
- '1:15 nachm.')
556
+ 'dd.MM.yy h:mm:ss a'), '02.01.03 2:00:00 vorm.')
557
+ self.assertEqual(self.format.format(datetime.time(0, 15), 'h:mm a'),
558
+ '12:15 vorm.')
559
+ self.assertEqual(self.format.format(datetime.time(1, 15), 'h:mm a'),
560
+ '1:15 vorm.')
561
+ self.assertEqual(self.format.format(datetime.time(12, 15), 'h:mm a'),
562
+ '12:15 nachm.')
563
+ self.assertEqual(self.format.format(datetime.time(13, 15), 'h:mm a'),
564
+ '1:15 nachm.')
624
565
 
625
566
  def testFormatDayInYear(self):
567
+ self.assertEqual(self.format.format(datetime.date(2003, 1, 3), 'D'),
568
+ "3")
569
+ self.assertEqual(self.format.format(datetime.date(2003, 1, 3), 'DD'),
570
+ "03")
571
+ self.assertEqual(self.format.format(datetime.date(2003, 1, 3), 'DDD'),
572
+ "003")
573
+ self.assertEqual(self.format.format(datetime.date(2003, 12, 31), 'D'),
574
+ "365")
575
+ self.assertEqual(self.format.format(datetime.date(2003, 12, 31), 'DD'),
576
+ "365")
626
577
  self.assertEqual(
627
- self.format.format(datetime.date(2003, 1, 3), 'D'),
628
- "3")
629
- self.assertEqual(
630
- self.format.format(datetime.date(2003, 1, 3), 'DD'),
631
- "03")
578
+ self.format.format(datetime.date(2003, 12, 31), 'DDD'), "365")
632
579
  self.assertEqual(
633
- self.format.format(datetime.date(2003, 1, 3), 'DDD'),
634
- "003")
635
- self.assertEqual(
636
- self.format.format(datetime.date(2003, 12, 31), 'D'),
637
- "365")
638
- self.assertEqual(
639
- self.format.format(datetime.date(2003, 12, 31), 'DD'),
640
- "365")
641
- self.assertEqual(
642
- self.format.format(datetime.date(2003, 12, 31), 'DDD'),
643
- "365")
644
- self.assertEqual(
645
- self.format.format(datetime.date(2004, 12, 31), 'DDD'),
646
- "366")
580
+ self.format.format(datetime.date(2004, 12, 31), 'DDD'), "366")
647
581
 
648
582
  def testFormatDayOfWeekInMOnth(self):
649
- self.assertEqual(
650
- self.format.format(datetime.date(2003, 1, 3), 'F'),
651
- "1")
652
- self.assertEqual(
653
- self.format.format(datetime.date(2003, 1, 10), 'F'),
654
- "2")
655
- self.assertEqual(
656
- self.format.format(datetime.date(2003, 1, 17), 'F'),
657
- "3")
658
- self.assertEqual(
659
- self.format.format(datetime.date(2003, 1, 24), 'F'),
660
- "4")
661
- self.assertEqual(
662
- self.format.format(datetime.date(2003, 1, 31), 'F'),
663
- "5")
664
- self.assertEqual(
665
- self.format.format(datetime.date(2003, 1, 6), 'F'),
666
- "1")
583
+ self.assertEqual(self.format.format(datetime.date(2003, 1, 3), 'F'),
584
+ "1")
585
+ self.assertEqual(self.format.format(datetime.date(2003, 1, 10), 'F'),
586
+ "2")
587
+ self.assertEqual(self.format.format(datetime.date(2003, 1, 17), 'F'),
588
+ "3")
589
+ self.assertEqual(self.format.format(datetime.date(2003, 1, 24), 'F'),
590
+ "4")
591
+ self.assertEqual(self.format.format(datetime.date(2003, 1, 31), 'F'),
592
+ "5")
593
+ self.assertEqual(self.format.format(datetime.date(2003, 1, 6), 'F'),
594
+ "1")
667
595
 
668
596
  def testFormatUnusualFormats(self):
669
597
  self.assertEqual(
@@ -675,90 +603,95 @@ class TestDateTimeFormat(TestCase):
675
603
  "2. Freitag im Januar, 2003")
676
604
 
677
605
  def testFormatGregorianEra(self):
678
- self.assertEqual(
679
- self.format.format(datetime.date(2017, 12, 17), 'G'),
680
- 'n. Chr.'
681
- )
606
+ self.assertEqual(self.format.format(datetime.date(2017, 12, 17), 'G'),
607
+ 'n. Chr.')
682
608
 
683
609
  def testFormateMonthLengthOne(self):
684
- self.assertEqual(
685
- self.format.format(datetime.date(2017, 12, 17), 'M'),
686
- '12'
687
- )
610
+ self.assertEqual(self.format.format(datetime.date(2017, 12, 17), 'M'),
611
+ '12')
688
612
 
689
613
 
690
614
  class TestNumberPatternParser(TestCase):
691
615
  """Extensive tests for the ICU-based-syntax number pattern parser."""
692
616
 
693
617
  def testParseSimpleIntegerPattern(self):
694
- self.assertEqual(
695
- parseNumberPattern('###0'),
696
- ((None, '', None, '###0', '', '', None, '', None, ()),
697
- (None, '', None, '###0', '', '', None, '', None, ())))
618
+ self.assertEqual(parseNumberPattern('###0'),
619
+ ((None, '', None, '###0', '', '', None, '', None, ()),
620
+ (None, '', None, '###0', '', '', None, '', None,
621
+ ())))
698
622
 
699
623
  def testParseScientificIntegerPattern(self):
700
- self.assertEqual(
701
- parseNumberPattern('###0E#0'),
702
- ((None, '', None, '###0', '', '#0', None, '', None, ()),
703
- (None, '', None, '###0', '', '#0', None, '', None, ())))
704
- self.assertEqual(
705
- parseNumberPattern('###0E+#0'),
706
- ((None, '', None, '###0', '', '+#0', None, '', None, ()),
707
- (None, '', None, '###0', '', '+#0', None, '', None, ())))
624
+ self.assertEqual(parseNumberPattern('###0E#0'),
625
+ ((None, '', None, '###0', '', '#0', None, '', None,
626
+ ()),
627
+ (None, '', None, '###0', '', '#0', None, '', None,
628
+ ())))
629
+ self.assertEqual(parseNumberPattern('###0E+#0'),
630
+ ((None, '', None, '###0', '', '+#0', None, '', None,
631
+ ()),
632
+ (None, '', None, '###0', '', '+#0', None, '', None,
633
+ ())))
708
634
 
709
635
  def testParsePosNegAlternativeIntegerPattern(self):
710
- self.assertEqual(
711
- parseNumberPattern('###0;#0'),
712
- ((None, '', None, '###0', '', '', None, '', None, ()),
713
- (None, '', None, '#0', '', '', None, '', None, ())))
636
+ self.assertEqual(parseNumberPattern('###0;#0'),
637
+ ((None, '', None, '###0', '', '', None, '', None, ()),
638
+ (None, '', None, '#0', '', '', None, '', None, ())))
714
639
 
715
640
  def testParsePrefixedIntegerPattern(self):
716
- self.assertEqual(
717
- parseNumberPattern('+###0'),
718
- ((None, '+', None, '###0', '', '', None, '', None, ()),
719
- (None, '+', None, '###0', '', '', None, '', None, ())))
641
+ self.assertEqual(parseNumberPattern('+###0'),
642
+ ((None, '+', None, '###0', '', '', None, '', None,
643
+ ()),
644
+ (None, '+', None, '###0', '', '', None, '', None,
645
+ ())))
720
646
 
721
647
  def testParsePosNegIntegerPattern(self):
722
- self.assertEqual(
723
- parseNumberPattern('+###0;-###0'),
724
- ((None, '+', None, '###0', '', '', None, '', None, ()),
725
- (None, '-', None, '###0', '', '', None, '', None, ())))
648
+ self.assertEqual(parseNumberPattern('+###0;-###0'),
649
+ ((None, '+', None, '###0', '', '', None, '', None,
650
+ ()),
651
+ (None, '-', None, '###0', '', '', None, '', None,
652
+ ())))
726
653
 
727
654
  def testParseScientificPosNegIntegerPattern(self):
728
- self.assertEqual(
729
- parseNumberPattern('+###0E0;-###0E#0'),
730
- ((None, '+', None, '###0', '', '0', None, '', None, ()),
731
- (None, '-', None, '###0', '', '#0', None, '', None, ())))
655
+ self.assertEqual(parseNumberPattern('+###0E0;-###0E#0'),
656
+ ((None, '+', None, '###0', '', '0', None, '', None,
657
+ ()),
658
+ (None, '-', None, '###0', '', '#0', None, '', None,
659
+ ())))
732
660
 
733
661
  def testParseThousandSeparatorIntegerPattern(self):
734
- self.assertEqual(
735
- parseNumberPattern('#,##0'),
736
- ((None, '', None, '###0', '', '', None, '', None, (3, 0)),
737
- (None, '', None, '###0', '', '', None, '', None, (3, 0))))
662
+ self.assertEqual(parseNumberPattern('#,##0'),
663
+ ((None, '', None, '###0', '', '', None, '', None,
664
+ (3, 0)),
665
+ (None, '', None, '###0', '', '', None, '', None,
666
+ (3, 0))))
738
667
 
739
668
  def testParseSimpleDecimalPattern(self):
740
- self.assertEqual(
741
- parseNumberPattern('###0.00#'),
742
- ((None, '', None, '###0', '00#', '', None, '', None, ()),
743
- (None, '', None, '###0', '00#', '', None, '', None, ())))
669
+ self.assertEqual(parseNumberPattern('###0.00#'),
670
+ ((None, '', None, '###0', '00#', '', None, '', None,
671
+ ()),
672
+ (None, '', None, '###0', '00#', '', None, '', None,
673
+ ())))
744
674
 
745
675
  def testParseScientificDecimalPattern(self):
746
- self.assertEqual(
747
- parseNumberPattern('###0.00#E#0'),
748
- ((None, '', None, '###0', '00#', '#0', None, '', None, ()),
749
- (None, '', None, '###0', '00#', '#0', None, '', None, ())))
676
+ self.assertEqual(parseNumberPattern('###0.00#E#0'),
677
+ ((None, '', None, '###0', '00#', '#0', None, '', None,
678
+ ()),
679
+ (None, '', None, '###0', '00#', '#0', None, '', None,
680
+ ())))
750
681
 
751
682
  def testParsePosNegAlternativeFractionPattern(self):
752
- self.assertEqual(
753
- parseNumberPattern('###0.00#;#0.0#'),
754
- ((None, '', None, '###0', '00#', '', None, '', None, ()),
755
- (None, '', None, '#0', '0#', '', None, '', None, ())))
683
+ self.assertEqual(parseNumberPattern('###0.00#;#0.0#'),
684
+ ((None, '', None, '###0', '00#', '', None, '', None,
685
+ ()),
686
+ (None, '', None, '#0', '0#', '', None, '', None,
687
+ ())))
756
688
 
757
689
  def testParsePosNegFractionPattern(self):
758
- self.assertEqual(
759
- parseNumberPattern('+###0.0##;-###0.0##'),
760
- ((None, '+', None, '###0', '0##', '', None, '', None, ()),
761
- (None, '-', None, '###0', '0##', '', None, '', None, ())))
690
+ self.assertEqual(parseNumberPattern('+###0.0##;-###0.0##'),
691
+ ((None, '+', None, '###0', '0##', '', None, '', None,
692
+ ()),
693
+ (None, '-', None, '###0', '0##', '', None, '', None,
694
+ ())))
762
695
 
763
696
  def testParseScientificPosNegFractionPattern(self):
764
697
  self.assertEqual(
@@ -767,17 +700,19 @@ class TestNumberPatternParser(TestCase):
767
700
  (None, '-', None, '###0', '0##', '0', None, '', None, ())))
768
701
 
769
702
  def testParseThousandSeparatorFractionPattern(self):
770
- self.assertEqual(
771
- parseNumberPattern('#,##0.0#'),
772
- ((None, '', None, '###0', '0#', '', None, '', None, (3, 0)),
773
- (None, '', None, '###0', '0#', '', None, '', None, (3, 0))))
703
+ self.assertEqual(parseNumberPattern('#,##0.0#'),
704
+ ((None, '', None, '###0', '0#', '', None, '', None,
705
+ (3, 0)),
706
+ (None, '', None, '###0', '0#', '', None, '', None,
707
+ (3, 0))))
774
708
 
775
709
  def testParseThousandSeparatorPatterns(self):
776
710
  # the following patterns are present in the ICU XMLs:
777
- self.assertEqual(
778
- parseNumberPattern('#,##0.00;-#,##0.00'),
779
- ((None, '', None, '###0', '00', '', None, '', None, (3, 0)),
780
- (None, '-', None, '###0', '00', '', None, '', None, (3, 0))))
711
+ self.assertEqual(parseNumberPattern('#,##0.00;-#,##0.00'),
712
+ ((None, '', None, '###0', '00', '', None, '', None,
713
+ (3, 0)),
714
+ (None, '-', None, '###0', '00', '', None, '', None,
715
+ (3, 0))))
781
716
 
782
717
  self.assertEqual(
783
718
  parseNumberPattern('#,##,##0.###;-#,##,##0.###'),
@@ -785,25 +720,29 @@ class TestNumberPatternParser(TestCase):
785
720
  (None, '-', None, '#####0', '###', '', None, '', None,
786
721
  (3, 2, 0))))
787
722
 
788
- self.assertEqual(
789
- parseNumberPattern('#,##0.##;-#,##0.##'),
790
- ((None, '', None, '###0', '##', '', None, '', None, (3, 0)),
791
- (None, '-', None, '###0', '##', '', None, '', None, (3, 0))))
723
+ self.assertEqual(parseNumberPattern('#,##0.##;-#,##0.##'),
724
+ ((None, '', None, '###0', '##', '', None, '', None,
725
+ (3, 0)),
726
+ (None, '-', None, '###0', '##', '', None, '', None,
727
+ (3, 0))))
792
728
 
793
- self.assertEqual(
794
- parseNumberPattern('#,##0.###;-#,##0.###'),
795
- ((None, '', None, '###0', '###', '', None, '', None, (3, 0)),
796
- (None, '-', None, '###0', '###', '', None, '', None, (3, 0))))
729
+ self.assertEqual(parseNumberPattern('#,##0.###;-#,##0.###'),
730
+ ((None, '', None, '###0', '###', '', None, '', None,
731
+ (3, 0)),
732
+ (None, '-', None, '###0', '###', '', None, '', None,
733
+ (3, 0))))
797
734
 
798
- self.assertEqual(
799
- parseNumberPattern('#,##0.###;(#,##0.###)'),
800
- ((None, '', None, '###0', '###', '', None, '', None, (3, 0)),
801
- (None, '(', None, '###0', '###', '', None, ')', None, (3, 0))))
735
+ self.assertEqual(parseNumberPattern('#,##0.###;(#,##0.###)'),
736
+ ((None, '', None, '###0', '###', '', None, '', None,
737
+ (3, 0)),
738
+ (None, '(', None, '###0', '###', '', None, ')', None,
739
+ (3, 0))))
802
740
 
803
- self.assertEqual(
804
- parseNumberPattern('#,##0.###;#,##0.###-'),
805
- ((None, '', None, '###0', '###', '', None, '', None, (3, 0)),
806
- (None, '', None, '###0', '###', '', None, '-', None, (3, 0))))
741
+ self.assertEqual(parseNumberPattern('#,##0.###;#,##0.###-'),
742
+ ((None, '', None, '###0', '###', '', None, '', None,
743
+ (3, 0)),
744
+ (None, '', None, '###0', '###', '', None, '-', None,
745
+ (3, 0))))
807
746
 
808
747
  self.assertEqual(
809
748
  parseNumberPattern('##,##,##0.###;-##,##,##0.###'),
@@ -811,50 +750,59 @@ class TestNumberPatternParser(TestCase):
811
750
  (None, '-', None, '######0', '###', '', None, '', None,
812
751
  (3, 2, 0))))
813
752
 
814
- self.assertEqual(
815
- parseNumberPattern('##,##0.##;-##,##0.##'),
816
- ((None, '', None, '####0', '##', '', None, '', None, (3, 0)),
817
- (None, '-', None, '####0', '##', '', None, '', None, (3, 0))))
818
-
819
- self.assertEqual(
820
- parseNumberPattern('###0.###;-###0.###'),
821
- ((None, '', None, '###0', '###', '', None, '', None, ()),
822
- (None, '-', None, '###0', '###', '', None, '', None, ())))
823
-
824
- self.assertEqual(
825
- parseNumberPattern('###0.###;###0.###-'),
826
- ((None, '', None, '###0', '###', '', None, '', None, ()),
827
- (None, '', None, '###0', '###', '', None, '-', None, ())))
828
-
829
- self.assertEqual(
830
- parseNumberPattern('#0.###;-#0.###'),
831
- ((None, '', None, '#0', '###', '', None, '', None, ()),
832
- (None, '-', None, '#0', '###', '', None, '', None, ())))
833
-
834
- self.assertEqual(
835
- parseNumberPattern('#,##0.###;#,##0.###'),
836
- ((None, '', None, '###0', '###', '', None, '', None, (3, 0)),
837
- (None, '', None, '###0', '###', '', None, '', None, (3, 0))))
838
-
839
- self.assertEqual(
840
- parseNumberPattern('###0.###;-###0.###'),
841
- ((None, '', None, '###0', '###', '', None, '', None, ()),
842
- (None, '-', None, '###0', '###', '', None, '', None, ())))
843
-
844
- self.assertEqual(
845
- parseNumberPattern('#,##0.00;-#,##0.00'),
846
- ((None, '', None, '###0', '00', '', None, '', None, (3, 0)),
847
- (None, '-', None, '###0', '00', '', None, '', None, (3, 0))))
848
-
849
- self.assertEqual(
850
- parseNumberPattern('#,##0.00;(#,##0.00)'),
851
- ((None, '', None, '###0', '00', '', None, '', None, (3, 0)),
852
- (None, '(', None, '###0', '00', '', None, ')', None, (3, 0))))
853
-
854
- self.assertEqual(
855
- parseNumberPattern('#,##0.00;-#,##0.00'),
856
- ((None, '', None, '###0', '00', '', None, '', None, (3, 0)),
857
- (None, '-', None, '###0', '00', '', None, '', None, (3, 0))))
753
+ self.assertEqual(parseNumberPattern('##,##0.##;-##,##0.##'),
754
+ ((None, '', None, '####0', '##', '', None, '', None,
755
+ (3, 0)),
756
+ (None, '-', None, '####0', '##', '', None, '', None,
757
+ (3, 0))))
758
+
759
+ self.assertEqual(parseNumberPattern('###0.###;-###0.###'),
760
+ ((None, '', None, '###0', '###', '', None, '', None,
761
+ ()),
762
+ (None, '-', None, '###0', '###', '', None, '', None,
763
+ ())))
764
+
765
+ self.assertEqual(parseNumberPattern('###0.###;###0.###-'),
766
+ ((None, '', None, '###0', '###', '', None, '', None,
767
+ ()),
768
+ (None, '', None, '###0', '###', '', None, '-', None,
769
+ ())))
770
+
771
+ self.assertEqual(parseNumberPattern('#0.###;-#0.###'),
772
+ ((None, '', None, '#0', '###', '', None, '', None,
773
+ ()),
774
+ (None, '-', None, '#0', '###', '', None, '', None,
775
+ ())))
776
+
777
+ self.assertEqual(parseNumberPattern('#,##0.###;#,##0.###'),
778
+ ((None, '', None, '###0', '###', '', None, '', None,
779
+ (3, 0)),
780
+ (None, '', None, '###0', '###', '', None, '', None,
781
+ (3, 0))))
782
+
783
+ self.assertEqual(parseNumberPattern('###0.###;-###0.###'),
784
+ ((None, '', None, '###0', '###', '', None, '', None,
785
+ ()),
786
+ (None, '-', None, '###0', '###', '', None, '', None,
787
+ ())))
788
+
789
+ self.assertEqual(parseNumberPattern('#,##0.00;-#,##0.00'),
790
+ ((None, '', None, '###0', '00', '', None, '', None,
791
+ (3, 0)),
792
+ (None, '-', None, '###0', '00', '', None, '', None,
793
+ (3, 0))))
794
+
795
+ self.assertEqual(parseNumberPattern('#,##0.00;(#,##0.00)'),
796
+ ((None, '', None, '###0', '00', '', None, '', None,
797
+ (3, 0)),
798
+ (None, '(', None, '###0', '00', '', None, ')', None,
799
+ (3, 0))))
800
+
801
+ self.assertEqual(parseNumberPattern('#,##0.00;-#,##0.00'),
802
+ ((None, '', None, '###0', '00', '', None, '', None,
803
+ (3, 0)),
804
+ (None, '-', None, '###0', '00', '', None, '', None,
805
+ (3, 0))))
858
806
 
859
807
  self.assertEqual(
860
808
  parseNumberPattern('##,##,##0.00;-##,##,##0.00'),
@@ -862,152 +810,171 @@ class TestNumberPatternParser(TestCase):
862
810
  (None, '-', None, '######0', '00', '', None, '', None,
863
811
  (3, 2, 0))))
864
812
 
865
- self.assertEqual(
866
- parseNumberPattern('###0.00;-###0.00'),
867
- ((None, '', None, '###0', '00', '', None, '', None, ()),
868
- (None, '-', None, '###0', '00', '', None, '', None, ())))
813
+ self.assertEqual(parseNumberPattern('###0.00;-###0.00'),
814
+ ((None, '', None, '###0', '00', '', None, '', None,
815
+ ()),
816
+ (None, '-', None, '###0', '00', '', None, '', None,
817
+ ())))
869
818
 
870
- self.assertEqual(
871
- parseNumberPattern('#,##0;-#,##0'),
872
- ((None, '', None, '###0', '', '', None, '', None, (3, 0)),
873
- (None, '-', None, '###0', '', '', None, '', None, (3, 0))))
819
+ self.assertEqual(parseNumberPattern('#,##0;-#,##0'),
820
+ ((None, '', None, '###0', '', '', None, '', None,
821
+ (3, 0)),
822
+ (None, '-', None, '###0', '', '', None, '', None,
823
+ (3, 0))))
874
824
 
875
- self.assertEqual(
876
- parseNumberPattern('###0.00;-###0.00'),
877
- ((None, '', None, '###0', '00', '', None, '', None, ()),
878
- (None, '-', None, '###0', '00', '', None, '', None, ())))
825
+ self.assertEqual(parseNumberPattern('###0.00;-###0.00'),
826
+ ((None, '', None, '###0', '00', '', None, '', None,
827
+ ()),
828
+ (None, '-', None, '###0', '00', '', None, '', None,
829
+ ())))
879
830
 
880
831
  def testParsePadding1WithoutPrefixPattern(self):
881
- self.assertEqual(
882
- parseNumberPattern('* ###0'),
883
- ((' ', '', None, '###0', '', '', None, '', None, ()),
884
- (' ', '', None, '###0', '', '', None, '', None, ())))
885
- self.assertEqual(
886
- parseNumberPattern('* ###0.0##'),
887
- ((' ', '', None, '###0', '0##', '', None, '', None, ()),
888
- (' ', '', None, '###0', '0##', '', None, '', None, ())))
889
- self.assertEqual(
890
- parseNumberPattern('* ###0.0##;*_###0.0##'),
891
- ((' ', '', None, '###0', '0##', '', None, '', None, ()),
892
- ('_', '', None, '###0', '0##', '', None, '', None, ())))
832
+ self.assertEqual(parseNumberPattern('* ###0'),
833
+ ((' ', '', None, '###0', '', '', None, '', None, ()),
834
+ (' ', '', None, '###0', '', '', None, '', None, ())))
835
+ self.assertEqual(parseNumberPattern('* ###0.0##'),
836
+ ((' ', '', None, '###0', '0##', '', None, '', None,
837
+ ()),
838
+ (' ', '', None, '###0', '0##', '', None, '', None,
839
+ ())))
840
+ self.assertEqual(parseNumberPattern('* ###0.0##;*_###0.0##'),
841
+ ((' ', '', None, '###0', '0##', '', None, '', None,
842
+ ()),
843
+ ('_', '', None, '###0', '0##', '', None, '', None,
844
+ ())))
893
845
 
894
846
  def testParsePadding1WithPrefixPattern(self):
895
- self.assertEqual(
896
- parseNumberPattern('* +###0'),
897
- ((' ', '+', None, '###0', '', '', None, '', None, ()),
898
- (' ', '+', None, '###0', '', '', None, '', None, ())))
899
- self.assertEqual(
900
- parseNumberPattern('* +###0.0##'),
901
- ((' ', '+', None, '###0', '0##', '', None, '', None, ()),
902
- (' ', '+', None, '###0', '0##', '', None, '', None, ())))
903
- self.assertEqual(
904
- parseNumberPattern('* +###0.0##;*_-###0.0##'),
905
- ((' ', '+', None, '###0', '0##', '', None, '', None, ()),
906
- ('_', '-', None, '###0', '0##', '', None, '', None, ())))
847
+ self.assertEqual(parseNumberPattern('* +###0'),
848
+ ((' ', '+', None, '###0', '', '', None, '', None, ()),
849
+ (' ', '+', None, '###0', '', '', None, '', None,
850
+ ())))
851
+ self.assertEqual(parseNumberPattern('* +###0.0##'),
852
+ ((' ', '+', None, '###0', '0##', '', None, '', None,
853
+ ()),
854
+ (' ', '+', None, '###0', '0##', '', None, '', None,
855
+ ())))
856
+ self.assertEqual(parseNumberPattern('* +###0.0##;*_-###0.0##'),
857
+ ((' ', '+', None, '###0', '0##', '', None, '', None,
858
+ ()),
859
+ ('_', '-', None, '###0', '0##', '', None, '', None,
860
+ ())))
907
861
 
908
862
  def testParsePadding1Padding2WithPrefixPattern(self):
909
- self.assertEqual(
910
- parseNumberPattern('* +* ###0'),
911
- ((' ', '+', ' ', '###0', '', '', None, '', None, ()),
912
- (' ', '+', ' ', '###0', '', '', None, '', None, ())))
913
- self.assertEqual(
914
- parseNumberPattern('* +* ###0.0##'),
915
- ((' ', '+', ' ', '###0', '0##', '', None, '', None, ()),
916
- (' ', '+', ' ', '###0', '0##', '', None, '', None, ())))
917
- self.assertEqual(
918
- parseNumberPattern('* +* ###0.0##;*_-*_###0.0##'),
919
- ((' ', '+', ' ', '###0', '0##', '', None, '', None, ()),
920
- ('_', '-', '_', '###0', '0##', '', None, '', None, ())))
863
+ self.assertEqual(parseNumberPattern('* +* ###0'),
864
+ ((' ', '+', ' ', '###0', '', '', None, '', None, ()),
865
+ (' ', '+', ' ', '###0', '', '', None, '', None, ())))
866
+ self.assertEqual(parseNumberPattern('* +* ###0.0##'),
867
+ ((' ', '+', ' ', '###0', '0##', '', None, '', None,
868
+ ()),
869
+ (' ', '+', ' ', '###0', '0##', '', None, '', None,
870
+ ())))
871
+ self.assertEqual(parseNumberPattern('* +* ###0.0##;*_-*_###0.0##'),
872
+ ((' ', '+', ' ', '###0', '0##', '', None, '', None,
873
+ ()),
874
+ ('_', '-', '_', '###0', '0##', '', None, '', None,
875
+ ())))
921
876
 
922
877
  def testParsePadding3WithoutSuffixPattern(self):
923
- self.assertEqual(
924
- parseNumberPattern('###0* '),
925
- ((None, '', None, '###0', '', '', ' ', '', None, ()),
926
- (None, '', None, '###0', '', '', ' ', '', None, ())))
927
- self.assertEqual(
928
- parseNumberPattern('###0.0##* '),
929
- ((None, '', None, '###0', '0##', '', ' ', '', None, ()),
930
- (None, '', None, '###0', '0##', '', ' ', '', None, ())))
931
- self.assertEqual(
932
- parseNumberPattern('###0.0##* ;###0.0##*_'),
933
- ((None, '', None, '###0', '0##', '', ' ', '', None, ()),
934
- (None, '', None, '###0', '0##', '', '_', '', None, ())))
878
+ self.assertEqual(parseNumberPattern('###0* '),
879
+ ((None, '', None, '###0', '', '', ' ', '', None, ()),
880
+ (None, '', None, '###0', '', '', ' ', '', None, ())))
881
+ self.assertEqual(parseNumberPattern('###0.0##* '),
882
+ ((None, '', None, '###0', '0##', '', ' ', '', None,
883
+ ()),
884
+ (None, '', None, '###0', '0##', '', ' ', '', None,
885
+ ())))
886
+ self.assertEqual(parseNumberPattern('###0.0##* ;###0.0##*_'),
887
+ ((None, '', None, '###0', '0##', '', ' ', '', None,
888
+ ()),
889
+ (None, '', None, '###0', '0##', '', '_', '', None,
890
+ ())))
935
891
 
936
892
  def testParsePadding3InScientificPattern(self):
937
- self.assertEqual(
938
- parseNumberPattern('###0E#0* '),
939
- ((None, '', None, '###0', '', '#0', ' ', '', None, ()),
940
- (None, '', None, '###0', '', '#0', ' ', '', None, ())))
941
- self.assertEqual(
942
- parseNumberPattern('###0.0##E0* '),
943
- ((None, '', None, '###0', '0##', '0', ' ', '', None, ()),
944
- (None, '', None, '###0', '0##', '0', ' ', '', None, ())))
945
- self.assertEqual(
946
- parseNumberPattern('###0.0##E#0* ;###0.0##E0*_'),
947
- ((None, '', None, '###0', '0##', '#0', ' ', '', None, ()),
948
- (None, '', None, '###0', '0##', '0', '_', '', None, ())))
893
+ self.assertEqual(parseNumberPattern('###0E#0* '),
894
+ ((None, '', None, '###0', '', '#0', ' ', '', None,
895
+ ()),
896
+ (None, '', None, '###0', '', '#0', ' ', '', None,
897
+ ())))
898
+ self.assertEqual(parseNumberPattern('###0.0##E0* '),
899
+ ((None, '', None, '###0', '0##', '0', ' ', '', None,
900
+ ()),
901
+ (None, '', None, '###0', '0##', '0', ' ', '', None,
902
+ ())))
903
+ self.assertEqual(parseNumberPattern('###0.0##E#0* ;###0.0##E0*_'),
904
+ ((None, '', None, '###0', '0##', '#0', ' ', '', None,
905
+ ()),
906
+ (None, '', None, '###0', '0##', '0', '_', '', None,
907
+ ())))
949
908
 
950
909
  def testParsePadding3WithSufffixPattern(self):
951
- self.assertEqual(
952
- parseNumberPattern('###0* /'),
953
- ((None, '', None, '###0', '', '', ' ', '/', None, ()),
954
- (None, '', None, '###0', '', '', ' ', '/', None, ())))
955
- self.assertEqual(
956
- parseNumberPattern('###0.0#* /'),
957
- ((None, '', None, '###0', '0#', '', ' ', '/', None, ()),
958
- (None, '', None, '###0', '0#', '', ' ', '/', None, ())))
959
- self.assertEqual(
960
- parseNumberPattern('###0.0#* /;###0.0#*_/'),
961
- ((None, '', None, '###0', '0#', '', ' ', '/', None, ()),
962
- (None, '', None, '###0', '0#', '', '_', '/', None, ())))
910
+ self.assertEqual(parseNumberPattern('###0* /'),
911
+ ((None, '', None, '###0', '', '', ' ', '/', None, ()),
912
+ (None, '', None, '###0', '', '', ' ', '/', None,
913
+ ())))
914
+ self.assertEqual(parseNumberPattern('###0.0#* /'),
915
+ ((None, '', None, '###0', '0#', '', ' ', '/', None,
916
+ ()),
917
+ (None, '', None, '###0', '0#', '', ' ', '/', None,
918
+ ())))
919
+ self.assertEqual(parseNumberPattern('###0.0#* /;###0.0#*_/'),
920
+ ((None, '', None, '###0', '0#', '', ' ', '/', None,
921
+ ()),
922
+ (None, '', None, '###0', '0#', '', '_', '/', None,
923
+ ())))
963
924
 
964
925
  def testParsePadding3And4WithSuffixPattern(self):
965
- self.assertEqual(
966
- parseNumberPattern('###0* /* '),
967
- ((None, '', None, '###0', '', '', ' ', '/', ' ', ()),
968
- (None, '', None, '###0', '', '', ' ', '/', ' ', ())))
969
- self.assertEqual(
970
- parseNumberPattern('###0* /* ;###0*_/*_'),
971
- ((None, '', None, '###0', '', '', ' ', '/', ' ', ()),
972
- (None, '', None, '###0', '', '', '_', '/', '_', ())))
926
+ self.assertEqual(parseNumberPattern('###0* /* '),
927
+ ((None, '', None, '###0', '', '', ' ', '/', ' ', ()),
928
+ (None, '', None, '###0', '', '', ' ', '/', ' ', ())))
929
+ self.assertEqual(parseNumberPattern('###0* /* ;###0*_/*_'),
930
+ ((None, '', None, '###0', '', '', ' ', '/', ' ', ()),
931
+ (None, '', None, '###0', '', '', '_', '/', '_', ())))
973
932
 
974
933
  def testParseMultipleCharacterPrefix(self):
975
- self.assertEqual(
976
- parseNumberPattern('DM###0'),
977
- ((None, 'DM', None, '###0', '', '', None, '', None, ()),
978
- (None, 'DM', None, '###0', '', '', None, '', None, ())))
979
- self.assertEqual(
980
- parseNumberPattern('DM* ###0'),
981
- ((None, 'DM', ' ', '###0', '', '', None, '', None, ()),
982
- (None, 'DM', ' ', '###0', '', '', None, '', None, ())))
934
+ self.assertEqual(parseNumberPattern('DM###0'),
935
+ ((None, 'DM', None, '###0', '', '', None, '', None,
936
+ ()),
937
+ (None, 'DM', None, '###0', '', '', None, '', None,
938
+ ())))
939
+ self.assertEqual(parseNumberPattern('DM* ###0'),
940
+ ((None, 'DM', ' ', '###0', '', '', None, '', None,
941
+ ()),
942
+ (None, 'DM', ' ', '###0', '', '', None, '', None,
943
+ ())))
983
944
 
984
945
  def testParseStringEscapedPrefix(self):
985
- self.assertEqual(
986
- parseNumberPattern("'DEM'###0"),
987
- ((None, 'DEM', None, '###0', '', '', None, '', None, ()),
988
- (None, 'DEM', None, '###0', '', '', None, '', None, ())))
989
- self.assertEqual(
990
- parseNumberPattern("D'EM'###0"),
991
- ((None, 'DEM', None, '###0', '', '', None, '', None, ()),
992
- (None, 'DEM', None, '###0', '', '', None, '', None, ())))
993
- self.assertEqual(
994
- parseNumberPattern("D'E'M###0"),
995
- ((None, 'DEM', None, '###0', '', '', None, '', None, ()),
996
- (None, 'DEM', None, '###0', '', '', None, '', None, ())))
946
+ self.assertEqual(parseNumberPattern("'DEM'###0"),
947
+ ((None, 'DEM', None, '###0', '', '', None, '', None,
948
+ ()),
949
+ (None, 'DEM', None, '###0', '', '', None, '', None,
950
+ ())))
951
+ self.assertEqual(parseNumberPattern("D'EM'###0"),
952
+ ((None, 'DEM', None, '###0', '', '', None, '', None,
953
+ ()),
954
+ (None, 'DEM', None, '###0', '', '', None, '', None,
955
+ ())))
956
+ self.assertEqual(parseNumberPattern("D'E'M###0"),
957
+ ((None, 'DEM', None, '###0', '', '', None, '', None,
958
+ ()),
959
+ (None, 'DEM', None, '###0', '', '', None, '', None,
960
+ ())))
997
961
 
998
962
  def testParseStringEscapedSuffix(self):
999
- self.assertEqual(
1000
- parseNumberPattern("###0'DEM'"),
1001
- ((None, '', None, '###0', '', '', None, 'DEM', None, ()),
1002
- (None, '', None, '###0', '', '', None, 'DEM', None, ())))
1003
- self.assertEqual(
1004
- parseNumberPattern("###0D'EM'"),
1005
- ((None, '', None, '###0', '', '', None, 'DEM', None, ()),
1006
- (None, '', None, '###0', '', '', None, 'DEM', None, ())))
1007
- self.assertEqual(
1008
- parseNumberPattern("###0D'E'M"),
1009
- ((None, '', None, '###0', '', '', None, 'DEM', None, ()),
1010
- (None, '', None, '###0', '', '', None, 'DEM', None, ())))
963
+ self.assertEqual(parseNumberPattern("###0'DEM'"),
964
+ ((None, '', None, '###0', '', '', None, 'DEM', None,
965
+ ()),
966
+ (None, '', None, '###0', '', '', None, 'DEM', None,
967
+ ())))
968
+ self.assertEqual(parseNumberPattern("###0D'EM'"),
969
+ ((None, '', None, '###0', '', '', None, 'DEM', None,
970
+ ()),
971
+ (None, '', None, '###0', '', '', None, 'DEM', None,
972
+ ())))
973
+ self.assertEqual(parseNumberPattern("###0D'E'M"),
974
+ ((None, '', None, '###0', '', '', None, 'DEM', None,
975
+ ()),
976
+ (None, '', None, '###0', '', '', None, 'DEM', None,
977
+ ())))
1011
978
 
1012
979
  def testParseInvalidBegin(self):
1013
980
  with self.assertRaisesRegex(NumberPatternParseError,
@@ -1016,141 +983,113 @@ class TestNumberPatternParser(TestCase):
1016
983
 
1017
984
  def testParseFractionQuote(self):
1018
985
  pattern, neg_pattern = parseNumberPattern("0.'")
1019
- self.assertEqual(
1020
- (None, '', None, '0', '', '', None, '', None, ()),
1021
- pattern)
1022
- self.assertEqual(
1023
- (None, '', None, '0', '', '', None, '', None, ()),
1024
- neg_pattern)
986
+ self.assertEqual((None, '', None, '0', '', '', None, '', None, ()),
987
+ pattern)
988
+ self.assertEqual((None, '', None, '0', '', '', None, '', None, ()),
989
+ neg_pattern)
1025
990
 
1026
991
  def testParseExponentialQuote(self):
1027
992
  pattern, neg_pattern = parseNumberPattern("0E'")
1028
- self.assertEqual(
1029
- (None, '', None, '0', '', '', None, '', None, ()),
1030
- pattern)
1031
- self.assertEqual(
1032
- (None, '', None, '0', '', '', None, '', None, ()),
1033
- neg_pattern)
993
+ self.assertEqual((None, '', None, '0', '', '', None, '', None, ()),
994
+ pattern)
995
+ self.assertEqual((None, '', None, '0', '', '', None, '', None, ()),
996
+ neg_pattern)
1034
997
 
1035
998
  def testParseExponentialNumber(self):
1036
999
  pattern, neg_pattern = parseNumberPattern("0E1")
1037
- self.assertEqual(
1038
- (None, '', None, '0', '', '', None, '1', None, ()),
1039
- pattern)
1040
- self.assertEqual(
1041
- (None, '', None, '0', '', '', None, '1', None, ()),
1042
- neg_pattern)
1000
+ self.assertEqual((None, '', None, '0', '', '', None, '1', None, ()),
1001
+ pattern)
1002
+ self.assertEqual((None, '', None, '0', '', '', None, '1', None, ()),
1003
+ neg_pattern)
1043
1004
 
1044
1005
 
1045
1006
  class TestNumberFormat(TestCase):
1046
1007
  """Test the functionality of an implmentation of the NumberFormat."""
1047
1008
 
1048
- format = NumberFormat(symbols={
1049
- 'decimal': '.', 'group': ',', 'list': ';', 'percentSign': '%',
1050
- 'nativeZeroDigit': '0', 'patternDigit': '#', 'plusSign': '+',
1051
- 'minusSign': '-', 'exponential': 'E', 'perMille': 'o/oo',
1052
- 'infinity': 'oo', 'nan': 'N/A'})
1009
+ format = NumberFormat(
1010
+ symbols={
1011
+ 'decimal': '.',
1012
+ 'group': ',',
1013
+ 'list': ';',
1014
+ 'percentSign': '%',
1015
+ 'nativeZeroDigit': '0',
1016
+ 'patternDigit': '#',
1017
+ 'plusSign': '+',
1018
+ 'minusSign': '-',
1019
+ 'exponential': 'E',
1020
+ 'perMille': 'o/oo',
1021
+ 'infinity': 'oo',
1022
+ 'nan': 'N/A'
1023
+ })
1053
1024
 
1054
1025
  def testInterfaceConformity(self):
1055
1026
  self.assertTrue(INumberFormat.providedBy(self.format))
1056
1027
 
1057
1028
  def testParseSimpleInteger(self):
1058
- self.assertEqual(self.format.parse('23341', '###0'),
1059
- 23341)
1060
- self.assertEqual(self.format.parse('041', '#000'),
1061
- 41)
1029
+ self.assertEqual(self.format.parse('23341', '###0'), 23341)
1030
+ self.assertEqual(self.format.parse('041', '#000'), 41)
1062
1031
 
1063
1032
  def testParseScientificInteger(self):
1064
- self.assertEqual(self.format.parse('2.3341E4', '0.0###E0'),
1065
- 23341)
1066
- self.assertEqual(self.format.parse('4.100E01', '0.000##E00'),
1067
- 41)
1068
- self.assertEqual(self.format.parse('1E0', '0E0'),
1069
- 1)
1070
- self.assertEqual(self.format.parse('0E0', '0E0'),
1071
- 0)
1033
+ self.assertEqual(self.format.parse('2.3341E4', '0.0###E0'), 23341)
1034
+ self.assertEqual(self.format.parse('4.100E01', '0.000##E00'), 41)
1035
+ self.assertEqual(self.format.parse('1E0', '0E0'), 1)
1036
+ self.assertEqual(self.format.parse('0E0', '0E0'), 0)
1072
1037
  # This is a special case I found not working, but is used frequently
1073
1038
  # in the new LDML Locale files.
1074
1039
  self.assertEqual(self.format.parse('2.3341E+04', '0.000###E+00'),
1075
1040
  23341)
1076
1041
 
1077
1042
  def testParsePosNegAlternativeInteger(self):
1078
- self.assertEqual(self.format.parse('23341', '#000;#00'),
1079
- 23341)
1080
- self.assertEqual(self.format.parse('041', '#000;#00'),
1081
- 41)
1082
- self.assertEqual(self.format.parse('41', '#000;#00'),
1083
- -41)
1084
- self.assertEqual(self.format.parse('01', '#000;#00'),
1085
- -1)
1043
+ self.assertEqual(self.format.parse('23341', '#000;#00'), 23341)
1044
+ self.assertEqual(self.format.parse('041', '#000;#00'), 41)
1045
+ self.assertEqual(self.format.parse('41', '#000;#00'), -41)
1046
+ self.assertEqual(self.format.parse('01', '#000;#00'), -1)
1086
1047
 
1087
1048
  def testParsePrefixedInteger(self):
1088
- self.assertEqual(self.format.parse('+23341', '+###0'),
1089
- 23341)
1090
- self.assertEqual(self.format.parse('+041', '+#000'),
1091
- 41)
1049
+ self.assertEqual(self.format.parse('+23341', '+###0'), 23341)
1050
+ self.assertEqual(self.format.parse('+041', '+#000'), 41)
1092
1051
 
1093
1052
  def testParsePosNegInteger(self):
1094
- self.assertEqual(self.format.parse('+23341', '+###0;-###0'),
1095
- 23341)
1096
- self.assertEqual(self.format.parse('+041', '+#000;-#000'),
1097
- 41)
1098
- self.assertEqual(self.format.parse('-23341', '+###0;-###0'),
1099
- -23341)
1100
- self.assertEqual(self.format.parse('-041', '+#000;-#000'),
1101
- -41)
1053
+ self.assertEqual(self.format.parse('+23341', '+###0;-###0'), 23341)
1054
+ self.assertEqual(self.format.parse('+041', '+#000;-#000'), 41)
1055
+ self.assertEqual(self.format.parse('-23341', '+###0;-###0'), -23341)
1056
+ self.assertEqual(self.format.parse('-041', '+#000;-#000'), -41)
1102
1057
 
1103
1058
  def testParseThousandSeparatorInteger(self):
1104
- self.assertEqual(self.format.parse('+23,341', '+#,##0;-#,##0'),
1105
- 23341)
1106
- self.assertEqual(self.format.parse('-23,341', '+#,##0;-#,##0'),
1107
- -23341)
1108
- self.assertEqual(self.format.parse('+0,041', '+#0,000;-#0,000'),
1109
- 41)
1110
- self.assertEqual(self.format.parse('-0,041', '+#0,000;-#0,000'),
1111
- -41)
1059
+ self.assertEqual(self.format.parse('+23,341', '+#,##0;-#,##0'), 23341)
1060
+ self.assertEqual(self.format.parse('-23,341', '+#,##0;-#,##0'), -23341)
1061
+ self.assertEqual(self.format.parse('+0,041', '+#0,000;-#0,000'), 41)
1062
+ self.assertEqual(self.format.parse('-0,041', '+#0,000;-#0,000'), -41)
1112
1063
 
1113
1064
  def testParseDecimal(self):
1114
- self.assertEqual(self.format.parse('23341.02', '###0.0#'),
1115
- 23341.02)
1116
- self.assertEqual(self.format.parse('23341.1', '###0.0#'),
1117
- 23341.1)
1118
- self.assertEqual(self.format.parse('23341.020', '###0.000#'),
1119
- 23341.02)
1065
+ self.assertEqual(self.format.parse('43341.02', '###0.0#'), 43341.02)
1066
+ self.assertEqual(self.format.parse('43341.1', '###0.0#'), 43341.1)
1067
+ self.assertEqual(self.format.parse('43341.020', '###0.000#'), 43341.02)
1120
1068
 
1121
1069
  def testParseDecimalWithOptionalDecimalDigits(self):
1122
- self.assertEqual(self.format.parse('23341.02', '###0.##'),
1123
- 23341.02)
1124
- self.assertEqual(self.format.parse('23341', '###0.#'),
1125
- 23341.0)
1126
- self.assertEqual(self.format.parse('23341.', '###0.#'),
1127
- 23341.0)
1070
+ self.assertEqual(self.format.parse('43341.02', '###0.##'), 43341.02)
1071
+ self.assertEqual(self.format.parse('43341', '###0.#'), 43341.0)
1072
+ self.assertEqual(self.format.parse('43341.', '###0.#'), 43341.0)
1128
1073
 
1129
1074
  def testParseScientificDecimal(self):
1130
- self.assertEqual(self.format.parse('2.334102E04', '0.00####E00'),
1131
- 23341.02)
1132
- self.assertEqual(self.format.parse('2.3341020E004', '0.0000000E000'),
1133
- 23341.02)
1134
- self.assertEqual(self.format.parse('0.0E0', '0.0#E0'),
1135
- 0.0)
1075
+ self.assertEqual(self.format.parse('4.334102E04', '0.00####E00'),
1076
+ 43341.02)
1077
+ self.assertEqual(self.format.parse('4.3341020E004', '0.0000000E000'),
1078
+ 43341.02)
1079
+ self.assertEqual(self.format.parse('0.0E0', '0.0#E0'), 0.0)
1136
1080
 
1137
1081
  def testParseScientificDecimalSmallerOne(self):
1138
- self.assertEqual(self.format.parse('2.357E-02', '0.00####E00'),
1139
- 0.02357)
1140
- self.assertEqual(self.format.parse('2.0000E-02', '0.0000E00'),
1141
- 0.02)
1082
+ self.assertEqual(self.format.parse('4.357E-02', '0.00####E00'),
1083
+ 0.04357)
1084
+ self.assertEqual(self.format.parse('4.0000E-02', '0.0000E00'), 0.04)
1142
1085
 
1143
1086
  def testParsePadding1WithoutPrefix(self):
1144
- self.assertEqual(self.format.parse(' 41', '* ##0;*_##0'),
1145
- 41)
1146
- self.assertEqual(self.format.parse('_41', '* ##0;*_##0'),
1147
- -41)
1087
+ self.assertEqual(self.format.parse(' 41', '* ##0;*_##0'), 41)
1088
+ self.assertEqual(self.format.parse('_41', '* ##0;*_##0'), -41)
1148
1089
 
1149
1090
  def testParsePadding1WithPrefix(self):
1150
- self.assertEqual(self.format.parse(' +41', '* +##0;*_-##0'),
1151
- 41)
1152
- self.assertEqual(self.format.parse('_-41', '* +##0;*_-##0'),
1153
- -41)
1091
+ self.assertEqual(self.format.parse(' +41', '* +##0;*_-##0'), 41)
1092
+ self.assertEqual(self.format.parse('_-41', '* +##0;*_-##0'), -41)
1154
1093
 
1155
1094
  def testParsePadding1Padding2WithPrefix(self):
1156
1095
  self.assertEqual(self.format.parse(' + 41', '* +* ###0;*_-*_###0'),
@@ -1159,18 +1098,14 @@ class TestNumberFormat(TestCase):
1159
1098
  -41)
1160
1099
 
1161
1100
  def testParsePadding1Scientific(self):
1162
- self.assertEqual(self.format.parse(' 4.102E1',
1163
- '* 0.0####E0;*_0.0####E0'),
1164
- 41.02)
1165
- self.assertEqual(self.format.parse('__4.102E1',
1166
- '* 0.0####E0;*_0.0####E0'),
1167
- -41.02)
1168
- self.assertEqual(self.format.parse(' +4.102E1',
1169
- '* +0.0###E0;*_-0.0###E0'),
1170
- 41.02)
1171
- self.assertEqual(self.format.parse('_-4.102E1',
1172
- '* +0.0###E0;*_-0.0###E0'),
1173
- -41.02)
1101
+ self.assertEqual(
1102
+ self.format.parse(' 4.102E1', '* 0.0####E0;*_0.0####E0'), 41.02)
1103
+ self.assertEqual(
1104
+ self.format.parse('__4.102E1', '* 0.0####E0;*_0.0####E0'), -41.02)
1105
+ self.assertEqual(
1106
+ self.format.parse(' +4.102E1', '* +0.0###E0;*_-0.0###E0'), 41.02)
1107
+ self.assertEqual(
1108
+ self.format.parse('_-4.102E1', '* +0.0###E0;*_-0.0###E0'), -41.02)
1174
1109
 
1175
1110
  def testParsePadding3WithoutSufffix(self):
1176
1111
  self.assertEqual(self.format.parse('41.02 ', '#0.0###* ;#0.0###*_'),
@@ -1180,25 +1115,19 @@ class TestNumberFormat(TestCase):
1180
1115
 
1181
1116
  def testParsePadding3WithSufffix(self):
1182
1117
  self.assertEqual(
1183
- self.format.parse('[41.02 ]', '[#0.0###* ];(#0.0###*_)'),
1184
- 41.02)
1118
+ self.format.parse('[41.02 ]', '[#0.0###* ];(#0.0###*_)'), 41.02)
1185
1119
  self.assertEqual(
1186
- self.format.parse('(41.02__)', '[#0.0###* ];(#0.0###*_)'),
1187
- -41.02)
1120
+ self.format.parse('(41.02__)', '[#0.0###* ];(#0.0###*_)'), -41.02)
1188
1121
 
1189
1122
  def testParsePadding3Scientific(self):
1190
- self.assertEqual(self.format.parse('4.102E1 ',
1191
- '0.0##E0##* ;0.0##E0##*_'),
1192
- 41.02)
1193
- self.assertEqual(self.format.parse('4.102E1__',
1194
- '0.0##E0##* ;0.0##E0##*_'),
1195
- -41.02)
1196
- self.assertEqual(self.format.parse('(4.102E1 )',
1197
- '(0.0##E0##* );0.0E0'),
1198
- 41.02)
1199
- self.assertEqual(self.format.parse('[4.102E1__]',
1200
- '0.0E0;[0.0##E0##*_]'),
1201
- -41.02)
1123
+ self.assertEqual(
1124
+ self.format.parse('4.102E1 ', '0.0##E0##* ;0.0##E0##*_'), 41.02)
1125
+ self.assertEqual(
1126
+ self.format.parse('4.102E1__', '0.0##E0##* ;0.0##E0##*_'), -41.02)
1127
+ self.assertEqual(
1128
+ self.format.parse('(4.102E1 )', '(0.0##E0##* );0.0E0'), 41.02)
1129
+ self.assertEqual(
1130
+ self.format.parse('[4.102E1__]', '0.0E0;[0.0##E0##*_]'), -41.02)
1202
1131
 
1203
1132
  def testParsePadding3Padding4WithSuffix(self):
1204
1133
  self.assertEqual(self.format.parse('(41.02 ) ', '(#0.0###* )* '),
@@ -1211,8 +1140,11 @@ class TestNumberFormat(TestCase):
1211
1140
  self.assertEqual(format.parse('1.234,567', '#,##0.000'), 1234.567)
1212
1141
 
1213
1142
  def testParseWithAlternativeExponentialSymbol(self):
1214
- format = NumberFormat(
1215
- symbols={'decimal': '.', 'group': ',', 'exponential': 'X'})
1143
+ format = NumberFormat(symbols={
1144
+ 'decimal': '.',
1145
+ 'group': ',',
1146
+ 'exponential': 'X'
1147
+ })
1216
1148
  self.assertEqual(format.parse('1.2X11', '#.#E0'), 1.2e11)
1217
1149
 
1218
1150
  def testParseFailWithInvalidCharacters(self):
@@ -1240,62 +1172,41 @@ class TestNumberFormat(TestCase):
1240
1172
  decimal.Decimal('233.41'))
1241
1173
 
1242
1174
  def testFormatSimpleInteger(self):
1243
- self.assertEqual(self.format.format(23341, '###0'),
1244
- '23341')
1245
- self.assertEqual(self.format.format(41, '#000'),
1246
- '041')
1175
+ self.assertEqual(self.format.format(23341, '###0'), '23341')
1176
+ self.assertEqual(self.format.format(41, '#000'), '041')
1247
1177
 
1248
1178
  def testFormatScientificInteger(self):
1249
- self.assertEqual(self.format.format(23341, '0.000#E0'),
1250
- '2.3341E4')
1251
- self.assertEqual(self.format.format(23341, '0.000#E00'),
1252
- '2.3341E04')
1253
- self.assertEqual(self.format.format(1, '0.##E0'),
1254
- '1E0')
1255
- self.assertEqual(self.format.format(1, '0.00E00'),
1256
- '1.00E00')
1179
+ self.assertEqual(self.format.format(23341, '0.000#E0'), '2.3341E4')
1180
+ self.assertEqual(self.format.format(23341, '0.000#E00'), '2.3341E04')
1181
+ self.assertEqual(self.format.format(1, '0.##E0'), '1E0')
1182
+ self.assertEqual(self.format.format(1, '0.00E00'), '1.00E00')
1257
1183
  # This is a special case I found not working, but is used frequently
1258
1184
  # in the new LDML Locale files.
1259
1185
  self.assertEqual(self.format.format(23341, '0.000###E+00'),
1260
1186
  '2.3341E+04')
1261
1187
 
1262
1188
  def testFormatScientificZero(self):
1263
- self.assertEqual(self.format.format(0, '0.00E00'),
1264
- '0.00E00')
1265
- self.assertEqual(self.format.format(0, '0E0'),
1266
- '0E0')
1189
+ self.assertEqual(self.format.format(0, '0.00E00'), '0.00E00')
1190
+ self.assertEqual(self.format.format(0, '0E0'), '0E0')
1267
1191
 
1268
1192
  def testFormatPosNegAlternativeInteger(self):
1269
- self.assertEqual(self.format.format(23341, '#000;#00'),
1270
- '23341')
1271
- self.assertEqual(self.format.format(41, '#000;#00'),
1272
- '041')
1273
- self.assertEqual(self.format.format(-23341, '#000;#00'),
1274
- '23341')
1275
- self.assertEqual(self.format.format(-41, '#000;#00'),
1276
- '41')
1277
- self.assertEqual(self.format.format(-1, '#000;#00'),
1278
- '01')
1193
+ self.assertEqual(self.format.format(23341, '#000;#00'), '23341')
1194
+ self.assertEqual(self.format.format(41, '#000;#00'), '041')
1195
+ self.assertEqual(self.format.format(-23341, '#000;#00'), '23341')
1196
+ self.assertEqual(self.format.format(-41, '#000;#00'), '41')
1197
+ self.assertEqual(self.format.format(-1, '#000;#00'), '01')
1279
1198
 
1280
1199
  def testFormatPrefixedInteger(self):
1281
- self.assertEqual(self.format.format(23341, '+###0'),
1282
- '+23341')
1283
- self.assertEqual(self.format.format(41, '+#000'),
1284
- '+041')
1285
- self.assertEqual(self.format.format(-23341, '+###0'),
1286
- '+23341')
1287
- self.assertEqual(self.format.format(-41, '+#000'),
1288
- '+041')
1200
+ self.assertEqual(self.format.format(23341, '+###0'), '+23341')
1201
+ self.assertEqual(self.format.format(41, '+#000'), '+041')
1202
+ self.assertEqual(self.format.format(-23341, '+###0'), '+23341')
1203
+ self.assertEqual(self.format.format(-41, '+#000'), '+041')
1289
1204
 
1290
1205
  def testFormatPosNegInteger(self):
1291
- self.assertEqual(self.format.format(23341, '+###0;-###0'),
1292
- '+23341')
1293
- self.assertEqual(self.format.format(41, '+#000;-#000'),
1294
- '+041')
1295
- self.assertEqual(self.format.format(-23341, '+###0;-###0'),
1296
- '-23341')
1297
- self.assertEqual(self.format.format(-41, '+#000;-#000'),
1298
- '-041')
1206
+ self.assertEqual(self.format.format(23341, '+###0;-###0'), '+23341')
1207
+ self.assertEqual(self.format.format(41, '+#000;-#000'), '+041')
1208
+ self.assertEqual(self.format.format(-23341, '+###0;-###0'), '-23341')
1209
+ self.assertEqual(self.format.format(-41, '+#000;-#000'), '-041')
1299
1210
 
1300
1211
  def testFormatPosNegScientificInteger(self):
1301
1212
  self.assertEqual(self.format.format(23341, '+0.00###E00;-0.00###E00'),
@@ -1304,24 +1215,15 @@ class TestNumberFormat(TestCase):
1304
1215
  '-2.3341E04')
1305
1216
 
1306
1217
  def testFormatThousandSeparatorInteger(self):
1307
- self.assertEqual(
1308
- self.format.format(23341, '+#,##0;-#,##0'),
1309
- '+23,341')
1310
- self.assertEqual(
1311
- self.format.format(-23341, '+#,##0;-#,##0'),
1312
- '-23,341')
1313
- self.assertEqual(
1314
- self.format.format(41, '+#0,000;-#0,000'),
1315
- '+0,041')
1316
- self.assertEqual(
1317
- self.format.format(-41, '+#0,000;-#0,000'),
1318
- '-0,041')
1319
- self.assertEqual(
1320
- self.format.format(987654321, '+#,##0;-#,##0'),
1321
- '+987,654,321')
1322
- self.assertEqual(
1323
- self.format.format(-987654321, '+#,##0;-#,##0'),
1324
- '-987,654,321')
1218
+ self.assertEqual(self.format.format(23341, '+#,##0;-#,##0'), '+23,341')
1219
+ self.assertEqual(self.format.format(-23341, '+#,##0;-#,##0'),
1220
+ '-23,341')
1221
+ self.assertEqual(self.format.format(41, '+#0,000;-#0,000'), '+0,041')
1222
+ self.assertEqual(self.format.format(-41, '+#0,000;-#0,000'), '-0,041')
1223
+ self.assertEqual(self.format.format(987654321, '+#,##0;-#,##0'),
1224
+ '+987,654,321')
1225
+ self.assertEqual(self.format.format(-987654321, '+#,##0;-#,##0'),
1226
+ '-987,654,321')
1325
1227
  self.assertEqual(
1326
1228
  self.format.format(987654321, '+#,##,#0,000;-#,##,#0,000'),
1327
1229
  '+98,76,54,321')
@@ -1330,8 +1232,7 @@ class TestNumberFormat(TestCase):
1330
1232
  '-98,76,54,321')
1331
1233
 
1332
1234
  def testFormatBadThousandSeparator(self):
1333
- self.assertRaises(ValueError,
1334
- self.format.format, 23341, '0,')
1235
+ self.assertRaises(ValueError, self.format.format, 23341, '0,')
1335
1236
 
1336
1237
  def testFormatDecimal(self):
1337
1238
  self.assertEqual(self.format.format(23341.02357, '###0.0#'),
@@ -1359,20 +1260,15 @@ class TestNumberFormat(TestCase):
1359
1260
  def testFormatScientificDecimalSmallerOne(self):
1360
1261
  self.assertEqual(self.format.format(0.02357, '0.00####E00'),
1361
1262
  '2.357E-02')
1362
- self.assertEqual(self.format.format(0.02, '0.0000E00'),
1363
- '2.0000E-02')
1263
+ self.assertEqual(self.format.format(0.02, '0.0000E00'), '2.0000E-02')
1364
1264
 
1365
1265
  def testFormatPadding1WithoutPrefix(self):
1366
- self.assertEqual(self.format.format(41, '* ##0;*_##0'),
1367
- ' 41')
1368
- self.assertEqual(self.format.format(-41, '* ##0;*_##0'),
1369
- '_41')
1266
+ self.assertEqual(self.format.format(41, '* ##0;*_##0'), ' 41')
1267
+ self.assertEqual(self.format.format(-41, '* ##0;*_##0'), '_41')
1370
1268
 
1371
1269
  def testFormatPadding1WithPrefix(self):
1372
- self.assertEqual(self.format.format(41, '* +##0;*_-##0'),
1373
- ' +41')
1374
- self.assertEqual(self.format.format(-41, '* +##0;*_-##0'),
1375
- '_-41')
1270
+ self.assertEqual(self.format.format(41, '* +##0;*_-##0'), ' +41')
1271
+ self.assertEqual(self.format.format(-41, '* +##0;*_-##0'), '_-41')
1376
1272
 
1377
1273
  def testFormatPadding1Scientific(self):
1378
1274
  self.assertEqual(self.format.format(41.02, '* 0.0####E0;*_0.0####E0'),
@@ -1419,40 +1315,33 @@ class TestNumberFormat(TestCase):
1419
1315
  '(4.102E1 ) ')
1420
1316
 
1421
1317
  def testFormatSmallNumbers(self):
1422
- self.assertEqual(self.format.format(
1423
- -1e-7, '(#0.00#####);(-#0.00#####)'), '(-0.0000001)')
1318
+ self.assertEqual(
1319
+ self.format.format(-1e-7, '(#0.00#####);(-#0.00#####)'),
1320
+ '(-0.0000001)')
1424
1321
  self.assertEqual(self.format.format(1e-9, '(#0.00###)'), '(0.00)')
1425
1322
  self.assertEqual(self.format.format(1e-9, '(#0.00###)'), '(0.00)')
1426
1323
 
1427
1324
  def testFormatHighPrecisionNumbers(self):
1428
1325
  self.assertEqual(
1429
- self.format.format(
1430
- 1 + 1e-7, '(#0.00#####);(-#0.00#####)'),
1326
+ self.format.format(1 + 1e-7, '(#0.00#####);(-#0.00#####)'),
1431
1327
  '(1.0000001)')
1328
+ self.assertEqual(self.format.format(1 + 1e-7, '(#0.00###)'),
1329
+ '(1.00000)')
1432
1330
  self.assertEqual(
1433
- self.format.format(
1434
- 1 + 1e-7, '(#0.00###)'),
1435
- '(1.00000)')
1436
- self.assertEqual(
1437
- self.format.format(
1438
- 1 + 1e-9, '(#0.00#######);(-#0.00#######)'),
1331
+ self.format.format(1 + 1e-9, '(#0.00#######);(-#0.00#######)'),
1439
1332
  '(1.000000001)')
1333
+ self.assertEqual(self.format.format(1 + 1e-9, '(#0.00###)'),
1334
+ '(1.00000)')
1440
1335
  self.assertEqual(
1441
- self.format.format(
1442
- 1 + 1e-9, '(#0.00###)'),
1443
- '(1.00000)')
1444
- self.assertEqual(
1445
- self.format.format(
1446
- 1 + 1e-12, '(#0.00##########);(-#0.00##########)'),
1336
+ self.format.format(1 + 1e-12,
1337
+ '(#0.00##########);(-#0.00##########)'),
1447
1338
  '(1.000000000001)')
1448
- self.assertEqual(
1449
- self.format.format(
1450
- 1 + 1e-12, '(#0.00###)'),
1451
- '(1.00000)')
1339
+ self.assertEqual(self.format.format(1 + 1e-12, '(#0.00###)'),
1340
+ '(1.00000)')
1452
1341
 
1453
1342
  def testNoRounding(self):
1454
1343
  # Witout Rounding
1455
1344
  self.assertEqual(
1456
- self.format.format(
1457
- decimal.Decimal('0.99999'), '0.###', rounding=False),
1458
- '0.99999')
1345
+ self.format.format(decimal.Decimal('0.99999'),
1346
+ '0.###',
1347
+ rounding=False), '0.99999')