Esempio n. 1
0
    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))
Esempio n. 2
0
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)
Esempio n. 3
0
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)
Esempio n. 4
0
 def setUp(self):
     self.temp = Roman()
Esempio n. 5
0
def test_incorrect_integers():
    """Zero and negative integers are not supported."""
    for number in incorrect_integers:
        with pytest.raises(ValueError):
            Roman(number)
Esempio n. 6
0
 def test_equal(self):
     for i in range(1, 2000):
         self.assertEqual(str(Roman(i)), text[i])  # Здесь, по сути,
Esempio n. 7
0
 def test_false(self):
     self.assertFalse(Roman(5) == Roman(6))
Esempio n. 8
0
def test_inversion():
    for i in range(1, 4000):
        assert int(Roman(i)) == i
Esempio n. 9
0
def test_mult():
    assert Roman("I") == Roman("I") * Roman("I")
    assert Roman("IV") == Roman("II") * Roman("II")
    assert Roman("IX") == Roman("III") * Roman("III")
Esempio n. 10
0
 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))
Esempio n. 11
0
 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))
Esempio n. 12
0
 def setUp(self):
     self.roman = Roman()
Esempio n. 13
0
def test_roman_init():
    assert Roman(5) == 'V'
    assert Roman('IV') == 'IV'
    assert Roman('MCMXL') + Roman('I') == Roman('MCMXLI')
Esempio n. 14
0
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")
Esempio n. 15
0
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"
Esempio n. 16
0
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
Esempio n. 17
0
def test_from_integer():
    """Roman(integer) makes a correct numeral."""
    for numeral, value in known_numerals:
        assert str(Roman(value)) == numeral
Esempio n. 18
0
def test_not_eq():
    assert Roman(1) != Roman(2)
Esempio n. 19
0
def test_to_integer():
    """Roman(numeral) converts to the right integer."""
    for numeral, value in known_numerals:
        assert int(Roman(numeral)) == value
Esempio n. 20
0
def test_sub():
    assert Roman(3987) - Roman(18) == Roman(3969)
Esempio n. 21
0
def test_eq():
    for i in range(1, 4000):
        assert Roman(i) == Roman(i)
Esempio n. 22
0
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
Esempio n. 23
0
def test_add():
    assert Roman(3987) + Roman(12) == Roman(3999)
Esempio n. 24
0
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
Esempio n. 25
0
def test_mul():
    assert Roman(19) * Roman(12) == Roman(228)
def roman():
    return Roman()
Esempio n. 27
0
 def test_true(self):
     self.assertTrue(Roman(5) == Roman(5))
Esempio n. 28
0
def test_correct_numerals():
    """is_roman_numeral should return True for correct roman numerals."""
    for numeral in correct_numerals:
        assert numeral == str(Roman(numeral))
Esempio n. 29
0
 def test_errors(self):
     self.assertRaises(ValueError, Roman, -1)
     with self.assertRaises(ValueError):
         a = Roman(1000) + Roman(1000)
Esempio n. 30
0
#!/usr/bin/env python3
"""
Import packages
"""
import sys
from roman import Roman

if __name__ == '__main__':

    try:
        # parameter required
        if len(sys.argv) <= 1:
            print("Integer number required")
        else:
            print(Roman().num_roman(int(sys.argv[1])))
    except Exception as e:
        print('Non integers can not be converted')