def assertIsProb(self, observed, msg=None):
"""Fail is observed is not between 0.0 and 1.0"""
try:
if observed is None:
raise ValueError
if (asarray(observed) >= 0.0).all() and \
(asarray(observed) <= 1.0).all():
return
except:
pass
raise self.failureException, \
(msg or 'Observed %s has elements that are not probs' % (`observed`))
def assertIsNotBetween(self, observed, min_value, max_value, msg=None):
"""Fail if observed is between min_value and max_value"""
try:
if min_value is None or max_value is None or observed is None:
raise ValueError
if min_value >= max_value:
raise ValueError
if logical_or(
asarray(observed) >= max_value,
asarray(observed) <= min_value).all():
return
except:
pass
raise self.failureException, \
(msg or 'Observed %s has elements between %s, %s' % \
(`observed`, `min_value`, `max_value`))
def assertSimilarFreqs(self, observed, expected, pvalue=0.01, msg=None):
"""Fail if observed p is lower than pvalue"""
if self._suite_pvalue:
pvalue = self._suite_pvalue
obs_ravel = ravel(asarray(observed))
exp_ravel = ravel(asarray(expected))
m = zeros((2, len(obs_ravel)))
m[0, :] = obs_ravel
m[1, :] = exp_ravel
G, p = G_ind(m)
if p > pvalue:
return
else:
raise self.failureException, \
(msg or 'p-value %s, G-test p %s' % (`pvalue`, `p`))
def assertLessThan(self, observed, value, msg=None):
"""Fail if observed is >= value"""
try:
if value is None or observed is None:
raise ValueError
if (asarray(observed) < value).all():
return
except:
pass
raise self.failureException, \
(msg or 'Observed %s has elements >= %s' % (`observed`, `value`))
def assertSimilarMeans(self, observed, expected, pvalue=0.01, msg=None):
"""Fail if observed p is lower than pvalue"""
if self._suite_pvalue:
pvalue = self._suite_pvalue
observed, expected = asarray(observed), asarray(expected)
t, p = t_two_sample(observed, expected)
if p > pvalue:
return
elif p is None or not isfinite(
p): #handle case where all elements were the same
if not observed.shape:
observed = observed.reshape((1, ))
if not expected.shape:
expected = expected.reshape((1, ))
if observed[0] == expected[0]:
return
else:
raise self.failureException, \
(msg or 'p-value %s, t-test p %s' % (`pvalue`, `p`))
def assertFloatEqualRel(self, obs, exp, eps=1e-6):
"""Tests whether two floating point numbers/arrays are approx. equal.
Checks whether the distance is within epsilon relative to the value
of the sum of observed and expected. Use this method when you expect
the difference to be small relative to the magnitudes of the observed
and expected values.
Note: for arbitrary objects, need to compare the specific attribute
that's numeric, not the whole object, using this method.
"""
#do array check first
#note that we can't use array ops to combine, because we need to check
#at each element whether the expected is zero to do the test to avoid
#floating point error.
#WARNING: numpy iterates over objects that are not regular Python
#floats/ints, so need to explicitly catch scalar values and prevent
#cast to array if we want the exact object to print out correctly.
is_array = False
if hasattr(obs, 'keys') and hasattr(exp, 'keys'): #both dicts?
result = self._get_values_from_matching_dicts(obs, exp)
if result:
obs, exp = result
else:
try:
iter(obs)
iter(exp)
except TypeError:
obs = [obs]
exp = [exp]
else:
try:
arr_obs = array(obs)
arr_exp = array(exp)
arr_diff = arr_obs - arr_exp
if arr_obs.shape != arr_exp.shape:
self.fail("Wrong shape: Got %s, but expected %s" % \
(`obs`, `exp`))
obs = arr_obs.ravel()
exp = arr_exp.ravel()
is_array = True
except (TypeError, ValueError):
pass
# shape mismatch can still get by...
# explict cast is to work around bug in certain versions of numpy
# installed version on osx 10.5
if asarray(obs, object).shape != asarray(exp, object).shape:
self.fail("Wrong shape: Got %s, but expected %s" % (obs, exp))
for observed, expected in zip(obs, exp):
#try the cheap comparison first
if observed == expected:
continue
try:
sum = float(observed + expected)
diff = float(observed - expected)
if (sum == 0):
if is_array:
self.failIf(abs(diff) > abs(eps), \
"Got %s, but expected %s (diff was %s)" % \
(`arr_obs`, `arr_exp`, `arr_diff`))
else:
self.failIf(abs(diff) > abs(eps), \
"Got %s, but expected %s (diff was %s)" % \
(`observed`, `expected`, `diff`))
else:
if is_array:
self.failIf(abs(diff/sum) > abs(eps), \
"Got %s, but expected %s (diff was %s)" % \
(`arr_obs`, `arr_exp`, `arr_diff`))
else:
self.failIf(abs(diff/sum) > abs(eps), \
"Got %s, but expected %s (diff was %s)" % \
(`observed`, `expected`, `diff`))
except (TypeError, ValueError, AttributeError,
NotImplementedError):
self.fail("Got %s, but expected %s" % \
(`observed`, `expected`))