#!/usr/bin/env python """Tests Numbers and Freqs objects, and their Unsafe versions. """ from math import sqrt import numpy from cogent.util.unit_test import TestCase, main from cogent.maths.stats.util import SummaryStatistics, SummaryStatisticsError,\ Numbers, UnsafeNumbers, Freqs, UnsafeFreqs, NumberFreqs, \ UnsafeNumberFreqs from cogent.util.misc import ConstraintError from operator import add, sub, mul __author__ = "Rob Knight" __copyright__ = "Copyright 2007-2012, The Cogent Project" __credits__ = ["Rob Knight", "Sandra Smit"] __license__ = "GPL" __version__ = "1.5.3" __maintainer__ = "Rob Knight" __email__ = "rob@spot.colorado.edu" __status__ = "Production" class SummaryStatisticsTests(TestCase): """Tests of summary stats functions.""" def test_init(self): """SummaryStatistics should initialize correctly.""" #check empty init -- can access private vars, but can't get #properties. s = SummaryStatistics() self.assertEqual(s._count, None) self.assertRaises(SummaryStatisticsError, getattr, s, 'Count') #check init with one positional parameter s = SummaryStatistics(1) self.assertEqual(s.Count, 1) #check init with all positional parameters. #note that inconsistent data can sneak in (c.f. sd vs var) s = SummaryStatistics(1,2,3,4,5,6) self.assertEqual(s.Count, 1) self.assertEqual(s.Sum, 2) self.assertEqual(s.Mean, 3) self.assertEqual(s.StandardDeviation, 4) self.assertEqual(s.Variance, 5) self.assertEqual(s.SumSquares, 6) def test_str(self): """SummaryStatistics str should print known fields.""" s = SummaryStatistics() self.assertEqual(str(s), '') #note that additional fields will fill in if they can be calculated. s = SummaryStatistics(Mean=3, StandardDeviation=2) #now expect to print as table self.assertEqual(str(s), '==========================\n Statistic Value\n--------------------------\n Mean 3\nStandardDeviation 2\n Variance 4\n--------------------------') def test_Count(self): """SummaryStatistics Count should work if Count or Sum and Mean ok""" s = SummaryStatistics(Count=3) self.assertEqual(s.Count, 3) s = SummaryStatistics(Sum=10, Mean=5) self.assertEqual(s.Count, 2) #if inconsistent, believes Count s = SummaryStatistics(Count=3, Sum=2, Mean=5) self.assertEqual(s.Count, 3) #doesn't work with just sum or mean s = SummaryStatistics(Mean=3) self.assertRaises(SummaryStatisticsError, getattr, s, 'Count') def test_Sum(self): """SummaryStatistics Sum should work if Sum or Count and Mean ok""" s = SummaryStatistics(Sum=3) self.assertEqual(s.Sum, 3) s = SummaryStatistics(Count=3, Mean=5) self.assertEqual(s.Sum, 15) def test_Mean(self): """SummaryStatistics Mean should work if Mean or Count and Sum ok""" s = SummaryStatistics(Mean=3) self.assertEqual(s.Mean, 3) s = SummaryStatistics(Count=3, Sum=15) self.assertEqual(s.Mean, 5) def test_StandardDeviation(self): """SummaryStatistics StandardDeviation should work if it or variance ok""" s = SummaryStatistics(StandardDeviation=3) self.assertEqual(s.StandardDeviation, 3) self.assertEqual(s.Variance, 9) s = SummaryStatistics(Variance=9) self.assertEqual(s.StandardDeviation, 3) def test_Variance(self): """SummaryStatistics Variance should work if it or std dev ok""" s = SummaryStatistics(StandardDeviation=3) self.assertEqual(s.StandardDeviation, 3) self.assertEqual(s.Variance, 9) s = SummaryStatistics(Variance=9) self.assertEqual(s.StandardDeviation, 3) def test_SumSquares(self): """SummaryStatistics SumSquares should work if set""" s = SummaryStatistics(SumSquares=3) self.assertEqual(s.SumSquares, 3) s = SummaryStatistics(Sum=3) self.assertRaises(SummaryStatisticsError, getattr, s, 'SumSquares') def test_cmp(self): """SummaryStatistics should sort by count, then sum, then variance""" a = SummaryStatistics(Count=3) b = SummaryStatistics(Count=4) c = SummaryStatistics(Count=3, Sum=5) d = SummaryStatistics(Count=3, Sum=10) e = SummaryStatistics(Sum=10) assert a < b assert b > a assert a == a assert a < b assert c < d assert e < a all = [c,a,d,b,e] all.sort() self.assertEqual(all, [e,a,c,d,b]) class NumbersTestsI(object): """Abstract class with tests for Numbers objects. Inherited by safe and unsafe versions to test polymorphism. """ ClassToTest = None def test_init_empty(self): """Numbers should initialize OK with empty list""" self.assertEqual(self.ClassToTest([]), []) def test_init_single(self): """Numbers should initialize OK with single number""" self.assertEqual(self.ClassToTest([5.0]), [5.0]) def test_init_list(self): """Numbers should initialize OK with list of numbers""" self.assertEqual(self.ClassToTest([1, 5.0, 3.2]), [1, 5.0, 3.2]) def test_init_bad_type(self): """Numbers should fail with TypeError if input not iterable""" self.assertRaises(TypeError, self.ClassToTest, 34) def test_add_nonempty(self): """Numbers should allow addition of two nonempty Numbers""" #test that addition works in the right direction self.assertFloatEqual(self.integers + self.floats, Numbers([1, 2, 3, 4, 5, 1.5, 2.7])) #test that neither of the things that were added was changed self.assertFloatEqual(self.integers, [1,2,3,4,5]) self.assertFloatEqual(self.floats, [1.5, 2.7]) def test_add_empty(self): """Numbers should be unchanged on addition of empty list""" #test that addition of an empty list works self.assertFloatEqual(self.integers + self.empty, self.integers) self.assertFloatEqual(self.empty + self.floats, self.floats) def test_add_repeated(self): """Numbers should support repeated addition, a+b+c""" self.assertFloatEqual(self.floats + self.floats + self.floats, [1.5, 2.7]*3) def test_iadd(self): """Numbers should support in-place addition""" self.floats += [4] self.assertFloatEqual(self.floats, [1.5, 2.7, 4.0]) def test_setitem(self): """Numbers should support assignment to positive index""" self.floats[0] = 1 self.assertFloatEqual(self.floats, [1.0, 2.7]) def test_setitem_negative_index(self): """Numbers should support assignment to negative index""" self.floats[-1] = 2 self.assertFloatEqual(self.floats, [1.5, 2.0]) def test_setslice(self): """Numbers should support slice assignment""" self.floats[0:1] = [1, 2, 3] self.assertFloatEqual(self.floats, [1, 2, 3, 2.7]) def test_append_good(self): """Numbers should support append of a number""" self.floats.append(1) self.assertFloatEqual(self.floats, [1.5, 2.7, 1.0]) def test_extend(self): """Numbers should support extend with a sequence""" self.floats.extend([5,5,5]) self.assertFloatEqual(self.floats, [1.5, 2.7, 5.0, 5.0, 5.0]) def test_items(self): """Numbers should support items() method""" self.assertFloatEqual(self.floats.items()[0], (1.5, 1)) self.assertFloatEqual(self.floats.items()[1], (2.7, 1)) def test_isValid(self): """Numbers isValid should return True if all items numbers""" for i in [self.empty, self.integers, self.floats, self.mixed]: assert i.isValid() def test_toFixedWidth(self): """Numbers should be able to convert items to fixed-width string""" self.assertEqual(self.floats.toFixedWidth(), " +1.50e+00 +2.70e+00") def test_toFixedWidth_empty(self): """Numbers should return empty string when converting no items""" self.assertEqual(self.empty.toFixedWidth(), '') def test_toFixedWidth_mixed(self): """Numbers should convert all kinds of floats to fixed precision""" self.assertEqual(self.mixed.toFixedWidth(), ''.join([ ' +0.00e+00', ' +1.00e+00', ' -1.00e+00', ' +1.23e+00', ' -1.24e+00', '+1.23e+302', '+1.23e-298', '-1.23e+302', '-1.23e-298', ])) def test_toFixedWidth_specified_precision(self): """Numbers should convert all kinds of floats to specified precision""" self.assertEqual(self.mixed.toFixedWidth(7), ''.join([ ' +0e+00', ' +1e+00', ' -1e+00', ' +1e+00', ' -1e+00', '+1e+302', '+1e-298', '-1e+302', '-1e-298', ])) self.assertEqual(self.mixed.toFixedWidth(8), ''.join([ ' +0e+00', ' +1e+00', ' -1e+00', ' +1e+00', ' -1e+00', ' +1e+302', ' +1e-298', ' -1e+302', ' -1e-298', ])) self.assertEqual(self.mixed.toFixedWidth(12), ''.join([ ' +0.0000e+00', ' +1.0000e+00', ' -1.0000e+00', ' +1.2346e+00', ' -1.2368e+00', '+1.2340e+302', '+1.2340e-298', '-1.2340e+302', '-1.2340e-298', ])) def test_normalize(self): """Numbers normalize should return items summing to 1 by default""" first = self.ints second = self.fracs first.normalize() second.normalize() self.assertFloatEqual(first, second) self.assertFloatEqual(first.Sum, 1) self.assertFloatEqual(second.Sum, 1) empty = self.empty empty.normalize() self.assertEqual(empty, []) zero = self.zero zero.normalize() self.assertEqual(zero, [0,0,0,0,0]) def test_normalize_parameter(self): """Numbers normalize(x) should divide items by x""" first = self.ClassToTest([0, 1, 2, 3, 4]) first.normalize(max(first)) self.assertFloatEqual(first, [0, 1.0/4, 2.0/4, 3.0/4, 4.0/4]) second = self.ClassToTest([0, 1, 2]) second.normalize(0.5) self.assertFloatEqual(second, [0, 2, 4]) def test_accumulate(self): """Numbers accumulate should do cumulative sum in place""" nl = self.ClassToTest([0, 1, 2, 3, 4]) nl.accumulate() self.assertEqual(nl, [0, 1, 3, 6, 10]) nl = self.ClassToTest() nl.accumulate() self.assertEqual(nl, []) def test_firstIndexLessThan(self): """Numbers firstIndexLessThan should return first index less than val""" nl = self.ints f = nl.firstIndexLessThan self.assertEqual(f(-50), None) self.assertEqual(f(100), 0) self.assertEqual(f(3), 0) self.assertEqual(f(1), None) self.assertEqual(f(1, inclusive=True), 0) self.assertEqual(f(-50, stop_at_ends=True), 4) def test_firstIndexGreaterThan(self): """Numbers firstIndexGreaterThan should return first index less than val""" nl = self.ints f = nl.firstIndexGreaterThan self.assertEqual(f(-50), 0) self.assertEqual(f(100), None) self.assertEqual(f(3), 3) self.assertEqual(f(1), 1) self.assertEqual(f(1, inclusive=True), 0) self.assertEqual(f(2), 2) self.assertEqual(f(2, inclusive=True), 1) self.assertEqual(f(100, stop_at_ends=True), 4) #compatibility tests with old choose() """Numbers choose should return correct index""" nl = self.ClassToTest([1, 2, 3, 4, 5]) nl.normalize() nl.accumulate() known_values = [ (-50, 0), (0, 0), (0.001, 0), (1/15.0 - 0.001, 0), (1/15.0 + 0.001, 1), (3/15.0 + 0.001, 2), (1, 4), (10, 4), ] for test, result in known_values: self.assertFloatEqual(nl.firstIndexGreaterThan(test, inclusive=True, stop_at_ends=True), result) def test_lastIndexGreaterThan(self): """Numbers lastIndexGreaterThan should return last index > val""" nl = self.ints f = nl.lastIndexGreaterThan self.assertEqual(f(-50), 4) self.assertEqual(f(100), None) self.assertEqual(f(3), 4) self.assertEqual(f(1), 4) self.assertEqual(f(1, inclusive=True), 4) self.assertEqual(f(100, stop_at_ends=True), 0) def test_lastIndexLessThan(self): """Numbers lastIndexLessThan should return last index < val""" nl = self.ints f = nl.lastIndexLessThan self.assertEqual(f(-50), None) self.assertEqual(f(100), 4) self.assertEqual(f(3), 1) self.assertEqual(f(1), None) self.assertEqual(f(1, inclusive=True), 0) self.assertEqual(f(-50, stop_at_ends=True), 0) def test_Sum(self): """Numbers Sum should be the same as sum()""" self.assertEqual(self.ints.Sum, 15) self.assertEqual(self.empty.Sum, 0) def test_Count(self): """Numbers Count should be the same as len()""" self.assertEqual(self.ints.Count, 5) self.assertEqual(self.empty.Count, 0) def test_SumSquares(self): """Numbers SumSquares should be sum of squares""" self.assertEqual(self.ints.SumSquares, (1*1+2*2+3*3+4*4+5*5)) self.assertEqual(self.empty.SumSquares, 0) def test_Variance(self): """Numbers Variance should be variance of individual numbers""" self.assertEqual(self.empty.Variance, None) self.assertEqual(self.zero.Variance, 0) self.assertFloatEqual(self.ints.Variance, 2.5) def test_StandardDeviation(self): """Numbers StandardDeviation should be sd of individual numbers""" self.assertEqual(self.empty.StandardDeviation, None) self.assertEqual(self.zero.StandardDeviation, 0) self.assertFloatEqual(self.ints.StandardDeviation, sqrt(2.5)) def test_Mean(self): """Numbers Mean should be mean of individual numbers""" self.assertEqual(self.empty.Mean, None) self.assertEqual(self.zero.Mean, 0) self.assertEqual(self.ints.Mean, 3) def test_NumberQuantiles(self): """quantiles should be correct""" num = self.ClassToTest(range(1,11)) self.assertFloatEqual(num.quantile(.1), 1.9) self.assertFloatEqual(num.quantile(.2), 2.8) self.assertFloatEqual(num.quantile(.25), 3.25) self.assertFloatEqual(num.Median, 5.5) self.assertFloatEqual(num.quantile(.75), 7.75) self.assertFloatEqual(num.quantile(.77), 7.93) def test_summarize(self): """Numbers summarize should return SummaryStatistics object""" self.assertEqual(self.ints.summarize(), SummaryStatistics(Mean=3,\ Variance=2.5, Count=5)) def test_choice(self): """Numbers choice should return random element from self""" nums = [self.ints.choice() for i in range(10)] self.assertEqual(len(nums), 10) for n in nums: assert n in self.ints v = Numbers(nums).Variance self.assertNotEqual(v, 0) def test_randomSequence(self): """Numbers randomSequence should return random sequence from self""" nums = self.ints.randomSequence(10) nums = [self.ints.choice() for i in range(10)] self.assertEqual(len(nums), 10) for n in nums: assert n in self.ints v = Numbers(nums).Variance self.assertNotEqual(v, 0) def test_subset(self): """Numbers subset should delete (or keep) selected items""" odd = [5,1,3] nums = self.ints nums.extend([1,1,1]) new_nums = nums.copy() new_nums.subset(odd) self.assertEqual(new_nums, [1,3,5,1,1,1]) new_nums = nums.copy() new_nums.subset(odd, keep=False) self.assertEqual(new_nums, [2,4]) def test_copy(self): """Numbers copy should leave class intact (unlike slice)""" c = self.ints.copy() self.assertEqual(c, self.ints) self.assertEqual(c.__class__, self.ints.__class__) def test_round(self): """Numbers round should round numbers in-place""" self.floats.round() self.assertEqual(self.floats, [2.0,3.0]) for i, f in enumerate(self.floats): self.floats[i] = self.floats[i] + 0.101 self.assertNotEqual(self.floats, [2.0,3.0]) self.assertNotEqual(self.floats, [2.1,3.1]) self.floats.round(1) self.assertEqual(self.floats, [2.1,3.1]) def test_Uncertainty(self): """Numbers Uncertainty should act via Freqs""" self.assertEqual(self.floats.Uncertainty, \ Freqs(self.floats).Uncertainty) self.assertNotEqual(self.floats.Uncertainty, None) def test_Mode(self): """Numbers Mode should return most common element""" self.assertEqual(self.empty.Mode, None) self.assertEqual(self.zero.Mode, 0) self.ints.extend([1,2,2,3,3,3]) self.assertEqual(self.ints.Mode, 3) class NumbersTests(TestCase, NumbersTestsI): """Tests of the (safe) Numbers class.""" ClassToTest = Numbers def setUp(self): """define some standard lists""" self.empty = self.ClassToTest([]) self.integers = self.ClassToTest([1,2,3,4,5]) self.floats = self.ClassToTest([1.5, 2.7]) self.mixed = self.ClassToTest([ 0, 1, -1, 1.234567890, -1.2367890, 123.4e300, 123.4e-300, -123.4e300, -123.4e-300, ]) self.zero = self.ClassToTest([0,0,0,0,0]) self.ints = self.ClassToTest([1,2,3,4,5]) self.fracs = self.ClassToTest([0.1,0.2,0.3,0.4,0.5]) def test_init_string(self): """Numbers should initialize by treating string as list of digits""" self.assertEqual(self.ClassToTest('102'), [1.0, 0.0, 2.0]) def test_init_bad_string(self): """Numbers should raise ValueError if float() can't convert string""" self.assertRaises(ValueError, self.ClassToTest, '102a') def test_append_bad(self): """Numbers should reject append of a non-number""" self.assertRaises(ValueError, self.floats.append, "abc") class UnsafeNumbersTests(TestCase, NumbersTestsI): """Tests of the UnsafeNumbers class.""" ClassToTest = UnsafeNumbers def setUp(self): """define some standard lists""" self.empty = self.ClassToTest([]) self.integers = self.ClassToTest([1,2,3,4,5]) self.floats = self.ClassToTest([1.5, 2.7]) self.mixed = self.ClassToTest([ 0, 1, -1, 1.234567890, -1.2367890, 123.4e300, 123.4e-300, -123.4e300, -123.4e-300, ]) self.zero = self.ClassToTest([0,0,0,0,0]) self.ints = self.ClassToTest([1,2,3,4,5]) self.fracs = self.ClassToTest([0.1,0.2,0.3,0.4,0.5]) def test_init_string(self): """UnsafeNumbers should treat string as list of chars""" self.assertEqual(self.ClassToTest('102'), ['1','0','2']) def test_init_bad_string(self): """UnsafeNumbers should silently incorporate unfloatable string""" self.assertEqual(self.ClassToTest('102a'), ['1','0','2','a']) def test_append_bad(self): """UnsafeNumbers should allow append of a non-number""" self.empty.append('abc') self.assertEquals(self.empty, ['abc']) def test_isValid_bad(self): """UnsafeNumbers should return False if invalid""" assert self.mixed.isValid() self.mixed.append('abc') assert not self.mixed.isValid() class StaticFreqsTestsI(object): """Tests of the interface shared by Freqs and UnsafeFreqs (static keys). All of these tests assume keys on the alphabet 'abcde'. These tests were added to ensure that array-based objects that implement a fixed set of keys maintain the appropriate portion of the freqs interface. """ ClassToTest = None def setUp(self): """Standard cases to test.""" self.Alphabetic = self.ClassToTest({'a':3,'b':2,'c':1,'d':1,'e':1}) self.Empty = self.ClassToTest({}) self.Constant = self.ClassToTest({'a':5}) #The following test various ways of constructing the objects def test_fromTuples(self): """Freqs fromTuples should add from key, count pairs w/ repeated keys""" ct = self.ClassToTest f = ct() self.assertEqual(f.fromTuples([('a',4),('b',3),('a',2)]), \ ct({'a':6,'b':3})) #note: should be allowed to subtract, as long as freq doesn't go #negative. f.fromTuples([('b',-1),('c',4.5)]) self.assertEqual(f, ct({'a':6,'b':2,'c':4.5})) #should work with a different operator f.fromTuples([('b',7)], op=mul) self.assertEqual(f, ct({'a':6, 'b':14, 'c':4.5})) #check that it works with something that depends on the key def func(key, first, second): if key == 'a': return first + second else: return max(second, first * second) f = ct() self.assertEqual(f.fromTuples([('a',4),('b',3),('a',2), ('b',4)], \ func,uses_key=True), ct({'a':6,'b':12})) def test_newFromTuples(self): """Freqs newFromTuples should work as expected.""" ct = self.ClassToTest self.assertEqual(ct.newFromTuples([('a',4),('b',3),('a',2)]), \ ct({'a':6,'b':3})) def test_fromDict(self): """Freqs fromDict should add from dict of {key:count}""" ct = self.ClassToTest f = ct() self.assertEqual(f.fromDict({'a':6,'b':3}), ct({'a':6,'b':3})) #note: should be allowed to subtract, as long as freq doesn't go #negative. f.fromDict({'b':-1, 'c':4.5}) self.assertEqual(f, ct({'a':6,'b':2,'c':4.5})) #should work with a different operator f.fromDict({'b':7}, op=mul) self.assertEqual(f, ct({'a':6, 'b':14, 'c':4.5})) def test_newFromDict(self): """Freqs newFromDict should work as expected.""" ct = self.ClassToTest self.assertEqual(ct.newFromDict({'a':6,'b':3}), ct({'a':6,'b':3})) def test_fromDicts(self): """Freqs fromDicts should add from list of dicts of {key:count}""" ct = self.ClassToTest f = ct() self.assertEqual(f.fromDicts([{'a':6},{'b':3}]), ct({'a':6,'b':3})) #note: should be allowed to subtract, as long as freq doesn't go #negative. Also tests add of 1-item dict (note: must be in list) f.fromDicts([{'b':-1, 'c':4.5}]) self.assertEqual(f, ct({'a':6,'b':2,'c':4.5})) #should work with a different operator f.fromDicts([{'b':2},{'b':3}], op=mul) self.assertEqual(f, ct({'a':6, 'b':12, 'c':4.5})) def test_newFromDicts(self): """Freqs newFromDicts should work as expected.""" ct = self.ClassToTest self.assertEqual(ct.newFromDicts([{'a':6},{'b':3}]), ct({'a':6,'b':3})) def test_fromSeq(self): """Freqs fromSeq should add items from sequence, according to weight""" ct = self.ClassToTest f = self.ClassToTest() self.assertEqual(f.fromSeq('aaabbbaaa'), ct({'a':6,'b':3})) #should be able to change the operator... self.assertEqual(f.fromSeq('aab', sub), ct({'a':4,'b':2})) #...or change the weight self.assertEqual(f.fromSeq('acc', weight=3.5),\ ct({'a':7.5,'b':2,'c':7})) def test_newFromSeq(self): """Freqs newFromSeq should work as expected.""" ct = self.ClassToTest self.assertEqual(ct.newFromSeq('aaabbbaaa'), ct({'a':6,'b':3})) def test_fromSeqs(self): """Freqs fromSeqs should add items from sequences, according to weight""" ct = self.ClassToTest f = ct() self.assertEqual(f.fromSeqs(['aaa','bbbaaa']), ct({'a':6,'b':3})) #should be able to change the operator... self.assertEqual(f.fromSeqs(list('aab'), sub), ct({'a':4,'b':2})) #...or change the weight. Note that a string counts as a seq of seqs. self.assertEqual(f.fromSeqs('acc', weight=3.5), \ ct({'a':7.5,'b':2,'c':7})) def test_newFromSeqs(self): """Freqs newFromSeqs should work as expected.""" ct = self.ClassToTest self.assertEqual(ct.newFromSeqs(['aaa','bbbaaa']), ct({'a':6,'b':3})) def test_isValid(self): """Freqs isValid should return True if valid""" d =self.ClassToTest() assert d.isValid() d.fromSeq('aaaaaaaaaaaaabb') assert d.isValid() def test_find_conversion_function(self): """Freqs _find_conversion_function should return correct value.""" d = self.ClassToTest() f = d._find_conversion_function #should always return None if data empty for i in [None, 0, False, {}, [], tuple()]: self.assertEqual(f(i), None) #should return fromDict for non-empty dict self.assertEqual(f({3:4}), d.fromDict) #should return fromSeq for string or list of scalars or strings for i in ['abc', [1,2,3], (1,2,3), ['ab','bb','cb']]: self.assertEqual(f(i), d.fromSeq) #should return fromSeqs for sequence of sequences for i in [[[1,2,3],[3,4,4]], ([1,2,4],[3,4,4]), [(1,2),[3],[], [4]]]: self.assertEqual(f(i), d.fromSeqs) #should return fromTuples if possibly key-value pairs for i in [[('a',3),('b',-1)], [(1,2),(3,4)]]: self.assertEqual(f(i), d.fromTuples) #should not be fooled by 2-item seqs that can't be key-value pairs self.assertEqual(f(['ab','cd']), d.fromSeq) #The following test inheritance of dict properties/methods def test_setitem_good(self): """Freqs should allow non-negative values to be set""" ct = self.ClassToTest self.Empty['a'] = 0 self.assertEqual(self.Empty, ct({'a':0})) self.Empty['b'] = 5 self.assertEqual(self.Empty, ct({'a':0, 'b':5})) def test_delitem(self): """delitem not applicable to freqs w/ constant keys: not tested""" pass def test_setdefault_good(self): """Freqs setdefault should work with positive values if key present""" a = self.Alphabetic.setdefault('a', 200) self.assertEqual(a, 3) self.assertEqual(self.Alphabetic['a'], 3) def test_iadd(self): """Freqs += should add in place from any known data type""" ct = self.ClassToTest f = ct({'a':3, 'b':4}) f += 'aca' self.assertEqual(f, ct({'a':5, 'b':4, 'c':1})) f += ['b','b'] self.assertEqual(f, ct({'a':5, 'b':6, 'c':1})) f += {'c':10, 'a':-3} self.assertEqual(f, ct({'a':2, 'b':6, 'c':11})) f += (('a',3),('b',-2)) self.assertEqual(f, ct({'a':5, 'b':4, 'c':11})) f += [['a', 'b', 'b'],['c', 'c', 'c']] self.assertEqual(f, ct({'a':6, 'b':6, 'c':14})) #note that list of strings will give implementation-dependent result def test_add(self): """Freqs + should make new object, adding from any known data type""" ct = self.ClassToTest orig = {'a':3, 'b':4} f = ct(orig) r = f + 'aca' self.assertEqual(r, ct({'a':5, 'b':4, 'c':1})) self.assertEqual(f, orig) r = f + ['b','b'] self.assertEqual(r, ct({'a':3, 'b':6})) self.assertEqual(f, orig) r = f + {'c':10, 'a':-3} self.assertEqual(r, ct({'a':0, 'b':4, 'c':10})) self.assertEqual(f, orig) r = f + (('a',3),('b',-2)) self.assertEqual(r, ct({'a':6, 'b':2})) self.assertEqual(f, orig) r = f + [['a', 'b', 'b'],['c', 'c', 'c']] self.assertEqual(r, ct({'a':4, 'b':6, 'c':3})) self.assertEqual(f, orig) #note that list of strings will give implementation-dependent result def test_isub(self): """Freqs -= should subtract in place using any known data type""" ct = self.ClassToTest f = ct({'a':5, 'b':4}) f -= 'aba' self.assertEqual(f, ct({'a':3, 'b':3})) f -= ['b','b'] self.assertEqual(f, ct({'a':3, 'b':1})) f -= {'c':-2, 'a':-3} self.assertEqual(f, ct({'a':6, 'b':1, 'c':2})) f -= (('a',3),('b',-2)) self.assertEqual(f, ct({'a':3, 'b':3, 'c':2})) f -= [['a', 'b', 'b'],['c', 'c']] self.assertEqual(f, ct({'a':2, 'b':1, 'c':0})) #note that list of strings will give implementation-dependent result def test_sub(self): """Freqs - should make new object, subtracting using any known data type""" orig = {'a':3, 'b':4} ct = self.ClassToTest f = self.ClassToTest(orig) r = f - 'aba' self.assertEqual(r, ct({'a':1, 'b':3})) self.assertEqual(f, orig) r = f - ['b','b'] self.assertEqual(r, ct({'a':3, 'b':2})) self.assertEqual(f, orig) r = f - {'c':-10, 'a':3} self.assertEqual(r, ct({'a':0, 'b':4, 'c':10})) self.assertEqual(f, orig) r = f - (('a',3),('b',-2)) self.assertEqual(r, ct({'a':0, 'b':6})) self.assertEqual(f, orig) r = f - [['a', 'b', 'b'],['a','a']] self.assertEqual(r, ct({'a':0, 'b':2})) self.assertEqual(f, orig) #note that list of strings will give implementation-dependent results def test_copy(self): """Freqs copy should preserve class of original""" d = {'a':4, 'b':3, 'c':6} f = self.ClassToTest(d) g = f.copy() self.assertEqual(f, g) self.assertEqual(f.__class__, g.__class__) def test_str(self): """Freqs abstract interface doesn't specify string result""" pass def test_delitem(self): """Freqs delitem is implementation-dependent""" pass #The following test custom methods def test_rekey(self): """Freqs rekey should map the results onto new keys""" #note that what happens to unmapped keys is implementation-dependent ct = self.ClassToTest d = ct({'a':3, 'b':5, 'c':6, 'd':7, 'e':1}) #should work with simple rekeying f = d.rekey({'a':'d', 'b':'e'}) self.assertEqual(f['d'], d['a']) self.assertEqual(f['e'], d['b']) #remaining keys might be absent or 0 for i in 'abc': if i in f: self.assertEqual(f[i], 0) #should work if many old keys map to the same new key f = d.rekey({'a':'d', 'b':'e', 'c':'e'}) self.assertEqual(f['d'], d['a']) self.assertEqual(f['e'], d['b'] + d['c']) #remaining keys might be absent or 0 for i in 'abc': if i in f: self.assertEqual(f[i], 0) #check with explicit constructor and default d = self.ClassToTest({'a':3, 'b':5, 'c':6, 'd':7, 'e':1}) f = d.rekey({'a':'+', 'b':'-', 'c':'+'}, default='x', constructor=dict) self.assertEqual(f, {'+':9, '-':5, 'x':8}) self.assertEqual(f.__class__, dict) def test_purge(self): """Freqs purge should have no effect if keys are fixed""" ct = self.ClassToTest orig = {'a':3, 'b':2, 'c':1, 'd':3, 'e':4} d = ct(orig) d.purge() self.assertEqual(d, ct(orig)) def test_normalize(self): """Freqs should allow normalization""" ct = self.ClassToTest self.Empty.normalize() self.assertEqual(self.Empty, ct({})) a = self.Alphabetic.copy() a.normalize() expected = {'a':0.375, 'b':0.25, 'c':0.125, 'd':0.125, 'e':0.125} for key, val in expected.items(): self.assertFloatEqual(a[key], val) def test_choice(self): """Freqs choice should work as expected""" self.Alphabetic.normalize() keys = self.Alphabetic.keys() vals = Numbers(self.Alphabetic.values()) vals.accumulate() #test first item self.assertEqual(self.Alphabetic.choice(-1), keys[0]) self.assertEqual(self.Alphabetic.choice(-0.0001), keys[0]) self.assertEqual(self.Alphabetic.choice(-1e300), keys[0]) self.assertEqual(self.Alphabetic.choice(0), keys[0]) #test last item last_val = vals.pop() self.assertEqual(self.Alphabetic.choice(last_val), keys[-1]) self.assertEqual(self.Alphabetic.choice(1000), keys[-1]) #test remaining items for index, value in enumerate(vals): self.assertEqual(self.Alphabetic.choice(value-0.01),keys[index]) self.assertEqual(self.Alphabetic.choice(value+0.01), keys[index+1]) def test_randomSequence_good(self): """Freqs randomSequence should give correct counts""" self.Alphabetic.normalize() total = self.Alphabetic.Sum keys = self.Alphabetic.keys() probs = [float(i)/total for i in self.Alphabetic.values()] rand_seq = self.Alphabetic.randomSequence(10000) observed = [rand_seq.count(key) for key in keys] expected = [prob*10000 for prob in probs] self.assertSimilarFreqs(observed, expected) def test_randomSequence_bad(self): """Empty Freqs should raise error on randomSequence""" self.assertRaises(IndexError, self.Empty.randomSequence, 5) def test_randomSequence_one_item(self): """Freqs randomSequence should work with one key""" self.Constant.normalize() rand = self.Constant.randomSequence(1000) self.assertEqual(rand.count('a'), 1000) self.assertEqual(len(rand), 1000) def test_subset_preserve(self): """Freqs subset should preserve wanted items""" ct = self.ClassToTest self.Constant.subset('bc') self.assertEqual(self.Constant, self.Empty) self.Alphabetic.subset('abx') self.assertEqual(self.Alphabetic, ct({'a':3,'b':2})) def test_subset_remove(self): """Freqs subset should delete unwanted items if asked""" ct = self.ClassToTest self.Alphabetic.subset('abx', keep=False) self.assertEqual(self.Alphabetic, ct({'c':1,'d':1,'e':1})) self.Constant.subset('bx', keep=False) self.assertEqual(self.Constant, ct({'a':5})) def test_scale(self): """Freqs scale should multiply all values with the given scale""" ct = self.ClassToTest f = ct({'a':0.25,'b':0.25}) f.scale(10) self.assertEqual(f,ct({'a':2.5,'b':2.5})) f.scale(100) self.assertEqual(f,ct({'a':250, 'b':250})) f.scale(0.001) self.assertEqual(f,ct({'a':0.25,'b':0.25})) def test_round(self): """Freqs round should round all frequencies to integers""" ct = self.ClassToTest f = ct({'a':23.1, 'b':12.5, 'c':56.7}) f.round() self.assertEqual(f,ct({'a':23, 'b':13, 'c':57})) g = ct({'a':23.1356, 'b':12.5731}) g.round(3) self.assertEqual(g,ct({'a':23.136, 'b':12.573})) def test_expand(self): """Freqs expand should give expected results""" ct = self.ClassToTest f = ct({'a':3, 'c':5, 'b':2}) self.assertEqual(f.expand(order='acb'), list('aaacccccbb')) self.assertEqual(f.expand(order='dba'), list('bbaaa')) self.assertEqual(f.expand(order='cba',convert_to=''.join),'cccccbbaaa') f['c'] = 0 self.assertEqual(f.expand(order='acb'), list('aaabb')) f.normalize() self.assertEqual(f.expand(order='cba'), ['a']) self.assertEqual(f.expand(convert_to=''.join), 'a') f.normalize(total=1.0/20) self.assertEqual(f.expand(order='abc'), list('a'*12 + 'b'*8)) #test expand with scaling g = ct({'c':0.5,'d':0.5}) self.assertEqual(g.expand(order='cd'),['c','d']) self.assertEqual(g.expand(order='cd',scale=10),list(5*'c'+5*'d')) self.assertRaises(ValueError,g.expand,scale=33) def test_Count(self): """Freqs Count should return correct count (number of categories)""" self.assertEqual(self.Alphabetic.Count, 5) #WARNING: Count of empty categories is implementation-dependent def test_Sum(self): """Freqs Sum should return sum of item counts in all categories""" self.assertEqual(self.Alphabetic.Sum, 8) self.assertEqual(self.Empty.Sum, 0) self.assertEqual(self.Constant.Sum, 5) def test_SumSquares(self): """Freqs SumSquared should return sum of squared freq of each category""" self.assertEqual(self.Alphabetic.SumSquares, 16) self.assertEqual(self.Empty.SumSquares, 0) self.assertEqual(self.Constant.SumSquares, 25) def test_Variance(self): """Freqs Variance should return variance of counts in categories""" self.assertFloatEqual(self.Alphabetic.Variance, 0.8) self.assertFloatEqual(self.Empty.Variance, None) #WARNING: Variance with empty categories is implementation-dependent def test_StandardDeviation(self): """Freqs StandardDeviation should return stdev of counts in categories""" self.assertFloatEqual(self.Alphabetic.StandardDeviation, sqrt(0.8)) self.assertFloatEqual(self.Empty.StandardDeviation, None) #WARNING: Standard deviation with empty categories is implementation- #dependent def test_Mean(self): """Freqs Mean should return mean of counts in categories""" self.assertEqual(self.Alphabetic.Mean, 8/5.0) self.assertEqual(self.Empty.Mean, None) #WARNING: Mean with empty categories is implementation-dependent def test_Uncertainty(self): """Freqs Shannon uncertainty values should match spreadsheet""" self.assertEqual(self.Empty.Uncertainty, 0) self.assertFloatEqual(self.Alphabetic.Uncertainty, 2.1556, eps=1e-4) #WARNING: Uncertainty with empty categories is implementation-dependent def test_mode(self): """Freqs mode should return most frequent item""" self.assertEqual(self.Empty.Mode, None) self.assertEqual(self.Alphabetic.Mode, 'a') self.assertEqual(self.Constant.Mode, 'a') def test_summarize(self): """Freqs summarize should return Summary: Count, Sum, SumSquares, Var""" s = self.Alphabetic.summarize() self.assertEqual(s.Sum, 8) self.assertEqual(s.Count, 5) self.assertEqual(s.SumSquares, 16) self.assertFloatEqual(s.Variance, 0.8) self.assertFloatEqual(s.StandardDeviation, sqrt(0.8)) self.assertFloatEqual(s.Mean, 8.0/5) def test_getSortedList(self): """Freqs getSortedList should return sorted list of key, val tuples""" #behavior is implementation-defined with empty list, so skip tests. a = self.Alphabetic a['b'] = 5 self.assertEqual(a.getSortedList(), \ [('b',5),('a',3),('e',1),('d',1),('c',1)]) self.assertEqual(a.getSortedList(descending=True), \ [('b',5),('a',3),('e',1),('d',1),('c',1)]) self.assertEqual(a.getSortedList(descending=False), \ [('c',1),('d',1),('e',1),('a',3),('b',5)]) self.assertEqual(a.getSortedList(by_val=False), \ [('e',1),('d',1),('c',1),('b',5),('a',3)]) self.assertEqual(a.getSortedList(by_val=False, descending=False), \ [('a',3),('b',5),('c',1),('d',1),('e',1)]) class FreqsStaticTests(StaticFreqsTestsI, TestCase): ClassToTest = Freqs class UnsafeFreqsStaticTests(StaticFreqsTestsI, TestCase): ClassToTest = UnsafeFreqs class FreqsTestsI(object): """Tests of the interface shared by Freqs and UnsafeFreqs.""" ClassToTest = None #The following test various ways of constructing the objects def test_fromTuples(self): """Freqs fromTuples should add from key, count pairs w/ repeated keys""" f = self.ClassToTest() self.assertEqual(f.fromTuples([('a',4),('b',3),('a',2)]), {'a':6,'b':3}) #note: should be allowed to subtract, as long as freq doesn't go #negative. f.fromTuples([('b',-1),('c',4.5)]) self.assertEqual(f, {'a':6,'b':2,'c':4.5}) #should work with a different operator f.fromTuples([('b',7)], op=mul) self.assertEqual(f, {'a':6, 'b':14, 'c':4.5}) #check that it works with something that depends on the key def func(key, first, second): if key == 'a': return first + second else: return max(second, first * second) f = self.ClassToTest() self.assertEqual(f.fromTuples([('a',4),('b',3),('a',2), ('b',4)], \ func,uses_key=True), {'a':6,'b':12}) def test_fromDict(self): """Freqs fromDict should add from dict of {key:count}""" f = self.ClassToTest() self.assertEqual(f.fromDict({'a':6,'b':3}), {'a':6,'b':3}) #note: should be allowed to subtract, as long as freq doesn't go #negative. f.fromDict({'b':-1, 'c':4.5}) self.assertEqual(f, {'a':6,'b':2,'c':4.5}) #should work with a different operator f.fromDict({'b':7}, op=mul) self.assertEqual(f, {'a':6, 'b':14, 'c':4.5}) def test_fromDicts(self): """Freqs fromDicts should add from list of dicts of {key:count}""" f = self.ClassToTest() self.assertEqual(f.fromDicts([{'a':6},{'b':3}]), {'a':6,'b':3}) #note: should be allowed to subtract, as long as freq doesn't go #negative. Also tests add of 1-item dict (note: must be in list) f.fromDicts([{'b':-1, 'c':4.5}]) self.assertEqual(f, {'a':6,'b':2,'c':4.5}) #should work with a different operator f.fromDicts([{'b':2},{'b':3}], op=mul) self.assertEqual(f, {'a':6, 'b':12, 'c':4.5}) def test_fromSeq(self): """Freqs fromSeq should add items from sequence, according to weight""" f = self.ClassToTest() self.assertEqual(f.fromSeq('aaabbbaaa'), {'a':6,'b':3}) #should be able to change the operator... self.assertEqual(f.fromSeq('aab', sub), {'a':4,'b':2}) #...or change the weight self.assertEqual(f.fromSeq('acc', weight=3.5), {'a':7.5,'b':2,'c':7}) def test_fromSeqs(self): """Freqs fromSeqs should add items from sequences, according to weight""" f = self.ClassToTest() self.assertEqual(f.fromSeqs(['aaa','bbbaaa']), {'a':6,'b':3}) #should be able to change the operator... self.assertEqual(f.fromSeqs(list('aab'), sub), {'a':4,'b':2}) #...or change the weight. Note that a string counts as a seq of seqs. self.assertEqual(f.fromSeqs('acc', weight=3.5), {'a':7.5,'b':2,'c':7}) def test_isValid(self): """Freqs isValid should return True if valid""" d =self.ClassToTest() assert d.isValid() d.fromSeq('aaaaaaaaaaaaabb') assert d.isValid() def test_find_conversion_function(self): """Freqs _find_conversion_function should return correct value.""" d = self.ClassToTest() f = d._find_conversion_function #should always return None if data empty for i in [None, 0, False, {}, [], tuple()]: self.assertEqual(f(i), None) #should return fromDict for non-empty dict self.assertEqual(f({3:4}), d.fromDict) #should return fromSeq for string or list of scalars or strings for i in ['abc', [1,2,3], (1,2,3), ['ab','bb','cb']]: self.assertEqual(f(i), d.fromSeq) #should return fromSeqs for sequence of sequences for i in [[[1,2,3],[3,4,4]], ([1,2,4],[3,4,4]), [(1,2),[3],[], [4]]]: self.assertEqual(f(i), d.fromSeqs) #should return fromTuples if possibly key-value pairs for i in [[('a',3),('b',-1)], [(1,2),(3,4)]]: self.assertEqual(f(i), d.fromTuples) #should not be fooled by 2-item seqs that can't be key-value pairs self.assertEqual(f(['ab','cd']), d.fromSeq) #The following test inheritance of dict properties/methods def test_setitem_good(self): """Freqs should allow non-negative values to be set""" self.Empty[3] = 0 self.assertEqual(self.Empty, {3:0}) self.Empty['xyz'] = 5 self.assertEqual(self.Empty, {3:0, 'xyz':5}) def test_delitem(self): """Freqs should delete all counts of item with del""" del self.Alphabetic['a'] del self.Alphabetic['b'] del self.Alphabetic['c'] self.assertEqual(self.Alphabetic, {'d':1,'e':1}) def test_setdefault_good(self): """Freqs setdefault should work with positive values""" a = self.Alphabetic.setdefault('a', 200) self.assertEqual(a, 3) self.assertEqual(self.Alphabetic['a'], 3) f = self.Alphabetic.setdefault('f', 0) self.assertEqual(f, 0) self.assertEqual(self.Alphabetic['f'], 0) g = self.Alphabetic.setdefault('g', 1000) self.assertEqual(g, 1000) self.assertEqual(self.Alphabetic['g'], 1000) #The following test overridden operators and methods def test_iadd(self): """Freqs += should add in place from any known data type""" f = self.ClassToTest({'a':3, 'b':4}) f += 'aca' self.assertEqual(f, {'a':5, 'b':4, 'c':1}) f += ['b','b'] self.assertEqual(f, {'a':5, 'b':6, 'c':1}) f += {'c':10, 'a':-3} self.assertEqual(f, {'a':2, 'b':6, 'c':11}) f += (('a',3),('b',-2)) self.assertEqual(f, {'a':5, 'b':4, 'c':11}) f += [['a', 'b', 'b'],['c', 'c', 'c']] self.assertEqual(f, {'a':6, 'b':6, 'c':14}) #note that list of strings will use the strings as keys f += ['abc', 'def', 'abc'] self.assertEqual(f, {'a':6, 'b':6, 'c':14, 'abc':2, 'def':1}) def test_add(self): """Freqs + should make new object, adding from any known data type""" orig = {'a':3, 'b':4} f = self.ClassToTest(orig) self.assertEqual(f, orig) r = f + 'aca' self.assertEqual(r, {'a':5, 'b':4, 'c':1}) self.assertEqual(f, orig) r = f + ['b','b'] self.assertEqual(r, {'a':3, 'b':6}) self.assertEqual(f, orig) r = f + {'c':10, 'a':-3} self.assertEqual(r, {'a':0, 'b':4, 'c':10}) self.assertEqual(f, orig) r = f + (('a',3),('b',-2)) self.assertEqual(r, {'a':6, 'b':2}) self.assertEqual(f, orig) r = f + [['a', 'b', 'b'],['c', 'c', 'c']] self.assertEqual(r, {'a':4, 'b':6, 'c':3}) self.assertEqual(f, orig) #note that list of strings will use the strings as keys r = f + ['abc', 'def', 'abc'] self.assertEqual(r, {'a':3, 'b':4, 'abc':2, 'def':1}) self.assertEqual(f, f) def test_isub(self): """Freqs -= should subtract in place using any known data type""" f = self.ClassToTest({'a':5, 'b':4}) f -= 'aba' self.assertEqual(f, {'a':3, 'b':3,}) f -= ['b','b'] self.assertEqual(f, {'a':3, 'b':1}) f -= {'c':-2, 'a':-3} self.assertEqual(f, {'a':6, 'b':1, 'c':2}) f -= (('a',3),('b',-2)) self.assertEqual(f, {'a':3, 'b':3, 'c':2}) f -= [['a', 'b', 'b'],['c', 'c']] self.assertEqual(f, {'a':2, 'b':1, 'c':0}) f['abc'] = 3 f['def'] = 10 #note that list of strings will use the strings as keys f -= ['abc', 'def', 'abc'] self.assertEqual(f, {'a':2, 'b':1, 'c':0, 'abc':1, 'def':9}) def test_sub(self): """Freqs - should make new object, subtracting using any known data type""" orig = {'a':3, 'b':4} f = self.ClassToTest(orig) self.assertEqual(f, orig) r = f - 'aba' self.assertEqual(r, {'a':1, 'b':3}) self.assertEqual(f, orig) r = f - ['b','b'] self.assertEqual(r, {'a':3, 'b':2}) self.assertEqual(f, orig) r = f - {'c':-10, 'a':3} self.assertEqual(r, {'a':0, 'b':4, 'c':10}) self.assertEqual(f, orig) r = f - (('a',3),('b',-2)) self.assertEqual(r, {'a':0, 'b':6}) self.assertEqual(f, orig) r = f - [['a', 'b', 'b'],['a','a']] self.assertEqual(r, {'a':0, 'b':2}) self.assertEqual(f, orig) #note that list of strings will use the strings as keys orig['abc'] = 5 orig['def'] = 10 f['abc'] = 5 f['def'] = 10 r = f - ['abc', 'def', 'abc'] self.assertEqual(r, {'a':3, 'b':4, 'abc':3, 'def':9}) self.assertEqual(f, orig) def test_copy(self): """Freqs copy should preserve class of original""" d = {'a':4, 'b':3, 'c':6} f = self.ClassToTest(d) g = f.copy() self.assertEqual(d, f) self.assertEqual(d, g) self.assertEqual(f, g) self.assertEqual(f.__class__, g.__class__) def test_str(self): """Freqs should print as tab-delimited table, or 'Empty'""" #should work with empty freq distribution self.assertEqual(str(self.ClassToTest([])), \ "Empty frequency distribution") #should work with single element self.assertEqual(str(self.ClassToTest({'X':1.0})), \ "Value\tCount\nX\t1.0") #should work with multiples of same key self.assertEqual(str(self.ClassToTest({1.0:5.0})), \ "Value\tCount\n1.0\t5.0") #should work with different keys self.assertEqual(str(self.ClassToTest({0:3.0,1:2.0})), \ "Value\tCount\n0\t3.0\n1\t2.0") def test_delitem(self): """Freqs delitem should refuse to delete a required key""" a = self.Alphabetic del a['a'] self.assertEqual(a, {'b':2, 'c':1, 'd':1, 'e':1}) #can't delete RequiredKeys once set a.RequiredKeys = 'bcd' del a['e'] self.assertEqual(a, {'b':2,'c':1,'d':1}) for k in 'bcd': self.assertRaises(KeyError, a.__delitem__, k) #when RequiredKeys is removed, can delete them again a.RequiredKeys = None del a['b'] self.assertEqual(a, {'c':1,'d':1}) #The following test custom methods def test_rekey(self): """Freqs rekey should map the results onto new keys.""" d = self.ClassToTest({'a':3, 'b':5, 'c':6, 'd':7, 'e':1}) f = d.rekey({'a':'+', 'b':'-', 'c':'+'}) self.assertEqual(f, {'+':9, '-':5, None:8}) self.assertEqual(f.__class__, d.__class__) #check with explicit constructor and default d = self.ClassToTest({'a':3, 'b':5, 'c':6, 'd':7, 'e':1}) f = d.rekey({'a':'+', 'b':'-', 'c':'+'}, default='x', constructor=dict) self.assertEqual(f, {'+':9, '-':5, 'x':8}) self.assertEqual(f.__class__, dict) def test_purge(self): """Freqs purge should have no effect unless RequiredKeys set.""" working = self.PosNeg.copy() self.assertEqual(working, self.PosNeg) working.purge() self.assertEqual(working, self.PosNeg) working.RequiredKeys=(-2,-1) working[-2] = 3 working.purge() self.assertEqual(working, {-2:3,-1:1}) #should have no effect if repeated working.purge() self.assertEqual(working, {-2:3,-1:1}) def test_normalize(self): """Freqs should allow normalization on any type""" self.Empty.normalize() self.assertEqual(self.Empty, {}) a = self.Alphabetic.copy() a.normalize() expected = {'a':0.375, 'b':0.25, 'c':0.125, 'd':0.125, 'e':0.125} for key, val in expected.items(): self.assertFloatEqual(a[key], val) self.PosNeg.normalize() expected = {-2:0.25, -1:0.25, 1:0.25, 2:0.25} for key, val in expected.items(): self.assertFloatEqual(self.PosNeg[key], val) #check that it works when we specify a total self.PosNeg.normalize(total=0.2) expected = {-2:1.25, -1:1.25, 1:1.25, 2:1.25} for key, val in expected.items(): self.assertFloatEqual(self.PosNeg[key], val) #check that purging works a = self.Alphabetic.copy() a.RequiredKeys = 'ac' a.normalize() self.assertEqual(a, {'a':0.75, 'c':0.25}) a = self.Alphabetic.copy() a.RequiredKeys = 'ac' a.normalize(purge=False) self.assertEqual(a, \ {'a':0.375, 'b':0.25, 'c':0.125, 'd':0.125, 'e':0.125}) #normalize should also create keys when necessary a.RequiredKeys = 'bdex' a.normalize(purge=True) self.assertEqual(a, {'b':0.5, 'd':0.25, 'e':0.25, 'x':0}) def test_choice(self): """Freqs choice should work as expected""" self.Alphabetic.normalize() keys = self.Alphabetic.keys() vals = Numbers(self.Alphabetic.values()) vals.accumulate() #test first item self.assertEqual(self.Alphabetic.choice(-1), keys[0]) self.assertEqual(self.Alphabetic.choice(-0.0001), keys[0]) self.assertEqual(self.Alphabetic.choice(-1e300), keys[0]) self.assertEqual(self.Alphabetic.choice(0), keys[0]) #test last item last_val = vals.pop() self.assertEqual(self.Alphabetic.choice(last_val), keys[-1]) self.assertEqual(self.Alphabetic.choice(1000), keys[-1]) #test remaining items for index, value in enumerate(vals): self.assertEqual(self.Alphabetic.choice(value-0.01),keys[index]) self.assertEqual(self.Alphabetic.choice(value+0.01), keys[index+1]) def test_randomSequence_good(self): """Freqs randomSequence should give correct counts""" self.Alphabetic.normalize() total = self.Alphabetic.Sum keys = self.Alphabetic.keys() probs = [float(i)/total for i in self.Alphabetic.values()] rand_seq = self.Alphabetic.randomSequence(10000) observed = [rand_seq.count(key) for key in keys] expected = [prob*10000 for prob in probs] self.assertSimilarFreqs(observed, expected) def test_randomSequence_bad(self): """Empty Freqs should raise error on randomSequence""" self.assertRaises(IndexError, self.Empty.randomSequence, 5) def test_randomSequence_one_item(self): """Freqs randomSequence should work with one key""" self.Constant.normalize() rand = self.Constant.randomSequence(1000) self.assertEqual(rand.count(1), 1000) self.assertEqual(len(rand), 1000) def test_subset_preserve(self): """Freqs subset should preserve unwanted items""" self.Constant.subset('abc') self.assertEqual(self.Constant, self.Empty) self.Alphabetic.subset('abx') self.assertEqual(self.Alphabetic, Freqs('aaabb')) def test_subset_remove(self): """Freqs subset should delete unwanted items if asked""" self.Alphabetic.subset('abx', keep=False) self.assertEqual(self.Alphabetic, Freqs('cde')) self.Constant.subset('abx', keep=False) self.assertEqual(self.Constant, Freqs([1]*5)) def test_scale(self): """Freqs scale should multiply all values with the given scale""" f = self.ClassToTest({'a':0.25,'b':0.25}) f.scale(10) self.assertEqual(f,{'a':2.5,'b':2.5}) f.scale(100) self.assertEqual(f,{'a':250, 'b':250}) f.scale(0.001) self.assertEqual(f,{'a':0.25,'b':0.25}) def test_round(self): """Freqs round should round all frequencies to integers""" f = self.ClassToTest({'a':23.1, 'b':12.5, 'c':56.7}) f.round() self.assertEqual(f,{'a':23, 'b':13, 'c':57}) g = Freqs({'a':23.1356, 'b':12.5731}) g.round(3) self.assertEqual(g,{'a':23.136, 'b':12.573}) def test_expand(self): """Freqs expand should give expected results""" f = self.ClassToTest({'U':3, 'A':5, 'C':2}) self.assertEqual(f.expand(order='UAC'), list('UUUAAAAACC')) self.assertEqual(f.expand(order='GCU'), list('CCUUU')) self.assertEqual(f.expand(order='ACU',convert_to=''.join),'AAAAACCUUU') del f['A'] self.assertEqual(f.expand(order='UAC'), list('UUUCC')) f.normalize() self.assertEqual(f.expand(order='ACU'), ['U']) self.assertEqual(f.expand(convert_to=''.join), 'U') f.normalize(total=1.0/20) self.assertEqual(f.expand(order='UCA'), list('U'*12 + 'C'*8)) #test expand with scaling g = self.ClassToTest({'A':0.5,'G':0.5}) self.assertEqual(g.expand(order='AG'),['A','G']) self.assertEqual(g.expand(order='AG',scale=10),list(5*'A'+5*'G')) self.assertRaises(ValueError,g.expand,scale=33) def test_Count(self): """Freqs Count should return correct count (number of categories)""" self.assertEqual(self.Alphabetic.Count, 5) self.assertEqual(self.NumericDuplicated.Count, 3) self.assertEqual(self.Empty.Count, 0) self.assertEqual(self.Constant.Count, 1) def test_Sum(self): """Freqs Sum should return sum of item counts in all categories""" self.assertEqual(self.Alphabetic.Sum, 8) self.assertEqual(self.NumericUnique.Sum, 5) self.assertEqual(self.NumericDuplicated.Sum, 4) self.assertEqual(self.Empty.Sum, 0) # WARNING: For numeric keys, the value of the key is not taken into # account (i.e. each key counts as a separate category) self.assertEqual(self.PosNeg.Sum, 4) self.assertEqual(self.Constant.Sum, 5) def test_SumSquares(self): """Freqs SumSquared should return sum of squared freq of each category""" self.assertEqual(self.Alphabetic.SumSquares, 16) self.assertEqual(self.NumericUnique.SumSquares, 5) self.assertEqual(self.NumericDuplicated.SumSquares, 6) self.assertEqual(self.Empty.SumSquares, 0) self.assertEqual(self.PosNeg.SumSquares, 4) self.assertEqual(self.Constant.SumSquares, 25) def test_Variance(self): """Freqs Variance should return variance of counts in categories""" self.assertFloatEqual(self.Alphabetic.Variance, 0.8) self.assertFloatEqual(self.NumericUnique.Variance, 0) self.assertFloatEqual(self.NumericDuplicated.Variance, 1.0/3) self.assertFloatEqual(self.Empty.Variance, None) self.assertFloatEqual(self.PosNeg.Variance, 0) self.assertEqual(self.Constant.Variance, 0) def test_StandardDeviation(self): """Freqs StandardDeviation should return stdev of counts in categories""" self.assertFloatEqual(self.Alphabetic.StandardDeviation, sqrt(0.8)) self.assertFloatEqual(self.NumericUnique.StandardDeviation, 0) self.assertFloatEqual(self.NumericDuplicated.StandardDeviation, \ sqrt(1.0/3)) self.assertFloatEqual(self.Empty.StandardDeviation, None) self.assertFloatEqual(self.PosNeg.StandardDeviation, 0) self.assertEqual(self.Constant.StandardDeviation, 0) def test_Mean(self): """Freqs Mean should return mean of counts in categories""" self.assertEqual(self.Alphabetic.Mean, 8/5.0) self.assertEqual(self.NumericUnique.Mean, 1) self.assertEqual(self.NumericDuplicated.Mean, 4/3.0) self.assertEqual(self.Empty.Mean, None) self.assertEqual(self.PosNeg.Mean, 1) self.assertEqual(self.Constant.Mean, 5) def test_Uncertainty(self): """Freqs Shannon uncertainty values should match spreadsheet""" self.assertEqual(self.Empty.Uncertainty, 0) self.assertFloatEqual(self.Alphabetic.Uncertainty, 2.1556, eps=1e-4) self.assertFloatEqual(self.PosNeg.Uncertainty, 2) self.assertFloatEqual(self.NumericDuplicated.Uncertainty, 1.5) self.assertFloatEqual(self.NumericUnique.Uncertainty, 2.3219, eps=1e-4) self.assertFloatEqual(self.Constant.Uncertainty, 0) def test_mode(self): """Freqs mode should return most frequent item""" self.assertEqual(self.Empty.Mode, None) self.assertEqual(self.Alphabetic.Mode, 'a') assert(self.PosNeg.Mode in self.PosNeg) assert(self.NumericUnique.Mode in self.NumericUnique) self.assertEqual(self.NumericDuplicated.Mode, 1.5) self.assertEqual(self.Constant.Mode, 1) def test_summarize(self): """Freqs summarize should return Summary: Count, Sum, SumSquares, Var""" self.assertEqual(self.Empty.summarize(), SummaryStatistics()) s = self.Alphabetic.summarize() self.assertEqual(s.Sum, 8) self.assertEqual(s.Count, 5) self.assertEqual(s.SumSquares, 16) self.assertFloatEqual(s.Variance, 0.8) self.assertFloatEqual(s.StandardDeviation, sqrt(0.8)) self.assertFloatEqual(s.Mean, 8.0/5) def test_getSortedList(self): """Freqs getSortedList should return sorted list of key, val tuples""" e = self.Empty self.assertEqual(e.getSortedList(), []) self.assertEqual(e.getSortedList(descending=True), []) self.assertEqual(e.getSortedList(descending=False), []) self.assertEqual(e.getSortedList(by_val=True), []) self.assertEqual(e.getSortedList(by_val=False), []) a = self.Alphabetic a['b'] = 5 self.assertEqual(a.getSortedList(), \ [('b',5),('a',3),('e',1),('d',1),('c',1)]) self.assertEqual(a.getSortedList(descending=True), \ [('b',5),('a',3),('e',1),('d',1),('c',1)]) self.assertEqual(a.getSortedList(descending=False), \ [('c',1),('d',1),('e',1),('a',3),('b',5)]) self.assertEqual(a.getSortedList(by_val=False), \ [('e',1),('d',1),('c',1),('b',5),('a',3)]) self.assertEqual(a.getSortedList(by_val=False, descending=False), \ [('a',3),('b',5),('c',1),('d',1),('e',1)]) class FreqsTests(FreqsTestsI, TestCase): """Tests of Freqs-specific behavior, mostly validation.""" ClassToTest = Freqs def setUp(self): """defines some standard frequency distributions to check""" self.Alphabetic = self.ClassToTest('abcdeaab') self.NumericUnique = self.ClassToTest([1,2,3,4,5]) self.NumericDuplicated = self.ClassToTest([1, 1.5, 1.5, 3.5]) self.Empty = self.ClassToTest('') self.PosNeg = self.ClassToTest([-2, -1, 1, 2]) self.Constant = self.ClassToTest([1]*5) def test_isValid_bad(self): """Freqs should reject invalid data, so isValid() always True""" self.assertRaises(ConstraintError, self.ClassToTest, {'a':3, 'b':-10}) def test_init_empty(self): """Freqs should initialize OK with empty list""" self.assertEqual(self.ClassToTest([]), {}) def test_init_single(self): """Freqs should initialize OK with single item""" self.assertEqual(self.ClassToTest(['X']), {'X':1.0}) def test_init_same_key(self): """Freqs should initialize OK with duplicate items""" self.assertEqual(self.ClassToTest([1]*5), {1:5}) def test_init_two_keys(self): """Freqs should initialize OK with distinct items""" self.assertEqual(self.ClassToTest([0,1,0,0,1]), {1:2,0:3}) def test_init_strings(self): """Freqs should initialize OK with characters in string""" self.assertEqual(self.ClassToTest('zabcz'), {'z':2,'a':1,'b':1,'c':1}) def test_init_fails_negative(self): """Freqs init should fail on negative frequencies""" self.assertRaises(ConstraintError, self.ClassToTest, {'a':3, 'b':-3}) def test_init_from_dict(self): """Freqs should init OK from dictionary""" self.assertEqual(self.ClassToTest({'a':3,'b':2}), {'a':3, 'b':2}) def test_init_from_dicts(self): """Freqs should init OK from list of dicts""" self.assertEqual(self.ClassToTest([{'a':1,'b':1}, {'a':2,'b':1}]), \ {'a':3, 'b':2}) def test_init_from_strings(self): """Freqs should init OK from list of strings""" self.assertEqual(self.ClassToTest(['abc','def','abc']), \ {'abc':2,'def':1}) def test_init_from_tuples(self): """Freqs should init OK from list of key-value pairs""" self.assertEqual(self.ClassToTest([('a',3),('b',10),('a',2)]), \ {'a':5,'b':10}) def test_init_alphabet_success(self): """Freqs should init ok with keys matching alphabet""" fd = self.ClassToTest('abc', Constraint='abcd') self.assertEqual(fd, {'a':1,'b':1,'c':1}) self.assertRaises(ConstraintError, fd.setdefault, 'x', 1) self.assertRaises(ConstraintError, fd.__setitem__, 'x', 1) def test_init_alphabet_failure(self): """Freqs should fail if keys don't match alphabet""" try: f = Freqs('abcd', Constraint='abc') except ConstraintError: pass else: self.fail() def test_setitem_bad(self): """Freqs should not allow negative values""" self.assertRaises(ConstraintError, self.Empty.__setitem__, 'xyz', -0.01) def test_setdefault_bad(self): """Freqs setdefault should fail if default < 0""" self.assertRaises(ConstraintError, self.Empty.setdefault, 'a', -1) self.assertRaises(ConstraintError, self.Empty.setdefault, 'a', -0.00001) self.assertRaises(ConstraintError, self.Empty.setdefault, 'a', "-1") self.assertRaises(ConstraintError, self.Empty.setdefault, 'a', "xxxx") class UnsafeFreqsTests(FreqsTestsI, TestCase): """Tests of UnsafeFreqs-specific behavior, mostly validation.""" ClassToTest = UnsafeFreqs def setUp(self): """defines some standard frequency distributions to check""" self.Alphabetic = self.ClassToTest({'a':3,'b':2,'c':1,'d':1,'e':1}) self.NumericUnique = self.ClassToTest({'1':1,'2':1,'3':1,'4':1,'5':1}) self.NumericDuplicated = self.ClassToTest({1:1, 1.5:2, 3.5:1}) self.Empty = self.ClassToTest({}) self.PosNeg = self.ClassToTest({-2:1, -1:1, 1:1, 2:1}) self.Constant = self.ClassToTest({1:5}) def test_isValid_bad(self): """UnsafeFreqs should allow invalid data, returning False for isValid""" d = self.ClassToTest({'a':3, 'b':'x'}) assert not d.isValid() def test_init_empty(self): """UnsafeFreqs should initialize OK with empty list""" self.assertEqual(self.ClassToTest([]), {}) def test_init_single(self): """UnsafeFreqs init FAILS with single item""" self.assertRaises(ValueError, self.ClassToTest, ['X']) def test_init_same_key(self): """UnsafeFreqs init FAILS with list of items""" self.assertRaises(TypeError, self.ClassToTest, [1]*5) def test_init_strings(self): """UnsafeFreqs init FAILS with string""" self.assertRaises(ValueError, self.ClassToTest, 'zabcz') def test_init_negative(self): """UnsafeFreqs init should SUCCEED on negative frequencies""" self.assertEqual(self.ClassToTest({'a':3, 'b':-3}), {'a':3,'b':-3}) def test_init_from_dict(self): """UnsafeFreqs should init OK from dictionary""" self.assertEqual(self.ClassToTest({'a':3,'b':2}), {'a':3, 'b':2}) def test_init_from_dicts(self): """UnsafeFreqs init should init LIKE A DICT from list of dicts""" # WARNING: Note the difference between this and Freqs init! self.assertEqual(self.ClassToTest([{'a':1,'b':1}, {'a':2,'b':1}]), \ {'a':'b'}) def test_init_from_strings(self): """UnsafeFreqs init should FAIL from list of strings""" self.assertRaises(ValueError, self.ClassToTest, ['abc','def','abc']) def test_init_from_tuples(self): """UnsafeFreqs should init LIKE A DICT from list of key-value pairs""" # WARNING: Note the difference between this and Freqs init! self.assertEqual(self.ClassToTest([('a',3),('b',10),('a',2)]), \ {'a':2,'b':10}) class FreqsSubclassTests(TestCase): """Freqs subclassing should work correctly, esp. with RequiredKeys.""" class BaseFreqs(Freqs): RequiredKeys = 'UCAG' def test_init(self): """Freqs subclass init should add RequiredKeys""" b = self.BaseFreqs() self.assertEqual(b, {'U':0.0,'C':0.0,'A':0.0,'G':0.0}) self.assertEqual(self.BaseFreqs('UUCCCCAAAabc'), \ {'U':2, 'C':4, 'A':3, 'a':1, 'b':1, 'c':1, 'G':0}) def test_delitem(self): """Freqs subclass delitem shouldn't allow deletion of RequiredKeys""" b = self.BaseFreqs('AAGCg') self.assertEqual(b, {'A':2,'G':1,'C':1,'U':0,'g':1}) del b['g'] self.assertEqual(b, {'A':2,'G':1,'C':1,'U':0}) self.assertRaises(KeyError, b.__delitem__, 'A') def test_purge(self): """Freqs subclass purge should eliminate anything not in RequiredKeys""" b = self.BaseFreqs('AjaknadjkAjnjndfjndCnjdjsfnfdsjkC32478737&#^&@GGGG') b.purge() self.assertEqual(b, {'A':2,'C':2,'G':4, 'U':0}) b.purge() self.assertEqual(b, {'A':2,'C':2,'G':4, 'U':0}) def test_normalize(self): """Freqs subclass normalize should optionally elminate non-required keys""" b = self.BaseFreqs('UUUCX') b.normalize(purge=False) self.assertEqual(b, {'U':0.6, 'C':0.2, 'X':0.2, 'A':0, 'G':0}) b.normalize(purge=True) self.assertFloatEqual(b, {'U':0.75, 'C':0.25, 'A':0, 'G':0}) b = self.BaseFreqs() b.normalize() self.assertEqual(b, {'U':0, 'C':0, 'A':0, 'G':0}) class NumberFreqsTestsI(object): """Interface for tests of safe and unsafe NumberFreqs classes.""" ClassToTest = None def setUp(self): """defines some standard frequency distributions to check""" self.NumericUnique = self.ClassToTest([1,2,3,4,5]) self.NumericDuplicated = self.ClassToTest([1, 1.5, 1.5, 3.5]) self.Empty = self.ClassToTest('') self.PosNeg = self.ClassToTest([-2, -1, 1, 2]) self.Constant = self.ClassToTest([1]*5) def test_setitem_good(self): """NumberFreqs should allow non-negative values to be set""" self.Empty[3] = 0 self.assertEqual(self.Empty, {3:0}) def test_add_good(self): """NumberFreqs should allow addition of counts or items""" self.Empty += [1]*5 self.assertEqual(self.Empty, {1:5}) def test_Mean(self): """NumberFreqs means should match hand-calculated values""" self.assertEqual(self.Empty.Mean, None) self.assertFloatEqual(self.NumericUnique.Mean, 15.0/5) self.assertFloatEqual(self.NumericDuplicated.Mean, 7.5/4) self.assertFloatEqual(self.PosNeg.Mean, 0.0) self.assertFloatEqual(self.Constant.Mean, 1.0) def test_Variance(self): """NumberFreqs variance should match values from R.""" self.assertEqual(None, self.Empty.Variance) self.assertFloatEqual(2.5, self.NumericUnique.Variance) self.assertFloatEqual(1.229167, self.NumericDuplicated.Variance) self.assertFloatEqual(10/3.0, self.PosNeg.Variance) self.assertFloatEqual(0, self.Constant.Variance) def test_Sum(self): """NumberFreqs sums should match hand-calculated values""" self.assertEqual(self.Empty.Sum, None) self.assertFloatEqual(self.NumericUnique.Sum, 15) self.assertFloatEqual(self.NumericDuplicated.Sum, 7.5) self.assertFloatEqual(self.PosNeg.Sum, 0.0) self.assertFloatEqual(self.Constant.Sum, 5.0) def test_Count(self): """NumberFreqs counts should match hand-calculated values""" self.assertEqual(self.NumericUnique.Count, 5) self.assertEqual(self.NumericDuplicated.Count, 4) self.assertEqual(self.Empty.Count, 0) self.assertEqual(self.PosNeg.Count, 4) self.assertEqual(self.Constant.Count, 5) def test_Sumsq(self): """NumberFreqs sum of squares should match spreadsheet""" self.assertEqual(self.Empty.SumSquares, None) self.assertFloatEqual(self.NumericUnique.SumSquares, 55.0) self.assertFloatEqual(self.NumericDuplicated.SumSquares, 17.75) self.assertFloatEqual(self.PosNeg.SumSquares, 10.0) self.assertFloatEqual(self.Constant.SumSquares, 5.0) def test_Stdev(self): """NumberFreqs stdev should match spreadsheet""" self.assertEqual(self.Empty.StandardDeviation, None) self.assertFloatEqual(self.NumericUnique.StandardDeviation,1.581139) self.assertFloatEqual(self.NumericDuplicated.StandardDeviation,1.108678) self.assertFloatEqual(self.PosNeg.StandardDeviation, 1.825742) self.assertFloatEqual(self.Constant.StandardDeviation, 0.0) def test_NumberFreqsQuantiles(self): """quantiles should match Numbers, including Median""" data={32: 60L, 33: 211L, 34: 141L, 35: 70L, 36: 26L, 10: 30L, 11: 5L, 18: 43L, 19: 10L, 21: 1L, 22: 1L, 23: 58L, 24: 12L, 25: 3L, 26: 74L, 27: 10L, 28: 77L, 29: 20L, 30: 102L, 31: 47L} nums = Numbers(NumberFreqs(data=data).expand()) number_freqs = self.ClassToTest() number_freqs.update(data) for quantile in numpy.arange(0.05, 0.96, 0.05): num_q = nums.quantile(quantile) num_f = number_freqs.quantile(quantile) self.assertFloatEqual(num_f, num_q) self.assertFloatEqual(number_freqs.Median, nums.Median) def test_normalize(self): """NumberFreqs should allow normalization on any type""" self.Empty.normalize() self.assertEqual(self.Empty, {}) # will refuse to normalize if sum is 0 orig = self.PosNeg.copy() self.PosNeg.normalize() self.assertEqual(self.PosNeg, orig) # will normalize OK if total passed in self.PosNeg.normalize(4) #self.PosNeg.Count) expected = {-2:0.25, -1:0.25, 1:0.25, 2:0.25} for key, val in expected.items(): self.assertFloatEqual(self.PosNeg[key], val) def test_Uncertainty(self): """NumberFreqs Shannon entropy values should match spreadsheet""" self.assertEqual(self.Empty.Uncertainty, 0) self.assertEqual(self.PosNeg.Uncertainty, 2) self.assertEqual(self.NumericDuplicated.Uncertainty, 1.5) self.assertEqual("%6.4f" % self.NumericUnique.Uncertainty, '2.3219') self.assertEqual(self.Constant.Uncertainty, 0) def test_Mode(self): """NumberFreqs mode should return most frequent item""" self.assertEqual(self.Empty.Mode, None) assert(self.PosNeg.Mode in self.PosNeg) assert(self.NumericUnique.Mode in self.NumericUnique) self.assertEqual(self.NumericDuplicated.Mode, 1.5) self.assertEqual(self.Constant.Mode, 1) def test_randomSequence_one_item(self): """NumberFreqs randomSequence should work with one key""" self.Constant.normalize() rand = self.Constant.randomSequence(1000) self.assertEqual(rand.count(1), 1000) self.assertEqual(len(rand), 1000) class NumberFreqsTests(NumberFreqsTestsI, TestCase): """Tests of (safe) NumberFreqs classes.""" ClassToTest = NumberFreqs def setUp(self): """defines some standard frequency distributions to check""" self.NumericUnique = self.ClassToTest([1,2,3,4,5]) self.NumericDuplicated = self.ClassToTest([1, 1.5, 1.5, 3.5]) self.Empty = self.ClassToTest() self.PosNeg = self.ClassToTest([-2, -1, 1, 2]) self.Constant = self.ClassToTest([1]*5) def test_setitem_bad(self): """NumberFreqs should not allow non-numeric values""" self.assertRaises(ValueError, self.Empty.__setitem__, 'xyz', -0.01) def test_add_bad(self): """NumberFreqs add should fail if key not numeric""" self.assertRaises(ValueError, self.Empty.__iadd__, {'a':-1}) class UnsafeNumberFreqsTests(NumberFreqsTestsI, TestCase): """Tests of UnsafeNumberFreqs classes.""" ClassToTest = UnsafeNumberFreqs def setUp(self): """defines some standard frequency distributions to check""" self.NumericUnique = self.ClassToTest({1:1,2:1,3:1,4:1,5:1}) self.NumericDuplicated = self.ClassToTest({1:1,1.5:2,3.5:1}) self.Empty = self.ClassToTest() self.PosNeg = self.ClassToTest({-2:1,-1:1,1:1,2:1}) self.Constant = self.ClassToTest({1:5}) #execute tests if called from command line if __name__ == '__main__': main()