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