def double_initialize_test(self):
"""Test for the error ocuring when the same error measure is initialized twice."""
data = [[0.0, 0.0], [1, 0.1], [2, 0.2], [3, 0.3], [4, 0.4]]
tsOrg = TimeSeries.from_twodim_list(data)
tsCalc = TimeSeries.from_twodim_list(data)
bem = BaseErrorMeasure()
bem_calculate = bem._calculate
bem_local_error = bem.local_error
def return_zero(ignoreMe, ignoreMeToo):
return 0
# remove the NotImplementedErrors for initialization
bem.local_error = return_zero
bem._calculate = return_zero
# correct initialize call
bem.initialize(tsOrg, tsCalc)
# incorrect initialize call
for cnt in range(10):
try:
bem.initialize(tsOrg, tsCalc)
except Exception:
pass
else:
assert False # pragma: no cover
bem.local_error = bem_calculate
bem._calculate = bem_local_error
def test_optimization_enabled(self):
error = BaseErrorMeasure()
error._enable_instance_optimization()
cerror.initialize = Mock()
error.initialize(None, None) #parameters irrelevant for this test
assert cerror.initialize.called, "If optimization is enabled the c method should be called"
def get_error_initialization_test(self):
"""Test the get_error of BaseErrorMeasure for the initialization exception."""
bem = BaseErrorMeasure()
try:
bem.get_error()
except StandardError:
pass
else:
assert False # pragma: no cover
def confidence_interval_test(self):
bem = BaseErrorMeasure()
bem._errorValues = [10, -5, 3, -4, None, 0, 2, -3]
self.assertRaises(ValueError, bem.confidence_interval, -0.5)
self.assertRaises(ValueError, bem.confidence_interval, 2)
self.assertEquals(bem.confidence_interval(0.5), (-3.0, 2.0))
self.assertEquals(bem.confidence_interval(0.1), (0.0, 0.0))
def get_error_initialization_test(self):
"""Test the get_error of BaseErrorMeasure for the initialization exception."""
bem = BaseErrorMeasure()
try:
bem.get_error()
except Exception:
pass
else:
assert False # pragma: no cover
def confidence_interval_test(self):
bem = BaseErrorMeasure()
bem._errorValues = [10, -5, 3, -4, None, 0, 2, -3]
self.assertRaises(ValueError, bem.confidence_interval, -0.5)
self.assertRaises(ValueError, bem.confidence_interval, 2)
self.assertEquals(bem.confidence_interval(0.5), (-3.0, 2.0))
self.assertEquals(bem.confidence_interval(0.1), (0.0, 0.0))
def double_initialize_test(self):
"""Test for the error ocuring when the same error measure is initialized twice."""
data = [[0.0, 0.0], [1, 0.1], [2, 0.2], [3, 0.3], [4, 0.4]]
tsOrg = TimeSeries.from_twodim_list(data)
tsCalc = TimeSeries.from_twodim_list(data)
bem = BaseErrorMeasure()
bem_calculate = bem._calculate
bem_local_error = bem.local_error
def return_zero(ignoreMe, ignoreMeToo):
return 0
# remove the NotImplementedErrors for initialization
bem.local_error = return_zero
bem._calculate = return_zero
# correct initialize call
bem.initialize(tsOrg, tsCalc)
# incorrect initialize call
for cnt in xrange(10):
try:
bem.initialize(tsOrg, tsCalc)
except StandardError:
pass
else:
assert False # pragma: no cover
bem.local_error = bem_calculate
bem._calculate = bem_local_error
def test_optimization_disabled(self):
error = BaseErrorMeasure()
error._disable_instance_optimization
cerror.initialize = Mock()
try:
error.initialize(None, None) #parameters irrelevant for this test
except:
pass
assert not cerror.initialize.called, "If optimization is disabled the c method should not be called"
def local_error_test(self):
"""Test local_error of BaseErrorMeasure."""
data = [[0.0, 0.0], [1, 0.1], [2, 0.2], [3, 0.3], [4, 0.4]]
tsOrg = TimeSeries.from_twodim_list(data)
tsCalc = TimeSeries.from_twodim_list(data)
bem = BaseErrorMeasure()
for idx in xrange(len(tsOrg)):
try:
bem.local_error([tsOrg[idx][1]], [tsCalc[idx][1]])
except NotImplementedError:
pass
else:
assert False # pragma: no cover
def local_error_test(self):
"""Test local_error of BaseErrorMeasure."""
data = [[0.0, 0.0], [1, 0.1], [2, 0.2], [3, 0.3], [4, 0.4]]
tsOrg = TimeSeries.from_twodim_list(data)
tsCalc = TimeSeries.from_twodim_list(data)
bem = BaseErrorMeasure()
for idx in range(len(tsOrg)):
try:
bem.local_error([tsOrg[idx][1]], [tsCalc[idx][1]])
except NotImplementedError:
pass
else:
assert False # pragma: no cover
def initialize_test(self):
"""Test if calculate throws an error as expected."""
data = [[0.0, 0.0], [1, 0.1], [2, 0.2], [3, 0.3], [4, 0.4]]
tsOrg = TimeSeries.from_twodim_list(data)
tsCalc = TimeSeries.from_twodim_list(data)
bem = BaseErrorMeasure()
try:
bem.initialize(tsOrg, tsCalc)
except NotImplementedError:
pass
else:
assert False # pragma: no cover
assert not bem.initialize(tsOrg, TimeSeries())
def test_function_call_is_transparent(self):
"""
With and without optimization the method
should be called with the same parameters.
"""
old_error = BaseErrorMeasure.local_error
BaseErrorMeasure.local_error = Mock()
ts = TimeSeries.from_twodim_list([[1,1]])
error = BaseErrorMeasure()
error._enable_instance_optimization()
error.initialize(ts, ts)
error = BaseErrorMeasure()
error._disable_instance_optimization()
error.initialize(ts, ts)
def initialize_test(self):
"""Test if calculate throws an error as expected."""
data = [[0.0, 0.0], [1, 0.1], [2, 0.2], [3, 0.3], [4, 0.4]]
tsOrg = TimeSeries.from_twodim_list(data)
tsCalc = TimeSeries.from_twodim_list(data)
bem = BaseErrorMeasure()
try:
bem.initialize(tsOrg, tsCalc)
except NotImplementedError:
pass
else:
assert False # pragma: no cover
assert not bem.initialize(tsOrg, TimeSeries())
def initialization_test(self):
"""Test the BaseErrorMeasure initialization."""
BaseErrorMeasure()
for percentage in [-1.2, -0.1, 100.1, 123.9]:
try:
BaseErrorMeasure(percentage)
except ValueError:
pass
else:
assert False # pragma: no cover
for percentage in [0.0, 12.3, 53.4, 100.0]:
try:
BaseErrorMeasure(percentage)
except ValueError: # pragma: no cover
assert False # pragma: no cover
def get_error_values_test(self):
bem = BaseErrorMeasure()
bem._errorValues = [1, -1, 3, -5, 8]
bem._errorDates = [1, 2, 3, 4, 5]
self.assertEquals(bem._get_error_values(0, 100, None, None),
[1, -1, 3, -5, 8])
self.assertEquals(bem._get_error_values(0, 100, 2, None),
[-1, 3, -5, 8])
self.assertEquals(bem._get_error_values(0, 100, None, 4),
[1, -1, 3, -5])
self.assertEquals(bem._get_error_values(0, 100, 2, 4), [-1, 3, -5])
self.assertRaises(ValueError, bem._get_error_values, 0, 100, None, 0)
def number_of_comparisons_test(self):
""" Test BaseErrorMeasure.initialize for behaviour if not enough dates match."""
dataOrg = [[0,0],[1,1],[2,2],[3,3],[4,4],[5,5],[6,6],[7,7],[8,8],[9,9]]
dataCalc = [[0,0],[1,1],[2,2],[3,3],[4,4],[5.1,5],[6.1,6],[7.1,7],[8.1,8],[9.1,9]]
tsOrg = TimeSeries.from_twodim_list(dataOrg)
tsCalc = TimeSeries.from_twodim_list(dataCalc)
bem = BaseErrorMeasure(60.0)
#prevent NotImplementedError
bem.local_error = lambda a,b: 1
mse = MeanSquaredError(80.0)
# only 50% of the original TimeSeries have a corresponding partner
if mse.initialize(tsOrg, tsCalc):
assert False # pragma: no cover
if not mse.initialize(tsOrg, tsOrg):
assert False # pragma: no cover
def test_optimization_enabled(self):
error = BaseErrorMeasure()
error._enable_instance_optimization()
cerror.initialize = Mock()
error.initialize(None, None) #parameters irrelevant for this test
assert cerror.initialize.called, "If optimization is enabled the c method should be called"
def get_error_values_test(self):
bem = BaseErrorMeasure()
bem._errorValues = [1, -1, 3, -5, 8]
bem._errorDates = [1,2,3,4,5]
self.assertEquals(bem._get_error_values(0,100, None, None), [1,-1,3,-5,8])
self.assertEquals(bem._get_error_values(0,100, 2, None), [-1,3,-5,8])
self.assertEquals(bem._get_error_values(0,100, None, 4), [1,-1,3,-5])
self.assertEquals(bem._get_error_values(0,100, 2, 4), [-1,3,-5])
self.assertRaises(ValueError, bem._get_error_values, 0, 100, None, 0)
def test_optimization_disabled(self):
error = BaseErrorMeasure()
error._disable_instance_optimization()
cerror.initialize = Mock()
try:
error.initialize(None, None) #parameters irrelevant for this test
except:
pass
assert not cerror.initialize.called, "If optimization is disabled the c method should not be called"
def get_error_parameter_test(self):
"""Test for the parameter validity of get_error()."""
data = [[0.0, 0.0], [1, 0.1], [2, 0.2], [3, 0.3], [4, 0.4]]
tsOrg = TimeSeries.from_twodim_list(data)
tsCalc = TimeSeries.from_twodim_list(data)
bem = BaseErrorMeasure()
bem_calculate = bem._calculate
bem_local_error = bem.local_error
def return_zero(ignoreMe, ignoreMeToo, andMe=None, andMeToo=None):
return 0
# remove the NotImplementedErrors for initialization
bem.local_error = return_zero
bem._calculate = return_zero
bem.initialize(tsOrg, tsCalc)
bem.local_error = bem_local_error
bem._calculate = bem_calculate
try:
bem.get_error(10.0, 90.0)
except NotImplementedError:
pass
else:
assert False # pragma: no cover
for start in [-1.0, 80.0, 103.0]:
for end in [-5.0, 10.0, 105.0]:
try:
bem.get_error(start, end)
except ValueError:
pass
else:
assert False # pragma: no cover
def get_error_parameter_test(self):
"""Test for the parameter validity of get_error()."""
data = [[0.0, 0.0], [1, 0.1], [2, 0.2], [3, 0.3], [4, 0.4]]
tsOrg = TimeSeries.from_twodim_list(data)
tsCalc = TimeSeries.from_twodim_list(data)
bem = BaseErrorMeasure()
bem_calculate = bem._calculate
bem_local_error = bem.local_error
def return_zero(ignoreMe, ignoreMeToo, andMe=None, andMeToo=None):
return 0
# remove the NotImplementedErrors for initialization
bem.local_error = return_zero
bem._calculate = return_zero
bem.initialize(tsOrg, tsCalc)
bem.local_error = bem_local_error
bem._calculate = bem_calculate
try:
bem.get_error(10.0, 90.0)
except NotImplementedError:
pass
else:
assert False # pragma: no cover
for start in [-1.0, 80.0, 103.0]:
for end in [-5.0, 10.0, 105.0]:
try:
bem.get_error(start, end)
except ValueError:
pass
else:
assert False # pragma: no cover
def test_function_call_is_transparent(self):
"""
With and without optimization the method
should be called with the same parameters.
"""
oldError = BaseErrorMeasure.local_error
BaseErrorMeasure.local_error = Mock()
ts = TimeSeries.from_twodim_list([[1, 1]])
error = BaseErrorMeasure()
error._enable_instance_optimization()
error.initialize(ts, ts)
error = BaseErrorMeasure()
error._disable_instance_optimization()
error.initialize(ts, ts)
BaseErrorMeasure.local_error = oldError
