def test_incorrect_numerals(): """is_roman_numeral should return False for strings that are not roman numerals.""" for numeral in incorrect_numerals: assert Roman.is_roman_numeral(numeral) == False with pytest.raises(ValueError): Roman(numeral)
def test_bad_type(): """is_roman_numeral should raise TypeError for non-string arguments""" for numeral in (None, 0, 1, 1.0): with pytest.raises(TypeError): Roman.is_roman_numeral(numeral) for obj in (None, 1.0): with pytest.raises(TypeError): Roman(numeral)
class RomanTests(unittest.TestCase): def setUp(self): self.roman = Roman() def test_input_1_should_return_I(self): result = self.roman.convert(1) self.assertEqual(result, 'I') def test_input_2_should_return_II(self): result = self.roman.convert(2) self.assertEqual(result, 'II') def test_input_3_should_return_III(self): result = self.roman.convert(3) self.assertEqual(result, 'III') def test_input_4_should_return_IV(self): result = self.roman.convert(4) self.assertEqual(result, 'IV') def test_input_5_should_return_V(self): result = self.roman.convert(5) self.assertEqual(result, 'V') def test_input_6_should_return_VI(self): result = self.roman.convert(6) self.assertEqual(result, 'VI') def test_input_7_should_return_VII(self): result = self.roman.convert(7) self.assertEqual(result, 'VII') def test_input_8_should_return_VIII(self): result = self.roman.convert(8) self.assertEqual(result, 'VIII') def test_input_9_should_return_IX(self): result = self.roman.convert(9) self.assertEqual(result, 'IX') def test_input_10_should_return_X(self): result = self.roman.convert(10) self.assertEqual(result, 'X')
def test_exceptions(self): ancient = 'The ancient Romans did not recognize 0 as a number neither did they include negative numbers' try: _ = Roman.convert_to_roman(0) self.fail('Should get an exception for non-positive values') except ValueError as ex: self.assertEqual(ancient, str(ex)) try: _ = Roman.convert_to_roman(-22) self.fail('Should get an exception for non-positive values') except ValueError as ex: self.assertEqual(ancient, str(ex)) try: _ = Roman.convert_to_decimal('T') # T unknown self.fail('Should get an exception for unrecognized characters') except ValueError as ex: self.assertEqual('Not found', str(ex)) try: _ = Roman.convert_to_decimal( 'IIII') # III is 3 and cannot be followed by anything self.fail('Should get an exception for unrecognized characters') except ValueError as ex: self.assertEqual('Wrong level', str(ex)) try: # not following the convention - XX is 20 and cannot be followed by 50 _ = Roman.convert_to_decimal('XXL') self.fail('Should get an exception for unrecognized characters') except ValueError as ex: self.assertEqual('Wrong level', str(ex)) try: _ = Roman.convert_to_decimal( 'MMCCXXC') # 2220 cannot be followed by 100 self.fail('Should get an exception for unrecognized characters') except ValueError as ex: self.assertEqual('Wrong level', str(ex)) try: _ = Roman.convert_to_decimal( 'I^' ) # with the current convention I can never be followed by a ^ self.fail('Should get an exception for unrecognized characters') except ValueError as ex: self.assertEqual('Not found', str(ex)) try: _ = Roman.convert_to_decimal('V^MMMDCCCLXXXVIIIR') # R unknown self.fail('Should get an exception for unrecognized characters') except ValueError as ex: self.assertEqual('Not found', str(ex))
def test_adding_x_to_x(self): """ Test adding 10 + 10 """ numeral_a = Roman('x') numeral_b = Roman('x') self.assertEqual('xx', numeral_a.add(numeral_b)) self.assertEqual('xx', numeral_b.add(numeral_a))
class TestRoman(unittest.TestCase): def setUp(self): self.roman = Roman() def tearDown(self): pass def test_get_value_by_symbol(self): self.assertEqual(self.roman.get_value_by_symbol("I"), 1) self.assertEqual(self.roman.get_value_by_symbol("V"), 5) self.assertEqual(self.roman.get_value_by_symbol("X"), 10) self.assertEqual(self.roman.get_value_by_symbol("L"), 50) self.assertEqual(self.roman.get_value_by_symbol("C"), 100) self.assertEqual(self.roman.get_value_by_symbol("D"), 500) self.assertEqual(self.roman.get_value_by_symbol("M"), 1000) def test_roman_to_arabic(self): self.assertEqual(self.roman.roman_to_arabic('II'), 2) self.assertEqual(self.roman.roman_to_arabic('MCMIII'), 1903) with self.assertRaises(InvalidSyntaxException): self.roman.roman_to_arabic("IIII")
def test_4000_handled_gracefully(self): number = Roman('4000') self.assertFalse(number.is_within_bounds()) self.assertFalse(number.is_valid) self.assertEquals(number.invalid_reason, '4000 is out of bounds.')
def test_number_of_digits_in_9999(self): number = Roman(9999) self.assertEquals(number.number_of_digits(), 4)
def test_equal(self): for i in range(1, 2000): self.assertEqual(str(Roman(i)), text[i]) # ΠΠ΄Π΅ΡΡ, ΠΏΠΎ ΡΡΡΠΈ,
def test_false(self): self.assertFalse(Roman(5) == Roman(6))
def test_incorrect_integers(): """Zero and negative integers are not supported.""" for number in incorrect_integers: with pytest.raises(ValueError): Roman(number)
class TestRomanToArabic(unittest.TestCase): def setUp(self): self.r = Roman() ''' Aide-memoire ------------ I 1 (one) (unus) V 5 (five) (quinque) X 10 (ten) (decem) L 50 (fifty) (quinquaginta) C 100 (one hundred) (centum) D 500 (five hundred) (quingenti) M 1000 (one thousand) (mille) ''' def test_IVXLCDM(self): ''' Test all uppercase digits in one test for brevity. ''' for numeral, decimal in [('I', 1), ('V', 5), ('X', 10), ('L', 50), ('C', 100), ('D', 500), ('M', 1000)]: number = Roman(numeral) self.assertEquals(number.decimal, decimal) def test_lowercase_digits(self): ''' Test all uppercase digits in one test for brevity. ''' for numeral, decimal in [('i', 1), ('v', 5), ('x', 10), ('l', 50), ('c', 100), ('d', 500), ('m', 1000)]: number = Roman(numeral) self.assertEquals(number.decimal, decimal) number = Roman('x') self.assertEquals(number.decimal, 10) def test_two_ones_make_two(self): number = Roman('II') self.assertEquals(number.decimal, 2) def test_iv_equals_four(self): number = Roman('iv') self.assertEquals(number.decimal, 4) def test_i_before_v_worth_minus_one(self): value = self.r.get_roman_value('i', 'v') self.assertEquals(value, -1) def test_i_on_its_own_worth_one(self): value = self.r.get_roman_value('i', None) self.assertEquals(value, 1) def test_v_before_i_worth_five(self): value = self.r.get_roman_value('v', 'i') self.assertEquals(value, 5) def test_iiii_also_equals_four(self): number = Roman('iiii') self.assertEquals(number.decimal, 4) def test_four_cs_1925(self): number = Roman('MDCCCCXXV') self.assertEquals(number.decimal, 1925) def test_subtractive_1925(self): number = Roman('MCMXXV') self.assertEquals(number.decimal, 1925) def test_ic_violates_subtractive_principle(self): ''' "The subtractive principle of the IX, XC, and CM in these examples is that a numeral for 10^n may not precede a numeral larger than 10^n+1, where n is an integer." --Wikipedia, Roman numerals <http://en.wikipedia.org/wiki/Roman_numerals> ''' self.assertTrue(self.r.violates_subtractive_principle('I', 'C')) def test_ix_does_not_violate_subtractive_principle(self): self.assertFalse(self.r.violates_subtractive_principle('I', 'X')) def test_m_does_not_violate_subtractive_principle(self): self.assertFalse(self.r.violates_subtractive_principle('M', None)) def test_violation_of_subtractive_principle_raises_exception(self): self.assertRaises(Exception, self.r.get_roman_value, 'i', 'm') def test_mim_not_valid(self): number = Roman('MIM') self.assertFalse(number.is_valid) self.assertEqual(number.invalid_reason, 'I before M violates the subtractive principle.') def test_MCMXCIX_valid(self): number = Roman('MCMXCIX') self.assertTrue(number.is_valid) self.assertEquals(number.invalid_reason, None) def test_vx_violates_subtractive_principle(self): ''' "The numerals 5*10^n (V, L, D) may not precede a larger numeral at all" --Wikipedia, Roman numerals <http://en.wikipedia.org/wiki/Roman_numerals> ''' self.assertTrue(self.r.violates_subtractive_principle('V', 'X')) def test_vv_invalid(self): number = Roman('VV') self.assertFalse(number.is_valid) self.assertEquals(number.invalid_reason, 'Cannot have two consecutive Vs.') def test_no_two_fives(self): self.assertTrue(self.r.two_consecutive_fives('L', 'L'))
def test_from_integer(): """Roman(integer) makes a correct numeral.""" for numeral, value in known_numerals: assert str(Roman(value)) == numeral
def test_correct_numerals(): """is_roman_numeral should return True for correct roman numerals.""" for numeral in correct_numerals: assert numeral == str(Roman(numeral))
def test_numeric(): assert 1 == Roman("I").numeric assert 2 == Roman("II").numeric assert 3 == Roman("III").numeric assert 4 == Roman("IV").numeric assert 5 == Roman("V").numeric assert 6 == Roman("VI").numeric assert 7 == Roman("VII").numeric assert 8 == Roman("VIII").numeric assert 9 == Roman("IX").numeric assert 10 == Roman("X").numeric assert 11 == Roman("XI").numeric assert 12 == Roman("XII").numeric assert 13 == Roman("XIII").numeric assert 14 == Roman("XIV").numeric assert 15 == Roman("XV").numeric assert 16 == Roman("XVI").numeric assert 17 == Roman("XVII").numeric assert 18 == Roman("XVIII").numeric assert 19 == Roman("XIX").numeric assert 20 == Roman("XX").numeric assert 30 == Roman("XXX").numeric assert 40 == Roman("XL").numeric assert 50 == Roman("L").numeric assert 60 == Roman("LX").numeric assert 70 == Roman("LXX").numeric assert 80 == Roman("LXXX").numeric assert 90 == Roman("XC").numeric assert 100 == Roman("C").numeric assert 101 == Roman("CI").numeric assert 105 == Roman("CV").numeric assert 110 == Roman("CX").numeric assert 150 == Roman("CL").numeric assert 200 == Roman("CC").numeric assert 300 == Roman("CCC").numeric assert 400 == Roman("CD").numeric assert 500 == Roman("D").numeric assert 600 == Roman("DC").numeric assert 700 == Roman("DCC").numeric assert 800 == Roman("DCCC").numeric assert 900 == Roman("CM").numeric assert 1000 == Roman("M").numeric assert 2000 == Roman("MM").numeric assert 2019 == Roman("MMXIX").numeric
def test_roman(): assert Roman(1).roman == "I" assert Roman(2).roman == "II" assert Roman(3).roman == "III" assert Roman(4).roman == "IV" assert Roman(5).roman == "V" assert Roman(6).roman == "VI" assert Roman(7).roman == "VII" assert Roman(8).roman == "VIII" assert Roman(9).roman == "IX" assert Roman(10).roman == "X" assert Roman(11).roman == "XI" assert Roman(12).roman == "XII" assert Roman(13).roman == "XIII" assert Roman(14).roman == "XIV" assert Roman(15).roman == "XV" assert Roman(16).roman == "XVI" assert Roman(17).roman == "XVII" assert Roman(18).roman == "XVIII" assert Roman(19).roman == "XIX" assert Roman(20).roman == "XX" assert Roman(30).roman == "XXX" assert Roman(40).roman == "XL" assert Roman(50).roman == "L" assert Roman(60).roman == "LX" assert Roman(70).roman == "LXX" assert Roman(80).roman == "LXXX" assert Roman(90).roman == "XC" assert Roman(100).roman == "C" assert Roman(101).roman == "CI" assert Roman(105).roman == "CV" assert Roman(110).roman == "CX" assert Roman(150).roman == "CL" assert Roman(200).roman == "CC" assert Roman(300).roman == "CCC" assert Roman(400).roman == "CD" assert Roman(500).roman == "D" assert Roman(600).roman == "DC" assert Roman(700).roman == "DCC" assert Roman(800).roman == "DCCC" assert Roman(900).roman == "CM" assert Roman(1000).roman == "M" assert Roman(2000).roman == "MM" assert Roman(2019).roman == "MMXIX"
def test_mult(): assert Roman("I") == Roman("I") * Roman("I") assert Roman("IV") == Roman("II") * Roman("II") assert Roman("IX") == Roman("III") * Roman("III")
def test_mult_int(): assert Roman("I") == Roman("I") * 1 assert Roman("IV") == Roman("II") * 2 assert Roman("IV") == 2 * Roman("II") assert Roman("IX") == Roman("III") * 3
def setUp(self): self.roman = Roman()
from roman import Roman if __name__ == "__main__": r1 = Roman("X") r2 = Roman(5) print(" Π§ΠΈΡΠ»Π°:", r1, r2, r1.arabic, r2.arabic) print(" Π‘ΡΠΌΠΌΠ°:", r1 + r2) print(" Π Π°Π·Π½ΠΎΡΡΡ:", r1 - r2) print("ΠΡΠΎΠΈΠ·Π²Π΅Π΄Π΅Π½ΠΈΠ΅:", r1 * r2) print(" Π§Π°ΡΡΠ½ΠΎΠ΅:", r1 // r2) print("\nΠΡΠ΅ΠΎΠ±ΡΠ°Π·ΠΎΠ²Π°Π½ΠΈΠ΅ Π±Π΅Π· ΡΠΎΠ·Π΄Π°Π½ΠΈΡ ΠΎΠ±ΡΠ΅ΠΊΡΠ°:") print(2016, "=", Roman.to_roman(2016)) print("MMXVI", "=", Roman.to_arabic("MMXVI")) # ------------- # ΠΡΠΈΠΌΠ΅Ρ Π²ΡΠ²ΠΎΠ΄Π°: # Π§ΠΈΡΠ»Π°: X V 10 5 # Π‘ΡΠΌΠΌΠ°: XV # Π Π°Π·Π½ΠΎΡΡΡ: V # ΠΡΠΎΠΈΠ·Π²Π΅Π΄Π΅Π½ΠΈΠ΅: L # Π§Π°ΡΡΠ½ΠΎΠ΅: II # # ΠΡΠ΅ΠΎΠ±ΡΠ°Π·ΠΎΠ²Π°Π½ΠΈΠ΅ Π±Π΅Π· ΡΠΎΠ·Π΄Π°Π½ΠΈΡ ΠΎΠ±ΡΠ΅ΠΊΡΠ°: # 2016 = MMXVI # MMXVI = 2016
def test_inversion(): for i in range(1, 4000): assert int(Roman(i)) == i
def roman(): return Roman()
def test_not_eq(): assert Roman(1) != Roman(2)
def test_number_of_digits_in_1(self): number = Roman(1) self.assertEquals(number.number_of_digits(), 1)
def test_sub(): assert Roman(3987) - Roman(18) == Roman(3969)
def test_add(): assert Roman("II") == Roman("I") + Roman("I") assert Roman("IV") == Roman("II") + Roman("II") assert Roman("V") == Roman("III") + Roman("II") assert Roman("V") == Roman("II") + Roman("III") assert Roman("M") == Roman("D") + Roman("D")
def setUp(self): self.r = Roman()
def test_to_integer(): """Roman(numeral) converts to the right integer.""" for numeral, value in known_numerals: assert int(Roman(numeral)) == value
def setUp(self): self.roman = Roman()
def test_eq(): for i in range(1, 4000): assert Roman(i) == Roman(i)
def test_roman(self): self.assertEqual(Roman.I, 1) self.assertEqual(Roman.III, 3) self.assertEqual(Roman.IV, 4) self.assertEqual(Roman.V, 5) self.assertEqual(Roman.VI, 6) self.assertEqual(Roman.IX, 9) self.assertEqual(Roman.XXIV, 24) self.assertEqual(Roman.XXXI, 31) self.assertEqual(Roman.CCCLXIX, 369) self.assertEqual(Roman.CD, 400) self.assertEqual(Roman.CDXLVIII, 448) self.assertEqual(Roman.to_roman(1), 'I') self.assertEqual(Roman.to_roman(3), 'III') self.assertEqual(Roman.to_roman(4) , 'IV') self.assertEqual(Roman.to_roman(5), 'V') self.assertEqual(Roman.to_roman(6), 'VI') self.assertEqual(Roman.to_roman(9), 'IX') self.assertEqual(Roman.to_roman(24), 'XXIV') self.assertEqual(Roman.to_roman(31), 'XXXI') self.assertEqual(Roman.to_roman(369), 'CCCLXIX') self.assertEqual(Roman.to_roman(400), 'CD') self.assertEqual(Roman.to_roman(448), 'CDXLVIII')
def test_add(): assert Roman(3987) + Roman(12) == Roman(3999)
def test_roman_init(): assert Roman(5) == 'V' assert Roman('IV') == 'IV' assert Roman('MCMXL') + Roman('I') == Roman('MCMXLI')
def test_mul(): assert Roman(19) * Roman(12) == Roman(228)
def test_adding_xi_to_vi(self): """ Test adding 11 + 6 """ numeral_a = Roman('xi') numeral_b = Roman('vi') self.assertEqual('xvii', numeral_a.add(numeral_b)) self.assertEqual('xvii', numeral_b.add(numeral_a))
def test_true(self): self.assertTrue(Roman(5) == Roman(5))
def test_adding_l_to_i(self): """ Test adding 50 + 1 """ numeral_a = Roman('l') numeral_b = Roman('i') self.assertEqual('li', numeral_a.add(numeral_b)) self.assertEqual('li', numeral_b.add(numeral_a))
def test_errors(self): self.assertRaises(ValueError, Roman, -1) with self.assertRaises(ValueError): a = Roman(1000) + Roman(1000)
from roman import Roman sum = 0 with open('p089_roman.txt', 'r') as file: for line in file: line = line.strip() print(line) roman = Roman(line) print('Decimal: ', roman.to_decimal()) minimal = Roman(Roman(line).to_decimal()).to_str() print('Minimal: ' + minimal) saved = len(line) - len(minimal) print('Saved: ', saved) print() sum += saved print('Answer:', sum)