def test_convert_base(self):
convert_result = maths.convert_base(10, 8)
self.assertEqual(12, convert_result,
"convert_base function base under ten is wrong")
big_result = maths.convert_base(27, 16)
self.assertEqual("1B", big_result,
"convert_base function base pass over ten is wrong")
def test_convert_base(self):
#arrange
c = maths.convert_base(32, 2)
d = maths.convert_base(32, 16)
#assert
self.assertEqual(int(c), 100000)
self.assertEqual(int(d), 20)
def test_convert_base(self):
''' Tests the convert_base function. '''
t1 = maths.convert_base(10, 2)
t2 = maths.convert_base(10, 15)
self.assertEqual(t1,'1010')
self.assertEqual(t2,'A')
def test_convert_base(self):
'''Tests the convert base function '''
result1 = maths.convert_base(9, 2)
self.assertEqual(result1, '1001')
result2 = maths.convert_base(11, 16)
self.assertEqual(result2, 'B')
def test_convert_base(self):
#Arrange
num = 8
n = 2
num2 = 65535
n2 = 16
#Act
act = maths.convert_base(num, n)
act2 = maths.convert_base(num2, n2)
#Assert
self.assertEqual(act, "1000")
self.assertEqual(act2, "FFFF")
def test_convert_base(self):
'''Tests the convert_base function. '''
# Tests converting to base 15, and base 2
# Arrange
numbers = [10,20,50,100,500]
resultsb15 = ['A', '15', '35', '6A', '235']
resultsb2 = ['1010', '10100', '110010', '1100100', '111110100']
# Action, and Assert
for i in range(len(numbers)):
base15num = maths.convert_base(numbers[i], 15)
base2num = maths.convert_base(numbers[i], 2)
self.assertEqual(base15num, resultsb15[i])
self.assertEqual(base2num, resultsb2[i])
def test_convert_base(self):
#Arrange
base_under_ten = 3
base_over_ten = 12
#Act
result1 = maths.convert_base(5, base_under_ten) #should be 12
result2 = maths.convert_base(25, base_over_ten) #should be 21
#Assert
self.assertEqual(result1, '12')
self.assertEqual(result2, '21')
def test_convert_base_under10(self):
#Arrange
#Act
value = maths.convert_base(38, 8)
#Assert
self.assertEqual(46, int(value))
def test_convert_base_over10(self):
#Arrange
#Act
value = maths.convert_base(38, 12)
#Assert
self.assertEqual(32, int(value))
def test_convert_base_under_base_10(self):
''' Tests the maths.convert_base function with a base under 10 '''
result = maths.convert_base(15, 2)
self.assertEqual(
1111, result,
"maths.convert_base did not return the expected result for a conversion to a base under 10"
)
def test_convert_base_over_base_10(self):
''' Tests the mats.convert_base function with a base over 10 '''
result = maths.convert_base(31, 16)
self.assertEqual(
"1F", result,
"maths.convert_base did not return the expected result for a conversion to a base over 10"
)
def test_convert_base_high(self):
'''Test the convert base function for a base over 10'''
#act
result = maths.convert_base(15, 12)
#assert
self.assertEqual(
result, '13',
"The convert_base function returned the incorrect value!")
def test_convert_base_low(self):
'''Test the convert base function for a base less than 10'''
#act
result = maths.convert_base(15, 5)
#assert
self.assertEqual(
result, '30',
"The convert_base function returned the incorrect value!")
def test_convert_base_over_10(self):
""" Tests the convert base function using base 16 """
number = 15
base = 16
self.conversion = maths.convert_base(number, base)
self.assertEqual(self.conversion, 'F', "Expects hexadecimal F")
def test_convert_base_under_10(self):
""" Tests the convert base function using base 2 """
number = 10
base = 2
self.conversion = maths.convert_base(number, base)
self.assertEqual(self.conversion, '1010', "Expects binary 1010")
def test_convert_base_over_ten(self):
''' Tests the convert_base function with base over 10 '''
# Arrange & Act
result = maths.convert_base(23, 13)
# Assert
self.assertEqual(
result, '1A',
"The convert_base function returned an incorrect value.")
def test_convert_base(self):
# Arrange
hexadecimal = maths.convert_base(10, 16)
octal = maths.convert_base(10, 8)
binary = maths.convert_base(10, 2)
# Act
print('\n\n Convert Base function \n',
'=' * 60,
'\n',
'Convert Base function - Hexadecimal test result: ',
hexadecimal,
'\n',
'Convert Base function - Octal test result: ',
octal,
'\n',
'Convert Base function - Binary test result: ',
binary,
'\n',
'=' * 60,
sep='')
# Assert
self.assertEqual(hexadecimal, 'A', msg=error_message)
self.assertEqual(octal, '12', msg=error_message)
self.assertEqual(binary, '1010', msg=error_message)
def test_factorial(self):
# Arrange
fac_1 = factorial(1)
fac_3 = factorial(3)
fac_5 = factorial(5)
# Act
# Assert
self.assertEqual(fac_1, 1)
self.assertEqual(fac_3, 6)
self.assertEqual(fac_5, 120)
def test_convert_base_over_10(self):
''' Tests the convert_base function for results over 10. '''
# Arrange
d = maths.convert_base(100, 89)
# Act
# Assert
self.assertEqual(d, 'B')
def test_convert_base(self):
''' Tests the convert_base function >= 10 '''
#Arrange
num1 = 10
num2 = 16
#Act
self.base1 = maths.convert_base(num1, num2)
#Assert
self.assertEqual("A", self.base1, "Expects A")
''' Tests the convert_base function < 10. '''
#Arrange
num3 = 8
num4 = 2
#Act
self.base2 = maths.convert_base(num3, num4)
#Assert
self.assertEqual("1000", self.base2, "Expects 1000")
def test_convert_base_under_10(self):
''' Tests the convert_base function for results under 10. '''
# Arrange
c = maths.convert_base(100, 49)
# Act
# Assert
self.assertEqual(c, '2')
def test_add_convert(self):
''' Tests the convert_base of the add function. '''
# Arrange
a = maths.add(1, 2, 1)
# Act
b = maths.convert_base(3, 1)
# Assert
self.assertEqual(a, b)
def test_convert_base_over10(self):
num = 15
n = 16
conv_b = maths.convert_base(num, n)
#Change result to suit question
if conv_b == str(hex(num)[2:].upper()):
pass
else:
self.fail('Failed to convert')
def test_convert_base_under10(self):
num = 15
n = 8
conv_b = maths.convert_base(num, n)
if conv_b == str(oct(num)[2:]):
pass
else:
self.fail('Failed to convert')
def test_add_base_over10(self):
first = 2
second = 6
n = 16
add = maths.add(first, second, n)
if add == maths.convert_base(first + second, n):
pass
else:
self.fail('test failed')
def test_convert_base2(self):
#Arrange
num = 15
n = 16
#Act
result = maths.convert_base(num, n)
#Assert
self.assertEqual(result,'F')
def test_conv0(self):
''' Tests the convert_base function. '''
#Arrange
num = 10
n = 5
c = maths.convert_base(num, n)
#Act
#Assert
self.assertEqual(c, "20")
print("convert_base test 0 finish")
pass # TODO
def test_conv1(self):
''' Tests the convert_base function. '''
#Arrange
num = 15
n = 16
c = maths.convert_base(num, n)
#Act
#Assert
self.assertEqual(c, "F")
print("convert_base test 1 finish")
pass # TODO
def test_convert_base_over_16(self):
''' Tests the convert_base function for base 16. '''
#Arrange
number = 10
base = 16
expected = 'A'
#Act
result = maths.convert_base(number, base)
#Assert
self.assertEqual(result, expected)
def test_convert_base_8(self):
''' Tests the convert_base function for base 8. '''
#Arrange
number = 10
base = 8
expected = '12'
#Act
result = maths.convert_base(number, base)
#Assert
self.assertEqual(result, expected)
def test_convert_base(self):
self.assertEqual(int(maths.convert_base(17, 7)), 23,
"Under base 10 test failed")
self.assertEqual(int(maths.convert_base(17, 16)), 11,
"Over base 10 test failed")
