def test_K2F_exceptions(self):
print(TestConversions.test_K2F_exceptions.__name__)
print("Exception Tests: Raise typeError if int")
with self.assertRaises(TypeError) as context:
conversions.convertKelvinToFahrenheit(300)
print("Exception Tests: Raise typeError if str")
with self.assertRaises(TypeError) as context:
conversions.convertKelvinToFahrenheit('a')
print("\n")
def test_convertKelvinToFahrenheit_when_exception_raised(self):
print('test_convertKelvinToFahrenheit_when_exception_raised')
# :given
kelvin = 'someString'
# :when
with self.assertRaises(TypeError):
conversions.convertKelvinToFahrenheit(self, kelvin)
def test_convertKelvinToFahrenheit(self):
self.assertEqual(conversions.convertKelvinToFahrenheit(200), -99.67)
print("Test is Successful! 200K = -99.67F")
self.assertEqual(conversions.convertKelvinToFahrenheit(50), -369.67)
print("Test is Successful! 10K = -441.67F")
self.assertEqual(conversions.convertKelvinToFahrenheit(1000), 1340.33)
print("Test is Successful! 1000K = 1340.33F")
self.assertEqual(conversions.convertKelvinToFahrenheit(500), 440.33)
print("Test is Successful! 500K = 440.33F")
self.assertEqual(conversions.convertKelvinToFahrenheit(260), 8.33)
print("Test is Successful! 260K = 8.33F")
def test_K2F_good_values(self):
print(TestConversions.test_K2F_good_values.__name__)
print('Good Tests: 0.0 to -459.67')
result = conversions.convertKelvinToFahrenheit(0.0)
self.assertEqual(result, -459.67)
print('Good Tests: -10.0 to -477.67')
result = conversions.convertKelvinToFahrenheit(-10.0)
self.assertEqual(result, -477.67)
print('Good Tests: 300.0 to 80.32999999999998')
result = conversions.convertKelvinToFahrenheit(300.0)
self.assertEqual(result, 80.32999999999998)
def test_convertKelvinToFahrenheit(self):
self.assertEqual(conversions.convertKelvinToFahrenheit(200), -99.67)
print("Test passed! 200K is equal to -99.67F")
self.assertEqual(conversions.convertKelvinToFahrenheit(50), -369.67)
print("Test passed! 10K is equal to -441.67F")
self.assertEqual(conversions.convertKelvinToFahrenheit(1000), 1340.33)
print("Test passed! 1000K is equal to 1340.33F")
self.assertEqual(conversions.convertKelvinToFahrenheit(500), 440.33)
print("Test passed! 500K is equal to 440.33F")
self.assertEqual(conversions.convertKelvinToFahrenheit(260), 8.33)
print("Test passed! 260K is equal to 8.33F")
def testConvertKelvinToFahrenheit(self):
"""convertKelvinToFahrenheit should give known result with known
input.
"""
for kelvin, fahrenheit in self.knownKelvinToFahrenheitValues:
result = conversions.convertKelvinToFahrenheit(kelvin)
self.assertEqual(fahrenheit, result)
def testConvertKelvinToFahrenheit(self):
print "\nNow testing convertKelvinToFahrenheit function:"
for i in range(0,len(self.knownValues)):
result = conversions.convertKelvinToFahrenheit(self.knownValues[i][1]) # result of the conversion from kelvin to fahrenheit
fahrenheit = self.knownValues[i][2]
self.assertEqual(fahrenheit, result) # comparing if the values are equal
print " testing kelvin = %f; %f = %f; Passed" % (self.knownValues[i][1], fahrenheit, result)
def convert(fromUnit, toUnit, value):
"""Convert fromUnit value to toUnit."""
if fromUnit == 'Fahrenheit':
if toUnit == 'Celcius':
return float(conversions.convertFahrenheitToCelcius(value))
elif toUnit == 'Kelvin':
return float(conversions.convertFahrenheitToKelvin(value))
else:
raise ConversionError('{} cannot be converted to {}'.format(fromUnit, toUnit))
elif fromUnit == 'Celcius':
if toUnit == 'Fahrenheit':
return float(conversions.convertCelciusToFahrenheit(value))
elif toUnit == 'Kelvin':
return float(conversions.convertCelciusToKelvin(value))
else:
raise ConversionError('{} cannot be converted to {}'.format(fromUnit, toUnit))
elif fromUnit == 'Kelvin':
if toUnit == 'Fahrenheit':
return float(conversions.convertKelvinToFahrenheit(value))
elif toUnit == 'Celcius':
return float(conversions.convertKelvinToCelcius(value))
else:
raise ConversionNotPossible('Cannot perform conversions')
def test_kelvinToFahrenheit(self):
for x in self.test_temp:
fahrenheit = (x * 1.8) - 459.67
self.assertEqual(conversions.convertKelvinToFahrenheit(x),
fahrenheit) #compare equal
print(
'Temperature conversion kelvin to fahrenheit is %s K is %s F' %
(x, round(fahrenheit, 2)))
def testKelvintoFahrenheit(self):
"""kelvin/fahrenheit values should match"""
for i in range(len(self.kelvin)):
testedFahrenheit = conversions.convertKelvinToFahrenheit(
self.kelvin[i])
self.assertEqual(self.fahrenheit[i],testedFahrenheit,msg=
'{}F != {}F'.format(
testedFahrenheit,self.fahrenheit[i]))
def test_convertKelvinToFahrenheit(self):
"""
convertCelsiusToFahrenheit should give known results
with known input
"""
for celsius, fahrenheit, kelvin in self.known_values:
result = round(conversions.convertKelvinToFahrenheit(kelvin), 2)
self.assertEqual(fahrenheit, result)
def test_convertKelvinToFahrenheit(self):
kelvin = 300
expected = 80.33
actual = conversions.convertKelvinToFahrenheit(kelvin)
self.assertAlmostEqual(expected,
actual,
places=2,
msg=msg.format("Kelvin", "Fahrenheit"))
def test_kelvin_fahrenheit_table(self):
"""if true will give known result with known input, if false will give known give in backwards order"""
for kelvin, fahrenheit in self.k_to_f_known_values:
result = conversions.convertKelvinToFahrenheit(kelvin)
self.assertEqual(fahrenheit, result)
for kelvin, fahrenheit in self.k_to_f_known_values:
result = conversions.convertFahrenheitToKelvin(fahrenheit)
self.assertEqual(kelvin, result)
def testKtoF(self):
"""tests that convertKelvinToFahrenheit returns the correct values"""
print 'tests that convertKelvinToFahrenheit returns the correct values'
for integer, numeral in self.ktofvalues:
result = conversions.convertKelvinToFahrenheit(integer)
self.assertEqual(numeral,
result,
msg='Incorrect result, calculation error')
def test_convertKelvinToFahrenheit(self):
kelvin = 300
expected = 80.33
actual = conversions.convertKelvinToFahrenheit(kelvin)
self.assertAlmostEqual(expected,
actual,
places=2,
msg="Kelvin to Fahrenheit conversion failed")
def testConvertKelvinToFahrenheit(self):
print "\nNow testing convertKelvinToFahrenheit function:"
for i in range(0, len(self.knownValues)):
result = conversions.convertKelvinToFahrenheit(
self.knownValues[i][1])
fahrenheit = self.knownValues[i][2]
self.assertEqual(fahrenheit, result)
print " testing kelvin = %f; %f = %f; Passed" % (
self.knownValues[i][1], fahrenheit, result)
def testKelvinToFahrenheit(self):
for val in self.knownvals:
k = val[2]
f = val[1]
expect = conversions.convertKelvinToFahrenheit(k)
self.assertEqual(expect,
f,
msg=('{} degrees F '
' is not equal to {}'
' degrees F.').format(k, f))
def testKelvinToFahrenheit(self):
"""Unit test for converting degress Kelvin to degrees Fahrenheit."""
for deg in self.degrees:
kel = deg[2]
fah = deg[0]
expect = conversions.convertKelvinToFahrenheit(kel)
self.assertEqual(expect,
fah,
msg=('{} degrees Kelvin '
'is not equal to {}'
' degrees Fahrenheit.').format(kel, fah))
def testConvertKelvinToFahrenheit(self):
for val in self.valid_conversions:
from_val = val[2]
expected_val = val[1]
returned_val = conv.convertKelvinToFahrenheit(from_val)
self.assertEqual(
returned_val,
expected_val,
msg=
('{} Fahrenheit is not equal to expected value of {} Fahrenheit.'
).format(returned_val, expected_val))
def testKelvinToFahrenheit(self):
"""Tests that the convertKelvinToFahrenheit function returns the
correct value.
"""
for val in self.knownvals:
k = val[2]
f = val[1]
expect = conversions.convertKelvinToFahrenheit(k)
self.assertEqual(expect, f, msg=('{} degrees F '
' is not equal to {}'
' degrees F.').format(k, f))
def test_convertKelvinToFahrenheit_when_celsius_is_negative(self):
print('test_convertKelvinToFahrenheit_when_celsius_is_negative')
# :given
kelvin = -30
# :when
expected = -513.67
actual = conversions.convertKelvinToFahrenheit(self, kelvin)
# :then
self.assertEqual(expected, actual)
def test_convertKelvinToFahrenheit_when_fraction(self):
print('test_convertKelvinToFahrenheit_when_fraction')
# :given
kelvin = 33.21
# :when
expected = -399.89
actual = conversions.convertKelvinToFahrenheit(self, kelvin)
# :then
self.assertEqual(expected, actual)
def testConvertKelvinToFahrenheit(self):
print(
"\n\n\nNow testing the conversion from Kelvin to Fahrenheit using the function convertKelvinToFahrenheit() from conversions.py:\n"
)
for i in range(0, len(self.knownValues)):
conversion = conversions.convertKelvinToFahrenheit(
self.knownValues[i][2])
fahrenheit = self.knownValues[i][1]
self.assertEqual(fahrenheit, conversion)
print(
" Now testing whether {:.4f}{}K is equal to {:.4f}{}F; After testing, {:.4f}{}K is in fact {:.4f}{}F; This conversion has passed the test."
.format(self.knownValues[i][2], deg, fahrenheit, deg,
self.knownValues[i][2], deg, conversion, deg))
def test_convertKelvinToFahrenheit(self):
cases = {
-40: -531.67,
0: -459.67,
50: -369.67,
100: -279.67,
123: -238.27,
}
for input, output in cases.iteritems():
print "input (K):", input, "expected output (F):", output
self.assertAlmostEqual(convertKelvinToFahrenheit(input), output, 2)
self.assertAlmostEqual(convert("kelvin", "fahrenheit", input),
output, 2)
def test_convertKelvinToFahrenheit_when_celsius_is_positive(self):
print('test_convertKelvinToFahrenheit_when_celsius_is_positive')
# :given
kelvin = 18
# :when
expected = -427.27
actual = conversions.convertKelvinToFahrenheit(self, kelvin)
# :then
self.assertEqual(expected, actual)
def testConvertKelvinToFahrenheit(self):
"""Tests that convertKelvinToFahrenheit returns the expected value."""
for val in self.known_values:
from_val = val[2]
expected_val = val[1]
returned_val = c.convertKelvinToFahrenheit(from_val)
self.assertEqual(returned_val,
expected_val,
msg=(
'{}º Fahrenheit is not equal to expected value'
' of {}º Fahrenheit.') \
.format(returned_val, expected_val)
)
def testConvertKelvinToFahrenheit(self):
""" Tests Conversion between Kelvin to Fahrenheit
Args:
None
Returns:
Assertion
"""
print("\nTesting conversion from Kelvin to Fahrenheit.\n")
for kelvin, fahr in self.knownValuesKelvinToFahr:
print(('Testing {} conversion should be equal to {}').format(
kelvin, fahr))
result = conversions.convertKelvinToFahrenheit(kelvin)
print(('The result of the conversion: {}\n').format(result))
self.assertEqual(fahr, result)
def test_refactor_temp_conversion(self):
for x, y in self.conversion_list:
if x == 'celsius' and y == 'kelvin':
conversion_value = conversions.convertCelsiusToKelvin(
self.refactor_temp)
reconversion_value = conversions_refactored.convert(
'celsius', 'kelvin', self.refactor_temp)
self.assertEqual(conversion_value,
reconversion_value) # compare equal
elif x == 'celsius' and y == 'fahrenheit':
conversion_value = conversions.convertCelsiusToFahrenheit(
self.refactor_temp)
reconversion_value = conversions_refactored.convert(
'celsius', 'fahrenheit', self.refactor_temp)
self.assertEqual(conversion_value,
reconversion_value) # compare equal
elif x == 'fahrenheit' and y == 'celsius':
conversion_value = conversions.convertFahrenheitToCelsius(
self.refactor_temp)
reconversion_value = conversions_refactored.convert(
'fahrenheit', 'celsius', self.refactor_temp)
self.assertEqual(conversion_value,
reconversion_value) # compare !equal
elif x == 'fahrenheit' and y == 'kelvin':
conversion_value = conversions.convertFahrenheitToKelvin(
self.refactor_temp)
reconversion_value = conversions_refactored.convert(
'fahrenheit', 'kelvin', self.refactor_temp)
self.assertEqual(conversion_value,
reconversion_value) # compare equal
elif x == 'kelvin' and y == 'fahrenheit':
conversion_value = conversions.convertKelvinToFahrenheit(
self.refactor_temp)
reconversion_value = conversions_refactored.convert(
'kelvin', 'fahrenheit', self.refactor_temp)
self.assertEqual(conversion_value,
reconversion_value) # compare equal
elif x == 'kelvin' and y == 'celsius':
conversion_value = conversions.convertKelvinToCelsius(
self.refactor_temp)
reconversion_value = conversions_refactored.convert(
'kelvin', 'celsius', self.refactor_temp)
self.assertEqual(conversion_value,
reconversion_value) # compare equal
print('Temperature conversion %s to %s is %s %s is %s %s' %
(x, y, self.refactor_temp, x[0].upper(),
round(reconversion_value, 2), y[0].upper()))
def test_to_all(self):
for C, K in self.known_values_C_K:
result = conversions.convertCelsiusToKelvin(C)
self.assertAlmostEqual(K, result)
print('The temperature {0} in Celius is {1} in Kelvim'.format(
C, result))
for C, F in self.known_values_C_F:
result = conversions.convertCelsiusToFahrenheit(C)
self.assertAlmostEqual(F, result)
print('The temperature {0} in Celius is {1} in Fahrenheit'.format(
C, result))
for F, C in self.known_values_F_C:
result = conversions.convertFahrenheitToCelsius(F)
self.assertAlmostEqual(C, result)
print('The temperature {0} in Fahrenheit is {1} in Celsius'.format(
F, result))
for F, K in self.known_values_F_K:
result = conversions.convertFahrenheitToKelvin(F)
self.assertAlmostEqual(K, result)
print('The temperature {0} in Fahrenheit is {1} in Kelvin '.format(
F, result))
for K, F in self.known_values_K_F:
result = conversions.convertKelvinToFahrenheit(K)
self.assertAlmostEqual(F, result)
print('The temperature {0} in Kelvin is {1} in Fahrenheit '.format(
K, result))
for K, C in self.known_values_K_C:
result = conversions.convertKelvinToCelsius(K)
self.assertAlmostEqual(C, result)
print('The temperature {0} in Kelvin is {1} in Celsius '.format(
K, result))
def testKelvinToFahrenheit_largeNumber(self): result = conversions.convertKelvinToFahrenheit(4222238.00) self.assertEqual(7599568.73, result)
def testKelvinToFahrenheit_negativeValues(self): result = conversions.convertKelvinToFahrenheit(-30.35) self.assertEqual(-514.3, result)
def testKelvinToFahrenheit_decimalValues(self): result = conversions.convertKelvinToFahrenheit(305.35) self.assertEqual(89.96, result)
def zeroBasedValue_testing(self):
self.assertEqual(convertKelvinToFahrenheit(0.0), 273.15)
def negative_value_testing(self):
self.assertEqual(convertKelvinToFahrenheit(-200.0), 173.15)
def testConvertKelvinToFahrenheit(self):
for celsius, kelvin, fahr in self.knownValuesCKF:
print 'checking convertKelvinToFahrenheit', kelvin
result = conv.convertKelvinToFahrenheit(kelvin)
self.assertEqual(fahr, result)
def testKelvintoFahrenheit(self):
for i in range(len(self.kel)):
fahr = conversions.convertKelvinToFahrenheit(
self.kel[i])
self.assertEqual(self.fah[i],fahr,msg='{}F != {}F'.format(fahr,self.fah[i]))
def positiveValue_testing(self):
self.assertEqual(convertKelvinToFahrenheit(300.0), 573.15)
def test_large(self):
"Test for large input."
results = conversions.convertKelvinToFahrenheit(567890)
self.assertEqual(1021742.33, results)
def test_non_whole_num(self):
"Test for non-whole input."
results = conversions.convertKelvinToFahrenheit(1.005)
self.assertEquals(-457.861, results)
def big_value_testing(self):
self.assertEqual(convertKelvinToFahrenheit(937538), 937938.15)
def testKelvinToFahrenheit_zeroKelvin(self): result = conversions.convertKelvinToFahrenheit(0.00) self.assertEqual(-459.67, result)
def testKelvinToFahrenheit_default(self): result = conversions.convertKelvinToFahrenheit(300.00) self.assertEqual(80.33, result)
def test_pos(self):
"Test for positive input."
results = conversions.convertKelvinToFahrenheit(300)
self.assertEqual(80.33, results)
def test_neg(self):
"Test for negative input."
results = conversions.convertKelvinToFahrenheit(-300)
self.assertEqual(-999.67, results)
def decimal_value_testing(self):
self.assertEqual(convertKelvinToFahrenheit(200.22), 373.37)
def testFromKevintoFahrenheitPositive(self):
print("Checks if 503.15k produces 446.00F")
self.assertAlmostEqual(446.00,
conversions.convertKelvinToFahrenheit(503.15),
places=2)
def test_zero(self):
"Test for zero input."
results = conversions.convertKelvinToFahrenheit(0)
self.assertEqual(-459.67, results)
