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")