kennethreitz/dive-into-python3
1
0
Fork 0
mirror of https://github.com/kennethreitz/dive-into-python3.git synced 2026-06-05 23:10:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

added source files for unit testing chapter(s), fixed some bugs in regular expressions chapter

Browse Source
This commit is contained in:
Mark Pilgrim
2009-02-16 14:31:42 -05:00
parent 12562a1761
commit 29129df299
18 changed files with 1232 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.hgignore
+2
View File
@@ -0,0 +1,2 @@
syntax: glob
*.pyc
regular-expressions.html
+9 -9
View File
@@ -209,7 +209,7 @@ characters. If you've used regular expressions in other languages (like Perl), t
<h3 id=tensandones>Checking for tens and ones</h3>
<p>Now let's expand the Roman numeral regular expression to cover the tens and ones place. This example shows the check for tens.
<pre class=screen>
<samp class=prompt>>>> </samp><kbd>pattern = '^M?M?M?M?(CM|CD|D?C?C?C?)(XC|XL|L?X?X?X?)$'</kbd>
<samp class=prompt>>>> </samp><kbd>pattern = '^M?M?M?(CM|CD|D?C?C?C?)(XC|XL|L?X?X?X?)$'</kbd>
<a><samp class=prompt>>>> </samp><kbd>re.search(pattern, 'MCMXL')</kbd> <span>&#x2460;</span></a>
<samp>&lt;_sre.SRE_Match object at 0x008EEB48></samp>
<a><samp class=prompt>>>> </samp><kbd>re.search(pattern, 'MCML')</kbd> <span>&#x2461;</span></a>
@@ -229,10 +229,10 @@ characters. If you've used regular expressions in other languages (like Perl), t
</ol>
<p>The expression for the ones place follows the same pattern. I'll spare you the details and show you the end result.
<pre class=screen>
<samp class=prompt>>>> </samp><kbd>pattern = '^M?M?M?M?(CM|CD|D?C?C?C?)(XC|XL|L?X?X?X?)(IX|IV|V?I?I?I?)$'</kbd>
<samp class=prompt>>>> </samp><kbd>pattern = '^M?M?M?(CM|CD|D?C?C?C?)(XC|XL|L?X?X?X?)(IX|IV|V?I?I?I?)$'</kbd>
</pre><p>So what does that look like using this alternate <code>{n,m}</code> syntax? This example shows the new syntax.
<pre class=screen>
<samp class=prompt>>>> </samp><kbd>pattern = '^M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$'</kbd>
<samp class=prompt>>>> </samp><kbd>pattern = '^M{0,3}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$'</kbd>
<a><samp class=prompt>>>> </samp><kbd>re.search(pattern, 'MDLV')</kbd> <span>&#x2460;</span></a>
<samp>&lt;_sre.SRE_Match object at 0x008EEB48></samp>
<a><samp class=prompt>>>> </samp><kbd>re.search(pattern, 'MMDCLXVI')</kbd> <span>&#x2461;</span></a>
@@ -259,15 +259,15 @@ characters. If you've used regular expressions in other languages (like Perl), t
<p>This will be more clear with an example. Let's revisit the compact regular expression you've been working with, and make it a verbose regular expression. This example shows how.
<pre class=screen>
<samp class=prompt>>>> </samp><kbd>pattern = """
^ # beginning of string
M{0,4} # thousands - 0 to 4 M's
^ # beginning of string
M{0,3} # thousands - 0 to 3 M's
(CM|CD|D?C{0,3}) # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
# or 500-800 (D, followed by 0 to 3 C's)
# or 500-800 (D, followed by 0 to 3 C's)
(XC|XL|L?X{0,3}) # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
# or 50-80 (L, followed by 0 to 3 X's)
# or 50-80 (L, followed by 0 to 3 X's)
(IX|IV|V?I{0,3}) # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
# or 5-8 (V, followed by 0 to 3 I's)
$ # end of string
# or 5-8 (V, followed by 0 to 3 I's)
$ # end of string
"""</kbd>
<a><samp class=prompt>>>> </samp><kbd>re.search(pattern, 'M', re.VERBOSE)</kbd> <span>&#x2460;</span></a>
<samp>&lt;_sre.SRE_Match object at 0x008EEB48></samp>
roman1.py
+33
View File
@@ -0,0 +1,33 @@
"""Convert to and from Roman numerals
This program is part of "Dive Into Python 3", a free Python book for
experienced programmers. Visit http://diveintopython3.org/ for the
latest version.
"""
roman_numeral_map = (('M', 1000),
('CM', 900),
('D', 500),
('CD', 400),
('C', 100),
('XC', 90),
('L', 50),
('XL', 40),
('X', 10),
('IX', 9),
('V', 5),
('IV', 4),
('I', 1))
def to_roman(n):
"""convert integer to Roman numeral"""
result = ""
for numeral, integer in roman_numeral_map:
while n >= integer:
result += numeral
n -= integer
return result
def from_roman(s):
"""convert Roman numeral to integer"""
pass
roman2.py
+37
View File
@@ -0,0 +1,37 @@
"""Convert to and from Roman numerals
This program is part of "Dive Into Python 3", a free Python book for
experienced programmers. Visit http://diveintopython3.org/ for the
latest version.
"""
class OutOfRangeError(ValueError): pass
roman_numeral_map = (('M', 1000),
('CM', 900),
('D', 500),
('CD', 400),
('C', 100),
('XC', 90),
('L', 50),
('XL', 40),
('X', 10),
('IX', 9),
('V', 5),
('IV', 4),
('I', 1))
def to_roman(n):
"""convert integer to Roman numeral"""
if n > 3999:
raise OutOfRangeError("number out of range (must be less than 3999)")
result = ""
for numeral, integer in roman_numeral_map:
while n >= integer:
result += numeral
n -= integer
return result
def from_roman(s):
"""convert Roman numeral to integer"""
pass
roman3.py
+37
View File
@@ -0,0 +1,37 @@
"""Convert to and from Roman numerals
This program is part of "Dive Into Python 3", a free Python book for
experienced programmers. Visit http://diveintopython3.org/ for the
latest version.
"""
class OutOfRangeError(ValueError): pass
roman_numeral_map = (('M', 1000),
('CM', 900),
('D', 500),
('CD', 400),
('C', 100),
('XC', 90),
('L', 50),
('XL', 40),
('X', 10),
('IX', 9),
('V', 5),
('IV', 4),
('I', 1))
def to_roman(n):
"""convert integer to Roman numeral"""
if not (0 < n < 4000):
raise OutOfRangeError("number out of range (must be 0..3999)")
result = ""
for numeral, integer in roman_numeral_map:
while n >= integer:
result += numeral
n -= integer
return result
def from_roman(s):
"""convert Roman numeral to integer"""
pass
roman4.py
+40
View File
@@ -0,0 +1,40 @@
"""Convert to and from Roman numerals
This program is part of "Dive Into Python 3", a free Python book for
experienced programmers. Visit http://diveintopython3.org/ for the
latest version.
"""
class OutOfRangeError(ValueError): pass
class NotIntegerError(ValueError): pass
roman_numeral_map = (('M', 1000),
('CM', 900),
('D', 500),
('CD', 400),
('C', 100),
('XC', 90),
('L', 50),
('XL', 40),
('X', 10),
('IX', 9),
('V', 5),
('IV', 4),
('I', 1))
def to_roman(n):
"""convert integer to Roman numeral"""
if not (0 < n < 4000):
raise OutOfRangeError("number out of range (must be 0..3999)")
if not isinstance(n, int):
raise NotIntegerError("non-integers can not be converted")
result = ""
for numeral, integer in roman_numeral_map:
while n >= integer:
result += numeral
n -= integer
return result
def from_roman(s):
"""convert Roman numeral to integer"""
pass
roman5.py
+46
View File
@@ -0,0 +1,46 @@
"""Convert to and from Roman numerals
This program is part of "Dive Into Python 3", a free Python book for
experienced programmers. Visit http://diveintopython3.org/ for the
latest version.
"""
class OutOfRangeError(ValueError): pass
class NotIntegerError(ValueError): pass
roman_numeral_map = (('M', 1000),
('CM', 900),
('D', 500),
('CD', 400),
('C', 100),
('XC', 90),
('L', 50),
('XL', 40),
('X', 10),
('IX', 9),
('V', 5),
('IV', 4),
('I', 1))
def to_roman(n):
"""convert integer to Roman numeral"""
if not (0 < n < 4000):
raise OutOfRangeError("number out of range (must be 0..3999)")
if not isinstance(n, int):
raise NotIntegerError("non-integers can not be converted")
result = ""
for numeral, integer in roman_numeral_map:
while n >= integer:
result += numeral
n -= integer
return result
def from_roman(s):
"""convert Roman numeral to integer"""
result = 0
index = 0
for numeral, integer in roman_numeral_map:
while s[index : index + len(numeral)] == numeral:
result += integer
index += len(numeral)
return result
roman6.py
+64
View File
@@ -0,0 +1,64 @@
"""Convert to and from Roman numerals
This program is part of "Dive Into Python 3", a free Python book for
experienced programmers. Visit http://diveintopython3.org/ for the
latest version.
"""
import re
class OutOfRangeError(ValueError): pass
class NotIntegerError(ValueError): pass
class InvalidRomanNumeralError(ValueError): pass
roman_numeral_map = (('M', 1000),
('CM', 900),
('D', 500),
('CD', 400),
('C', 100),
('XC', 90),
('L', 50),
('XL', 40),
('X', 10),
('IX', 9),
('V', 5),
('IV', 4),
('I', 1))
roman_numeral_pattern = re.compile("""
^ # beginning of string
M{0,3} # thousands - 0 to 3 M's
(CM|CD|D?C{0,3}) # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
# or 500-800 (D, followed by 0 to 3 C's)
(XC|XL|L?X{0,3}) # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
# or 50-80 (L, followed by 0 to 3 X's)
(IX|IV|V?I{0,3}) # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
# or 5-8 (V, followed by 0 to 3 I's)
$ # end of string
""", re.VERBOSE)
def to_roman(n):
"""convert integer to Roman numeral"""
if not (0 < n < 4000):
raise OutOfRangeError("number out of range (must be 0..3999)")
if not isinstance(n, int):
raise NotIntegerError("non-integers can not be converted")
result = ""
for numeral, integer in roman_numeral_map:
while n >= integer:
result += numeral
n -= integer
return result
def from_roman(s):
"""convert Roman numeral to integer"""
if not roman_numeral_pattern.search(s):
raise InvalidRomanNumeralError("Invalid Roman numeral: {0}".format(s))
result = 0
index = 0
for numeral, integer in roman_numeral_map:
while s[index : index + len(numeral)] == numeral:
result += integer
index += len(numeral)
return result
roman7.py
+66
View File
@@ -0,0 +1,66 @@
"""Convert to and from Roman numerals
This program is part of "Dive Into Python 3", a free Python book for
experienced programmers. Visit http://diveintopython3.org/ for the
latest version.
"""
import re
class OutOfRangeError(ValueError): pass
class NotIntegerError(ValueError): pass
class InvalidRomanNumeralError(ValueError): pass
roman_numeral_map = (('M', 1000),
('CM', 900),
('D', 500),
('CD', 400),
('C', 100),
('XC', 90),
('L', 50),
('XL', 40),
('X', 10),
('IX', 9),
('V', 5),
('IV', 4),
('I', 1))
roman_numeral_pattern = re.compile("""
^ # beginning of string
M{0,3} # thousands - 0 to 3 M's
(CM|CD|D?C{0,3}) # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
# or 500-800 (D, followed by 0 to 3 C's)
(XC|XL|L?X{0,3}) # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
# or 50-80 (L, followed by 0 to 3 X's)
(IX|IV|V?I{0,3}) # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
# or 5-8 (V, followed by 0 to 3 I's)
$ # end of string
""", re.VERBOSE)
def to_roman(n):
"""convert integer to Roman numeral"""
if not (0 < n < 4000):
raise OutOfRangeError("number out of range (must be 0..3999)")
if not isinstance(n, int):
raise NotIntegerError("non-integers can not be converted")
result = ""
for numeral, integer in roman_numeral_map:
while n >= integer:
result += numeral
n -= integer
return result
def from_roman(s):
"""convert Roman numeral to integer"""
if not s:
raise InvalidRomanNumeralError("Input can not be blank")
if not roman_numeral_pattern.search(s):
raise InvalidRomanNumeralError("Invalid Roman numeral: {0}".format(s))
result = 0
index = 0
for numeral, integer in roman_numeral_map:
while s[index : index + len(numeral)] == numeral:
result += integer
index += len(numeral)
return result
roman8.py
+68
View File
@@ -0,0 +1,68 @@
"""Convert to and from Roman numerals
This program is part of "Dive Into Python 3", a free Python book for
experienced programmers. Visit http://diveintopython3.org/ for the
latest version.
"""
import re
class OutOfRangeError(ValueError): pass
class NotIntegerError(ValueError): pass
class InvalidRomanNumeralError(ValueError): pass
roman_numeral_map = (('M', 1000),
('CM', 900),
('D', 500),
('CD', 400),
('C', 100),
('XC', 90),
('L', 50),
('XL', 40),
('X', 10),
('IX', 9),
('V', 5),
('IV', 4),
('I', 1))
roman_numeral_pattern = re.compile("""
^ # beginning of string
M{0,3} # thousands - 0 to 3 M's
(CM|CD|D?C{0,3}) # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
# or 500-800 (D, followed by 0 to 3 C's)
(XC|XL|L?X{0,3}) # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
# or 50-80 (L, followed by 0 to 3 X's)
(IX|IV|V?I{0,3}) # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
# or 5-8 (V, followed by 0 to 3 I's)
$ # end of string
""", re.VERBOSE)
def to_roman(n):
"""convert integer to Roman numeral"""
if not (0 < n < 4000):
raise OutOfRangeError("number out of range (must be 0..3999)")
if not isinstance(n, int):
raise NotIntegerError("non-integers can not be converted")
result = ""
for numeral, integer in roman_numeral_map:
while n >= integer:
result += numeral
n -= integer
return result
def from_roman(s):
"""convert Roman numeral to integer"""
if not isinstance(s, str):
raise InvalidRomanNumeralError("Input must be a string")
if not s:
raise InvalidRomanNumeralError("Input can not be blank")
if not roman_numeral_pattern.search(s):
raise InvalidRomanNumeralError("Invalid Roman numeral: {0}".format(s))
result = 0
index = 0
for numeral, integer in roman_numeral_map:
while s[index : index + len(numeral)] == numeral:
result += integer
index += len(numeral)
return result
romantest1.py
+76
View File
@@ -0,0 +1,76 @@
"""Unit test for roman1.py
This program is part of "Dive Into Python 3", a free Python book for
experienced programmers. Visit http://diveintopython3.org/ for the
latest version.
"""
import roman1
import unittest
class KnownValues(unittest.TestCase):
known_values = ( (1, 'I'),
(2, 'II'),
(3, 'III'),
(4, 'IV'),
(5, 'V'),
(6, 'VI'),
(7, 'VII'),
(8, 'VIII'),
(9, 'IX'),
(10, 'X'),
(50, 'L'),
(100, 'C'),
(500, 'D'),
(1000, 'M'),
(31, 'XXXI'),
(148, 'CXLVIII'),
(294, 'CCXCIV'),
(312, 'CCCXII'),
(421, 'CDXXI'),
(528, 'DXXVIII'),
(621, 'DCXXI'),
(782, 'DCCLXXXII'),
(870, 'DCCCLXX'),
(941, 'CMXLI'),
(1043, 'MXLIII'),
(1110, 'MCX'),
(1226, 'MCCXXVI'),
(1301, 'MCCCI'),
(1485, 'MCDLXXXV'),
(1509, 'MDIX'),
(1607, 'MDCVII'),
(1754, 'MDCCLIV'),
(1832, 'MDCCCXXXII'),
(1993, 'MCMXCIII'),
(2074, 'MMLXXIV'),
(2152, 'MMCLII'),
(2212, 'MMCCXII'),
(2343, 'MMCCCXLIII'),
(2499, 'MMCDXCIX'),
(2574, 'MMDLXXIV'),
(2646, 'MMDCXLVI'),
(2723, 'MMDCCXXIII'),
(2892, 'MMDCCCXCII'),
(2975, 'MMCMLXXV'),
(3051, 'MMMLI'),
(3185, 'MMMCLXXXV'),
(3250, 'MMMCCL'),
(3313, 'MMMCCCXIII'),
(3408, 'MMMCDVIII'),
(3501, 'MMMDI'),
(3610, 'MMMDCX'),
(3743, 'MMMDCCXLIII'),
(3844, 'MMMDCCCXLIV'),
(3888, 'MMMDCCCLXXXVIII'),
(3940, 'MMMCMXL'),
(3999, 'MMMCMXCIX'))
def test_to_roman_known_values(self):
"""to_roman should give known result with known input"""
for integer, numeral in self.known_values:
result = roman1.to_roman(integer)
self.assertEqual(numeral, result)
if __name__ == "__main__":
unittest.main()
romantest2.py
+81
View File
@@ -0,0 +1,81 @@
"""Unit test for roman1.py
This program is part of "Dive Into Python 3", a free Python book for
experienced programmers. Visit http://diveintopython3.org/ for the
latest version.
"""
import roman2
import unittest
class KnownValues(unittest.TestCase):
known_values = ( (1, 'I'),
(2, 'II'),
(3, 'III'),
(4, 'IV'),
(5, 'V'),
(6, 'VI'),
(7, 'VII'),
(8, 'VIII'),
(9, 'IX'),
(10, 'X'),
(50, 'L'),
(100, 'C'),
(500, 'D'),
(1000, 'M'),
(31, 'XXXI'),
(148, 'CXLVIII'),
(294, 'CCXCIV'),
(312, 'CCCXII'),
(421, 'CDXXI'),
(528, 'DXXVIII'),
(621, 'DCXXI'),
(782, 'DCCLXXXII'),
(870, 'DCCCLXX'),
(941, 'CMXLI'),
(1043, 'MXLIII'),
(1110, 'MCX'),
(1226, 'MCCXXVI'),
(1301, 'MCCCI'),
(1485, 'MCDLXXXV'),
(1509, 'MDIX'),
(1607, 'MDCVII'),
(1754, 'MDCCLIV'),
(1832, 'MDCCCXXXII'),
(1993, 'MCMXCIII'),
(2074, 'MMLXXIV'),
(2152, 'MMCLII'),
(2212, 'MMCCXII'),
(2343, 'MMCCCXLIII'),
(2499, 'MMCDXCIX'),
(2574, 'MMDLXXIV'),
(2646, 'MMDCXLVI'),
(2723, 'MMDCCXXIII'),
(2892, 'MMDCCCXCII'),
(2975, 'MMCMLXXV'),
(3051, 'MMMLI'),
(3185, 'MMMCLXXXV'),
(3250, 'MMMCCL'),
(3313, 'MMMCCCXIII'),
(3408, 'MMMCDVIII'),
(3501, 'MMMDI'),
(3610, 'MMMDCX'),
(3743, 'MMMDCCXLIII'),
(3844, 'MMMDCCCXLIV'),
(3888, 'MMMDCCCLXXXVIII'),
(3940, 'MMMCMXL'),
(3999, 'MMMCMXCIX'))
def test_to_roman_known_values(self):
"""to_roman should give known result with known input"""
for integer, numeral in self.known_values:
result = roman2.to_roman(integer)
self.assertEqual(numeral, result)
class ToRomanBadInput(unittest.TestCase):
def test_too_large(self):
"""to_roman should fail with large input"""
self.assertRaises(roman2.OutOfRangeError, roman2.to_roman, 4000)
if __name__ == "__main__":
unittest.main()
romantest3.py
+89
View File
@@ -0,0 +1,89 @@
"""Unit test for roman1.py
This program is part of "Dive Into Python 3", a free Python book for
experienced programmers. Visit http://diveintopython3.org/ for the
latest version.
"""
import roman3
import unittest
class KnownValues(unittest.TestCase):
known_values = ( (1, 'I'),
(2, 'II'),
(3, 'III'),
(4, 'IV'),
(5, 'V'),
(6, 'VI'),
(7, 'VII'),
(8, 'VIII'),
(9, 'IX'),
(10, 'X'),
(50, 'L'),
(100, 'C'),
(500, 'D'),
(1000, 'M'),
(31, 'XXXI'),
(148, 'CXLVIII'),
(294, 'CCXCIV'),
(312, 'CCCXII'),
(421, 'CDXXI'),
(528, 'DXXVIII'),
(621, 'DCXXI'),
(782, 'DCCLXXXII'),
(870, 'DCCCLXX'),
(941, 'CMXLI'),
(1043, 'MXLIII'),
(1110, 'MCX'),
(1226, 'MCCXXVI'),
(1301, 'MCCCI'),
(1485, 'MCDLXXXV'),
(1509, 'MDIX'),
(1607, 'MDCVII'),
(1754, 'MDCCLIV'),
(1832, 'MDCCCXXXII'),
(1993, 'MCMXCIII'),
(2074, 'MMLXXIV'),
(2152, 'MMCLII'),
(2212, 'MMCCXII'),
(2343, 'MMCCCXLIII'),
(2499, 'MMCDXCIX'),
(2574, 'MMDLXXIV'),
(2646, 'MMDCXLVI'),
(2723, 'MMDCCXXIII'),
(2892, 'MMDCCCXCII'),
(2975, 'MMCMLXXV'),
(3051, 'MMMLI'),
(3185, 'MMMCLXXXV'),
(3250, 'MMMCCL'),
(3313, 'MMMCCCXIII'),
(3408, 'MMMCDVIII'),
(3501, 'MMMDI'),
(3610, 'MMMDCX'),
(3743, 'MMMDCCXLIII'),
(3844, 'MMMDCCCXLIV'),
(3888, 'MMMDCCCLXXXVIII'),
(3940, 'MMMCMXL'),
(3999, 'MMMCMXCIX'))
def test_to_roman_known_values(self):
"""to_roman should give known result with known input"""
for integer, numeral in self.known_values:
result = roman3.to_roman(integer)
self.assertEqual(numeral, result)
class ToRomanBadInput(unittest.TestCase):
def test_too_large(self):
"""to_roman should fail with large input"""
self.assertRaises(roman3.OutOfRangeError, roman3.to_roman, 4000)
def test_zero(self):
"""to_roman should fail with 0 input"""
self.assertRaises(roman3.OutOfRangeError, roman3.to_roman, 0)
def test_negative(self):
"""to_roman should fail with negative input"""
self.assertRaises(roman3.OutOfRangeError, roman3.to_roman, -1)
if __name__ == "__main__":
unittest.main()
romantest4.py
+93
View File
@@ -0,0 +1,93 @@
"""Unit test for roman1.py
This program is part of "Dive Into Python 3", a free Python book for
experienced programmers. Visit http://diveintopython3.org/ for the
latest version.
"""
import roman4
import unittest
class KnownValues(unittest.TestCase):
known_values = ( (1, 'I'),
(2, 'II'),
(3, 'III'),
(4, 'IV'),
(5, 'V'),
(6, 'VI'),
(7, 'VII'),
(8, 'VIII'),
(9, 'IX'),
(10, 'X'),
(50, 'L'),
(100, 'C'),
(500, 'D'),
(1000, 'M'),
(31, 'XXXI'),
(148, 'CXLVIII'),
(294, 'CCXCIV'),
(312, 'CCCXII'),
(421, 'CDXXI'),
(528, 'DXXVIII'),
(621, 'DCXXI'),
(782, 'DCCLXXXII'),
(870, 'DCCCLXX'),
(941, 'CMXLI'),
(1043, 'MXLIII'),
(1110, 'MCX'),
(1226, 'MCCXXVI'),
(1301, 'MCCCI'),
(1485, 'MCDLXXXV'),
(1509, 'MDIX'),
(1607, 'MDCVII'),
(1754, 'MDCCLIV'),
(1832, 'MDCCCXXXII'),
(1993, 'MCMXCIII'),
(2074, 'MMLXXIV'),
(2152, 'MMCLII'),
(2212, 'MMCCXII'),
(2343, 'MMCCCXLIII'),
(2499, 'MMCDXCIX'),
(2574, 'MMDLXXIV'),
(2646, 'MMDCXLVI'),
(2723, 'MMDCCXXIII'),
(2892, 'MMDCCCXCII'),
(2975, 'MMCMLXXV'),
(3051, 'MMMLI'),
(3185, 'MMMCLXXXV'),
(3250, 'MMMCCL'),
(3313, 'MMMCCCXIII'),
(3408, 'MMMCDVIII'),
(3501, 'MMMDI'),
(3610, 'MMMDCX'),
(3743, 'MMMDCCXLIII'),
(3844, 'MMMDCCCXLIV'),
(3888, 'MMMDCCCLXXXVIII'),
(3940, 'MMMCMXL'),
(3999, 'MMMCMXCIX'))
def test_to_roman_known_values(self):
"""to_roman should give known result with known input"""
for integer, numeral in self.known_values:
result = roman4.to_roman(integer)
self.assertEqual(numeral, result)
class ToRomanBadInput(unittest.TestCase):
def test_too_large(self):
"""to_roman should fail with large input"""
self.assertRaises(roman4.OutOfRangeError, roman4.to_roman, 4000)
def test_zero(self):
"""to_roman should fail with 0 input"""
self.assertRaises(roman4.OutOfRangeError, roman4.to_roman, 0)
def test_negative(self):
"""to_roman should fail with negative input"""
self.assertRaises(roman4.OutOfRangeError, roman4.to_roman, -1)
def test_non_integer(self):
"""to_roman should fail with non-integer input"""
self.assertRaises(roman4.NotIntegerError, roman4.to_roman, 0.5)
if __name__ == "__main__":
unittest.main()
romantest5.py
+107
View File
@@ -0,0 +1,107 @@
"""Unit test for roman1.py
This program is part of "Dive Into Python 3", a free Python book for
experienced programmers. Visit http://diveintopython3.org/ for the
latest version.
"""
import roman5
import unittest
class KnownValues(unittest.TestCase):
known_values = ( (1, 'I'),
(2, 'II'),
(3, 'III'),
(4, 'IV'),
(5, 'V'),
(6, 'VI'),
(7, 'VII'),
(8, 'VIII'),
(9, 'IX'),
(10, 'X'),
(50, 'L'),
(100, 'C'),
(500, 'D'),
(1000, 'M'),
(31, 'XXXI'),
(148, 'CXLVIII'),
(294, 'CCXCIV'),
(312, 'CCCXII'),
(421, 'CDXXI'),
(528, 'DXXVIII'),
(621, 'DCXXI'),
(782, 'DCCLXXXII'),
(870, 'DCCCLXX'),
(941, 'CMXLI'),
(1043, 'MXLIII'),
(1110, 'MCX'),
(1226, 'MCCXXVI'),
(1301, 'MCCCI'),
(1485, 'MCDLXXXV'),
(1509, 'MDIX'),
(1607, 'MDCVII'),
(1754, 'MDCCLIV'),
(1832, 'MDCCCXXXII'),
(1993, 'MCMXCIII'),
(2074, 'MMLXXIV'),
(2152, 'MMCLII'),
(2212, 'MMCCXII'),
(2343, 'MMCCCXLIII'),
(2499, 'MMCDXCIX'),
(2574, 'MMDLXXIV'),
(2646, 'MMDCXLVI'),
(2723, 'MMDCCXXIII'),
(2892, 'MMDCCCXCII'),
(2975, 'MMCMLXXV'),
(3051, 'MMMLI'),
(3185, 'MMMCLXXXV'),
(3250, 'MMMCCL'),
(3313, 'MMMCCCXIII'),
(3408, 'MMMCDVIII'),
(3501, 'MMMDI'),
(3610, 'MMMDCX'),
(3743, 'MMMDCCXLIII'),
(3844, 'MMMDCCCXLIV'),
(3888, 'MMMDCCCLXXXVIII'),
(3940, 'MMMCMXL'),
(3999, 'MMMCMXCIX'))
def test_to_roman_known_values(self):
"""to_roman should give known result with known input"""
for integer, numeral in self.known_values:
result = roman5.to_roman(integer)
self.assertEqual(numeral, result)
def test_from_roman_known_values(self):
"""from_roman should give known result with known input"""
for integer, numeral in self.known_values:
result = roman5.from_roman(numeral)
self.assertEqual(integer, result)
class ToRomanBadInput(unittest.TestCase):
def test_too_large(self):
"""to_roman should fail with large input"""
self.assertRaises(roman5.OutOfRangeError, roman5.to_roman, 4000)
def test_zero(self):
"""to_roman should fail with 0 input"""
self.assertRaises(roman5.OutOfRangeError, roman5.to_roman, 0)
def test_negative(self):
"""to_roman should fail with negative input"""
self.assertRaises(roman5.OutOfRangeError, roman5.to_roman, -1)
def test_non_integer(self):
"""to_roman should fail with non-integer input"""
self.assertRaises(roman5.NotIntegerError, roman5.to_roman, 0.5)
class SanityCheck(unittest.TestCase):
def testSanity(self):
"""from_roman(to_roman(n))==n for all n"""
for integer in range(1, 4000):
numeral = roman5.to_roman(integer)
result = roman5.from_roman(numeral)
self.assertEqual(integer, result)
if __name__ == "__main__":
unittest.main()
romantest6.py
+124
View File
@@ -0,0 +1,124 @@
"""Unit test for roman1.py
This program is part of "Dive Into Python 3", a free Python book for
experienced programmers. Visit http://diveintopython3.org/ for the
latest version.
"""
import roman6
import unittest
class KnownValues(unittest.TestCase):
known_values = ( (1, 'I'),
(2, 'II'),
(3, 'III'),
(4, 'IV'),
(5, 'V'),
(6, 'VI'),
(7, 'VII'),
(8, 'VIII'),
(9, 'IX'),
(10, 'X'),
(50, 'L'),
(100, 'C'),
(500, 'D'),
(1000, 'M'),
(31, 'XXXI'),
(148, 'CXLVIII'),
(294, 'CCXCIV'),
(312, 'CCCXII'),
(421, 'CDXXI'),
(528, 'DXXVIII'),
(621, 'DCXXI'),
(782, 'DCCLXXXII'),
(870, 'DCCCLXX'),
(941, 'CMXLI'),
(1043, 'MXLIII'),
(1110, 'MCX'),
(1226, 'MCCXXVI'),
(1301, 'MCCCI'),
(1485, 'MCDLXXXV'),
(1509, 'MDIX'),
(1607, 'MDCVII'),
(1754, 'MDCCLIV'),
(1832, 'MDCCCXXXII'),
(1993, 'MCMXCIII'),
(2074, 'MMLXXIV'),
(2152, 'MMCLII'),
(2212, 'MMCCXII'),
(2343, 'MMCCCXLIII'),
(2499, 'MMCDXCIX'),
(2574, 'MMDLXXIV'),
(2646, 'MMDCXLVI'),
(2723, 'MMDCCXXIII'),
(2892, 'MMDCCCXCII'),
(2975, 'MMCMLXXV'),
(3051, 'MMMLI'),
(3185, 'MMMCLXXXV'),
(3250, 'MMMCCL'),
(3313, 'MMMCCCXIII'),
(3408, 'MMMCDVIII'),
(3501, 'MMMDI'),
(3610, 'MMMDCX'),
(3743, 'MMMDCCXLIII'),
(3844, 'MMMDCCCXLIV'),
(3888, 'MMMDCCCLXXXVIII'),
(3940, 'MMMCMXL'),
(3999, 'MMMCMXCIX'))
def test_to_roman_known_values(self):
"""to_roman should give known result with known input"""
for integer, numeral in self.known_values:
result = roman6.to_roman(integer)
self.assertEqual(numeral, result)
def test_from_roman_known_values(self):
"""from_roman should give known result with known input"""
for integer, numeral in self.known_values:
result = roman6.from_roman(numeral)
self.assertEqual(integer, result)
class ToRomanBadInput(unittest.TestCase):
def test_too_large(self):
"""to_roman should fail with large input"""
self.assertRaises(roman6.OutOfRangeError, roman6.to_roman, 4000)
def test_zero(self):
"""to_roman should fail with 0 input"""
self.assertRaises(roman6.OutOfRangeError, roman6.to_roman, 0)
def test_negative(self):
"""to_roman should fail with negative input"""
self.assertRaises(roman6.OutOfRangeError, roman6.to_roman, -1)
def test_non_integer(self):
"""to_roman should fail with non-integer input"""
self.assertRaises(roman6.NotIntegerError, roman6.to_roman, 0.5)
class FromRomanBadInput(unittest.TestCase):
def test_too_many_repeated_numerals(self):
"""from_roman should fail with too many repeated numerals"""
for s in ('MMMMM', 'DD', 'CCCC', 'LL', 'XXXX', 'VV', 'IIII'):
self.assertRaises(roman6.InvalidRomanNumeralError, roman6.from_roman, s)
def test_repeated_pairs(self):
"""from_roman should fail with repeated pairs of numerals"""
for s in ('CMCM', 'CDCD', 'XCXC', 'XLXL', 'IXIX', 'IVIV'):
self.assertRaises(roman6.InvalidRomanNumeralError, roman6.from_roman, s)
def test_malformed_antecedents(self):
"""from_roman should fail with malformed antecedents"""
for s in ('IIMXCC', 'VX', 'DCM', 'CMM', 'IXIV',
'MCMC', 'XCX', 'IVI', 'LM', 'LD', 'LC'):
self.assertRaises(roman6.InvalidRomanNumeralError, roman6.from_roman, s)
class SanityCheck(unittest.TestCase):
def testSanity(self):
"""from_roman(to_roman(n))==n for all n"""
for integer in range(1, 4000):
numeral = roman6.to_roman(integer)
result = roman6.from_roman(numeral)
self.assertEqual(integer, result)
if __name__ == "__main__":
unittest.main()
romantest7.py
+128
View File
@@ -0,0 +1,128 @@
"""Unit test for roman1.py
This program is part of "Dive Into Python 3", a free Python book for
experienced programmers. Visit http://diveintopython3.org/ for the
latest version.
"""
import roman7
import unittest
class KnownValues(unittest.TestCase):
known_values = ( (1, 'I'),
(2, 'II'),
(3, 'III'),
(4, 'IV'),
(5, 'V'),
(6, 'VI'),
(7, 'VII'),
(8, 'VIII'),
(9, 'IX'),
(10, 'X'),
(50, 'L'),
(100, 'C'),
(500, 'D'),
(1000, 'M'),
(31, 'XXXI'),
(148, 'CXLVIII'),
(294, 'CCXCIV'),
(312, 'CCCXII'),
(421, 'CDXXI'),
(528, 'DXXVIII'),
(621, 'DCXXI'),
(782, 'DCCLXXXII'),
(870, 'DCCCLXX'),
(941, 'CMXLI'),
(1043, 'MXLIII'),
(1110, 'MCX'),
(1226, 'MCCXXVI'),
(1301, 'MCCCI'),
(1485, 'MCDLXXXV'),
(1509, 'MDIX'),
(1607, 'MDCVII'),
(1754, 'MDCCLIV'),
(1832, 'MDCCCXXXII'),
(1993, 'MCMXCIII'),
(2074, 'MMLXXIV'),
(2152, 'MMCLII'),
(2212, 'MMCCXII'),
(2343, 'MMCCCXLIII'),
(2499, 'MMCDXCIX'),
(2574, 'MMDLXXIV'),
(2646, 'MMDCXLVI'),
(2723, 'MMDCCXXIII'),
(2892, 'MMDCCCXCII'),
(2975, 'MMCMLXXV'),
(3051, 'MMMLI'),
(3185, 'MMMCLXXXV'),
(3250, 'MMMCCL'),
(3313, 'MMMCCCXIII'),
(3408, 'MMMCDVIII'),
(3501, 'MMMDI'),
(3610, 'MMMDCX'),
(3743, 'MMMDCCXLIII'),
(3844, 'MMMDCCCXLIV'),
(3888, 'MMMDCCCLXXXVIII'),
(3940, 'MMMCMXL'),
(3999, 'MMMCMXCIX'))
def test_to_roman_known_values(self):
"""to_roman should give known result with known input"""
for integer, numeral in self.known_values:
result = roman7.to_roman(integer)
self.assertEqual(numeral, result)
def test_from_roman_known_values(self):
"""from_roman should give known result with known input"""
for integer, numeral in self.known_values:
result = roman7.from_roman(numeral)
self.assertEqual(integer, result)
class ToRomanBadInput(unittest.TestCase):
def test_too_large(self):
"""to_roman should fail with large input"""
self.assertRaises(roman7.OutOfRangeError, roman7.to_roman, 4000)
def test_zero(self):
"""to_roman should fail with 0 input"""
self.assertRaises(roman7.OutOfRangeError, roman7.to_roman, 0)
def test_negative(self):
"""to_roman should fail with negative input"""
self.assertRaises(roman7.OutOfRangeError, roman7.to_roman, -1)
def test_non_integer(self):
"""to_roman should fail with non-integer input"""
self.assertRaises(roman7.NotIntegerError, roman7.to_roman, 0.5)
class FromRomanBadInput(unittest.TestCase):
def test_too_many_repeated_numerals(self):
"""from_roman should fail with too many repeated numerals"""
for s in ('MMMMM', 'DD', 'CCCC', 'LL', 'XXXX', 'VV', 'IIII'):
self.assertRaises(roman7.InvalidRomanNumeralError, roman7.from_roman, s)
def test_repeated_pairs(self):
"""from_roman should fail with repeated pairs of numerals"""
for s in ('CMCM', 'CDCD', 'XCXC', 'XLXL', 'IXIX', 'IVIV'):
self.assertRaises(roman7.InvalidRomanNumeralError, roman7.from_roman, s)
def test_malformed_antecedents(self):
"""from_roman should fail with malformed antecedents"""
for s in ('IIMXCC', 'VX', 'DCM', 'CMM', 'IXIV',
'MCMC', 'XCX', 'IVI', 'LM', 'LD', 'LC'):
self.assertRaises(roman7.InvalidRomanNumeralError, roman7.from_roman, s)
def test_blank(self):
"""from_roman should fail with blank string"""
self.assertRaises(roman7.InvalidRomanNumeralError, roman7.from_roman, "")
class SanityCheck(unittest.TestCase):
def testSanity(self):
"""from_roman(to_roman(n))==n for all n"""
for integer in range(1, 4000):
numeral = roman7.to_roman(integer)
result = roman7.from_roman(numeral)
self.assertEqual(integer, result)
if __name__ == "__main__":
unittest.main()
romantest8.py
+132
View File
@@ -0,0 +1,132 @@
"""Unit test for roman1.py
This program is part of "Dive Into Python 3", a free Python book for
experienced programmers. Visit http://diveintopython3.org/ for the
latest version.
"""
import roman8
import unittest
class KnownValues(unittest.TestCase):
known_values = ( (1, 'I'),
(2, 'II'),
(3, 'III'),
(4, 'IV'),
(5, 'V'),
(6, 'VI'),
(7, 'VII'),
(8, 'VIII'),
(9, 'IX'),
(10, 'X'),
(50, 'L'),
(100, 'C'),
(500, 'D'),
(1000, 'M'),
(31, 'XXXI'),
(148, 'CXLVIII'),
(294, 'CCXCIV'),
(312, 'CCCXII'),
(421, 'CDXXI'),
(528, 'DXXVIII'),
(621, 'DCXXI'),
(782, 'DCCLXXXII'),
(870, 'DCCCLXX'),
(941, 'CMXLI'),
(1043, 'MXLIII'),
(1110, 'MCX'),
(1226, 'MCCXXVI'),
(1301, 'MCCCI'),
(1485, 'MCDLXXXV'),
(1509, 'MDIX'),
(1607, 'MDCVII'),
(1754, 'MDCCLIV'),
(1832, 'MDCCCXXXII'),
(1993, 'MCMXCIII'),
(2074, 'MMLXXIV'),
(2152, 'MMCLII'),
(2212, 'MMCCXII'),
(2343, 'MMCCCXLIII'),
(2499, 'MMCDXCIX'),
(2574, 'MMDLXXIV'),
(2646, 'MMDCXLVI'),
(2723, 'MMDCCXXIII'),
(2892, 'MMDCCCXCII'),
(2975, 'MMCMLXXV'),
(3051, 'MMMLI'),
(3185, 'MMMCLXXXV'),
(3250, 'MMMCCL'),
(3313, 'MMMCCCXIII'),
(3408, 'MMMCDVIII'),
(3501, 'MMMDI'),
(3610, 'MMMDCX'),
(3743, 'MMMDCCXLIII'),
(3844, 'MMMDCCCXLIV'),
(3888, 'MMMDCCCLXXXVIII'),
(3940, 'MMMCMXL'),
(3999, 'MMMCMXCIX'))
def test_to_roman_known_values(self):
"""to_roman should give known result with known input"""
for integer, numeral in self.known_values:
result = roman8.to_roman(integer)
self.assertEqual(numeral, result)
def test_from_roman_known_values(self):
"""from_roman should give known result with known input"""
for integer, numeral in self.known_values:
result = roman8.from_roman(numeral)
self.assertEqual(integer, result)
class ToRomanBadInput(unittest.TestCase):
def test_too_large(self):
"""to_roman should fail with large input"""
self.assertRaises(roman8.OutOfRangeError, roman8.to_roman, 4000)
def test_zero(self):
"""to_roman should fail with 0 input"""
self.assertRaises(roman8.OutOfRangeError, roman8.to_roman, 0)
def test_negative(self):
"""to_roman should fail with negative input"""
self.assertRaises(roman8.OutOfRangeError, roman8.to_roman, -1)
def test_non_integer(self):
"""to_roman should fail with non-integer input"""
self.assertRaises(roman8.NotIntegerError, roman8.to_roman, 0.5)
class FromRomanBadInput(unittest.TestCase):
def test_too_many_repeated_numerals(self):
"""from_roman should fail with too many repeated numerals"""
for s in ('MMMMM', 'DD', 'CCCC', 'LL', 'XXXX', 'VV', 'IIII'):
self.assertRaises(roman8.InvalidRomanNumeralError, roman8.from_roman, s)
def test_repeated_pairs(self):
"""from_roman should fail with repeated pairs of numerals"""
for s in ('CMCM', 'CDCD', 'XCXC', 'XLXL', 'IXIX', 'IVIV'):
self.assertRaises(roman8.InvalidRomanNumeralError, roman8.from_roman, s)
def test_malformed_antecedents(self):
"""from_roman should fail with malformed antecedents"""
for s in ('IIMXCC', 'VX', 'DCM', 'CMM', 'IXIV',
'MCMC', 'XCX', 'IVI', 'LM', 'LD', 'LC'):
self.assertRaises(roman8.InvalidRomanNumeralError, roman8.from_roman, s)
def test_blank(self):
"""from_roman should fail with blank string"""
self.assertRaises(roman8.InvalidRomanNumeralError, roman8.from_roman, "")
def test_non_string(self):
"""from_roman should fail with non-string input"""
self.assertRaises(roman8.InvalidRomanNumeralError, roman8.from_roman, 1)
class SanityCheck(unittest.TestCase):
def testSanity(self):
"""from_roman(to_roman(n))==n for all n"""
for integer in range(1, 4000):
numeral = roman8.to_roman(integer)
result = roman8.from_roman(numeral)
self.assertEqual(integer, result)
if __name__ == "__main__":
unittest.main()