#!/usr/bin/env python
"""Tests of transformation and composition functions .
"""
from cogent.util.unit_test import TestCase, main
from cogent.util.misc import identity
from cogent.util.transform import apply_each, bools, bool_each, \
    conjoin, all, both,\
    disjoin, any, either, negate, none, neither, compose, compose_many, \
    per_shortest, per_longest, for_seq, \
    has_field, extract_field, test_field, index, test_container, \
    trans_except, trans_all, make_trans, find_any, find_no, find_all,\
    keep_if_more, exclude_if_more, keep_if_more_other, exclude_if_more_other,\
    keep_chars,exclude_chars, reorder, reorder_inplace, float_from_string,\
    first, last, first_in_set, last_in_set, first_not_in_set, last_not_in_set,\
    first_index, last_index, first_index_in_set, last_index_in_set, \
    first_index_not_in_set, last_index_not_in_set, perm, comb, cross_comb, _increment_comb

__author__ = "Sandra Smit"
__copyright__ = "Copyright 2007-2009, The Cogent Project"
__credits__ = ["Rob Knight", "Sandra Smit", "Zongzhi Liu"]
__license__ = "GPL"
__version__ = "1.4.1"
__maintainer__ = "Sandra Smit"
__email__ = "sandra.smit@colorado.edu"
__status__ = "Production"

class has_x(object):
    #convenience class for has_field and related functions
    def __init__(self, x):
        self.x = x
    def __hash__(self):
        return hash(self.x)
    def __str__(self):
        return str(self.x)

class has_y(object):
    #convenience class for has_field and related functions
    def __init__(self, y):
        self.y = y
    def __hash__(self):
        return hash(self.y)
    def __str__(self):
        return str(self.y)


class metafunctionsTests(TestCase):
    """Tests of standalone functions."""
    def setUp(self):
        """Define some standard functions and data."""
        self.Numbers = range(20)
        self.SmallNumbers = range(3)
        self.SmallNumbersRepeated = range(5) * 4
        self.Letters = 'abcde'
        self.Mixed = list(self.Letters) + range(5)
        self.firsts = 'ab2'
        self.seconds = '0bc'

        self.is_char = lambda x: isinstance(x, str) and len(x) == 1
        self.is_vowel = lambda x: x in 'aeiou'
        self.is_consonant = lambda x: x not in 'aeiuo'
        self.is_number = lambda x: isinstance(x, int)
        self.is_odd_number = lambda x: x%2
        self.is_odd_letter = lambda x: x in 'acegikmoqs'
        self.is_zero = lambda x: x == 0
        self.is_small = lambda x: x < 3
        self.double = lambda x: x * 2
        self.minusone = lambda x: x - 1

        #function to test *args, **kwargs)
        self.is_alpha_digit = lambda first, second: \
            first.isalpha() and second.isdigit()
        self.is_digit_alpha = lambda first, second: \
            first.isdigit() and second.isalpha()

    def test_apply_each(self):
        """apply_each should apply each function to args, kwargs"""
        self.assertEqual(apply_each( \
            [self.is_char, self.is_vowel, self.is_consonant, self.is_number], \
            self.Letters[0]), [True, True, False, False])
            
        self.assertEqual(apply_each( \
            [self.is_char, self.is_vowel, self.is_consonant, self.is_number], \
            self.Letters[1]), [True, False, True, False])

        self.assertEqual(apply_each( \
            [self.double, self.minusone], self.SmallNumbers[0]), [0, -1])

        self.assertEqual(apply_each( \
            [self.double, self.minusone], self.SmallNumbers[1]), [2, 0])

        expects = [[True, False], [False, False], [False, True]]
        for i in range(len(expects)):
            self.assertEqual(apply_each( \
                [self.is_alpha_digit, self.is_digit_alpha], 
                self.firsts[i], self.seconds[i]), expects[i])
            self.assertEqual(apply_each( \
                [self.is_alpha_digit, self.is_digit_alpha], 
                self.firsts[i], second=self.seconds[i]), expects[i])
            self.assertEqual(apply_each( \
                [self.is_alpha_digit, self.is_digit_alpha], 
                second=self.seconds[i], first=self.firsts[i]), expects[i])

    def test_bools(self):
        """bools should convert items to True or False."""
        self.assertEqual(bools(self.Letters), [True]*5)
        self.assertEqual(bools(self.Numbers), [False] + [True]*19)

    def test_bool_each(self):
        """bool_each should return boolean version of applying each f to args"""
        self.assertEqual(bool_each([self.double, self.minusone], \
            self.SmallNumbers[0]), [False, True])

        self.assertEqual(bool_each([self.double, self.minusone], \
            self.SmallNumbers[1]), [True, False])

    def test_conjoin(self):
        """conjoin should return True if all components True"""
        self.assertEqual(conjoin([self.is_odd_letter,self.is_vowel],'a'), True)
        self.assertEqual(conjoin([self.is_odd_letter,self.is_vowel], x='b'), 
            False)
        self.assertEqual(conjoin([self.is_odd_letter,self.is_vowel],'c'), False)
        self.assertEqual(conjoin([self.is_odd_letter,self.is_vowel],'e'), True)
        #technically, this one should be true as well, but I left it off to 
        #have an even vowel test case...
        self.assertEqual(conjoin([self.is_odd_letter,self.is_vowel],'u'), False)
        #should short-circuit, i.e. not evaluate later cases after False
        self.assertEqual(conjoin([self.is_odd_letter, self.fail], 'b'), False)
        self.assertRaises(AssertionError, conjoin, \
            [self.is_odd_letter, self.fail], 'a')
        
    def test_all(self):
        """all should return a function returning True if all components True"""
        odd_vowel = all([self.is_odd_letter, self.is_vowel, self.is_char])
        self.assertEqual(odd_vowel('a'), True)
        self.assertEqual(map(odd_vowel, 'abceu'), 
            [True,False,False,True,False])
        odd_number = all([self.is_odd_number, self.is_number])
        self.assertEqual(map(odd_number, range(5)), [False,True]*2+[False])
        #should short-circuit, i.e. not evaluate later cases after False
        self.assertEqual(all([self.is_odd_letter, self.fail])('b'), False)
        self.assertRaises(AssertionError, all([self.is_odd_letter,self.fail]),\
            'a')

    def test_both(self):
        """both should return True if both components True"""
        odd_vowel = both(self.is_odd_letter, self.is_vowel)
        self.assertEqual(map(odd_vowel, 'abcu'), [True,False,False,False])
        #should short-circuit
        self.assertEqual(both(self.is_odd_letter, self.fail)('b'), False)
        self.assertRaises(AssertionError, both(self.is_odd_letter, self.fail),\
            'a')

    def test_disjoin(self):
        """disjoin should return True if any component True"""
        self.assertEqual(disjoin([self.is_odd_letter,self.is_vowel], 'a'), True)
        self.assertEqual(disjoin([self.is_odd_letter,self.is_vowel], 'b'),False)
        self.assertEqual(disjoin([self.is_odd_letter,self.is_vowel], 'c'), True)
        self.assertEqual(disjoin([self.is_odd_letter,self.is_vowel], x='u'),
            True)
        #should short-circuit after first True
        self.assertEqual(disjoin([self.is_odd_letter, self.fail], 'a'), True)
        self.assertRaises(AssertionError, \
            disjoin, [self.is_odd_letter, self.fail], 'b')
        
    def test_any(self):
        """any should return a function returning True if any component True"""
        odd_vowel = any([self.is_odd_letter, self.is_vowel])
        self.assertEqual(odd_vowel('a'), True)
        self.assertEqual(map(odd_vowel, 'abceu'), [True,False,True,True,True])
        odd = any([self.is_odd_number, self.is_small])
        self.assertEqual(map(odd, range(5)), [True]*4+[False])
        #should short-circuit after first True
        self.assertEqual(any([self.is_odd_letter, self.fail])(x='a'), True)
        self.assertRaises(AssertionError, any([self.is_odd_letter,self.fail]),\
            'b')

    def test_either(self):
        """either should return function returning True if either component True"""
        odd_vowel = either(self.is_odd_letter, self.is_vowel)
        self.assertEqual(map(odd_vowel, 'abcu'), [True,False,True,True])
        #should short-circuit
        self.assertEqual(either(self.is_odd_letter, self.fail)(x='a'), True)
        self.assertRaises(AssertionError, \
            either(self.is_odd_letter, self.fail), 'b')
        
    def test_negate(self):
        """negate should return True if no component True"""
        self.assertEqual(negate([self.is_odd_letter,self.is_vowel], 'a'), False)
        self.assertEqual(negate([self.is_odd_letter,self.is_vowel], 'b'), True)
        self.assertEqual(negate([self.is_odd_letter,self.is_vowel], 'c'), False)
        self.assertEqual(negate([self.is_odd_letter,self.is_vowel], 'u'), False)
        #should short-circuit after first True
        self.assertEqual(negate([self.is_odd_letter, self.fail], x='a'), False)
        self.assertRaises(AssertionError, \
            negate, [self.is_odd_letter, self.fail], 'b')
        
    def test_none(self):
        """none should return a function returning True if no component True"""
        odd_vowel = none([self.is_odd_letter, self.is_vowel])
        self.assertEqual(odd_vowel('a'), False)
        self.assertEqual(map(odd_vowel, 'abceu'), [False,True] + [False]*3)
        odd = none([self.is_odd_number, self.is_small])
        self.assertEqual(map(odd, range(5)), [False]*4+[True])
        #should short-circuit after first True
        self.assertEqual(none([self.is_odd_letter, self.fail])(x='a'), False)
        self.assertRaises(AssertionError, none([self.is_odd_letter,self.fail]),\
            'b')

    def test_neither(self):
        """neither should return function returning True if each component False"""
        odd_vowel = neither(self.is_odd_letter, self.is_vowel)
        self.assertEqual(map(odd_vowel, 'abcu'), [False,True,False,False])
        #should short-circuit
        self.assertEqual(neither(self.is_odd_letter, self.fail)(x='a'), False)
        self.assertRaises(AssertionError, \
            neither(self.is_odd_letter, self.fail), 'b')
 
    def test_compose(self):
        """compose should return function returning f(g(x))"""
        ds = compose(self.double, self.minusone)
        sd = compose(self.minusone, self.double)
        self.assertEqual(ds(5), 8)
        self.assertEqual(sd(x=5), 9)
        #check that it works when arg lists are different
        commafy = compose(','.join, list)
        self.assertEqual(commafy('abc'), 'a,b,c')
        self.assertEqual(commafy(''), '')
        self.assertEqual(commafy('a'), 'a')

    def test_compose_many(self):
        """compose_many should return composition of all args"""
        from numpy import arange
        def to_strings(x):
            return map(str, x)
        printable_range = compose_many(''.join, to_strings, range)
        printable_arange = compose_many(''.join, to_strings, arange)
        
        self.assertEqual(printable_range(3), '012')
        self.assertEqual(printable_range(0), '')
        self.assertEqual(printable_range(5), '01234')

        self.assertEqual(printable_arange(stop=51, start=10, step=10),
            '1020304050')

    def test_identity(self):
        """identity should return x"""
        for i in ['a', 'abc', None, '', [], [1], 1, 2**50, 0.3e-50, {'a':3}]:
            assert identity(i) is i
            
    def test_has_field(self):
        """has_field should return True if specified field exists."""
        x = has_x(1)
        y = has_y(1)
        check_x = has_field('x')
        self.assertEqual(check_x(x), True)
        self.assertEqual(check_x(y), False)
        check_y = has_field('y')
        self.assertEqual(check_y(x), False)
        self.assertEqual(check_y(y), True)
        del y.y
        self.assertEqual(check_y(y), False)
        y.x = 3
        self.assertEqual(check_x(y), True)

    def test_extract_field(self):
        """extract_field should apply constructor to field, or return None"""
        num = has_x('1')
        alpha = has_x('x')
        y = has_y('1')
        extractor = extract_field('x')
        self.assertEqual(extractor(num), '1')
        self.assertEqual(extractor(alpha), 'x')
        self.assertEqual(extractor(y), None)

        int_extractor = extract_field('x', int)
        self.assertEqual(int_extractor(num), 1)
        self.assertEqual(int_extractor(alpha), None)
        self.assertEqual(int_extractor(y), None)

    def test_test_field(self):
        """test_field should return boolean result of applying constructor"""
        num = has_x('5')
        alpha = has_x('x')
        zero = has_x(0)
        y = has_y('5')
        
        tester = test_field('x')
        self.assertEqual(tester(num), True)
        self.assertEqual(tester(alpha), True)
        self.assertEqual(tester(y), False)

        int_tester = test_field('x', int)
        self.assertEqual(int_tester(num), True)
        self.assertEqual(int_tester(alpha), False)
        self.assertEqual(int_tester(y), False)
        self.assertEqual(int_tester(zero), False)

    def test_index(self):
        """index should index objects by specified field or identity"""
        num = has_x(5)
        let = has_x('5')
        zer = has_x('0')
        non = has_x(None)
        y = has_y(3)
        items = [num, let, zer, non, y]
        duplicates = items * 3

        basic_indexer = index()
        i = basic_indexer(items)
        self.assertEqual(i, {num:[num], let:[let], zer:[zer], non:[non], y:[y]})
        #test reusability
        i = basic_indexer([3,3,4])
        self.assertEqual(i, {3:[3, 3], 4:[4]})
        #test duplicates
        d = basic_indexer(duplicates)
        self.assertEqual(d, {num:[num]*3, let:[let]*3, zer:[zer]*3, \
            non:[non]*3, y:[y]*3})
        #test with constructor
        str_indexer = index(str)
        i = str_indexer(items)
        self.assertEqual(i, {'5':[num,let], '0':[zer], 'None':[non], '3':[y]})
        #test order correct in duplicates
        i = str_indexer(duplicates)
        self.assertEqual(i, {'5':[num,let,num,let,num,let], '0':[zer,zer,zer],
            'None':[non,non,non], '3':[y,y,y]})
        #test with squashing
        overwriter = index(str, overwrite=True)
        i = overwriter(duplicates)
        self.assertEqual(i, {'5':let, '0':zer, 'None':non, '3':y})

    def test_test_container(self):
        """test_container should return True or False in a typesafe way."""
        test_dict = test_container({'a':1})
        test_list = test_container([1,2,3])
        test_str = test_container('438hfanvr438')

        for item in (1, 2, 3):
            assert test_list(item)
            assert not test_dict(item)
            assert not test_str(item)

        assert test_dict('a')
        assert not test_list('a')
        assert test_str('a')

        for item in ('4', 'h', 'fan'):
            assert not test_dict(item)
            assert not test_list(item)
            assert test_str(item)

        for item in (['x','y'],{},{'a':3},'@#@',('a','b'),None,False):
            assert not test_dict(item)
            assert not test_list(item)
            assert not test_str(item)

class SequenceFunctionsTests(TestCase):
    """Tests of standalone functions for dealing with sequences."""
    def test_per_shortest(self):
        """per_shortest should divide by min(len(x), len(y))"""
        self.assertEqual(per_shortest(20, 'aaaaaa', 'bbbb'), 5)
        self.assertEqual(per_shortest(20, 'aaaaaa', 'b'), 20)
        self.assertEqual(per_shortest(20, 'a', 'bbbbb'), 20)
        self.assertEqual(per_shortest(20, '', 'b'), 0)
        self.assertEqual(per_shortest(20, '', ''), 0)
        #check that it does it in floating-point
        self.assertEqual(per_shortest(1, 'aaaaaa', 'bbbb'), 0.25)
        #check that it raises TypeError on non-seq
        self.assertRaises(TypeError, per_shortest, 1, 2, 3)

    def test_per_longest(self):
        """per_longest should divide by max(len(x), len(y))"""
        self.assertEqual(per_longest(20, 'aaaaaa', 'bbbb'), 20/6.0)
        self.assertEqual(per_longest(20, 'aaaaaa', 'b'), 20/6.0)
        self.assertEqual(per_longest(20, 'a', 'bbbbb'), 20/5.0)
        self.assertEqual(per_longest(20, '', 'b'), 20)
        self.assertEqual(per_longest(20, '', ''), 0)
        #check that it does it in floating-point
        self.assertEqual(per_longest(1, 'aaaaaa', 'bbbb'), 1/6.0)
        #check that it raises TypeError on non-seq
        self.assertRaises(TypeError, per_longest, 1, 2, 3)

    def test_for_seq(self):
        """for_seq should return the correct function"""
        is_eq = lambda x,y: x == y
        is_ne = lambda x,y: x != y
        lt_5 =  lambda x,y: x + y < 5
        diff =  lambda x,y: x - y

        sumsq = lambda x: sum([i*i for i in x])

        long_norm = lambda s, x, y: (s + 0.0) / max(len(x), len(y))
        times_two = lambda s, x, y: 2*s

        empty = []
        s1 = [1,2,3,4,5]
        s2 = [1,3,2,4,5]
        s3 = [1,1,1,1,1]
        s4 = [5,5,5,5,5]
        s5 = [3,3,3,3,3]
        short = [1]

        #test behavior with default aggregator and normalizer
        f = for_seq(is_eq)
        self.assertFloatEqual(f(s1, s1), 1.0)
        self.assertFloatEqual(f(s1, short), 1.0)
        self.assertFloatEqual(f(short, s1), 1.0)
        self.assertFloatEqual(f(short, s4), 0.0)
        self.assertFloatEqual(f(s4, short), 0.0)
        self.assertFloatEqual(f(s1,s2), 0.6)
        
        f = for_seq(is_ne)
        self.assertFloatEqual(f(s1, s1), 0.0)
        self.assertFloatEqual(f(s1, short), 0.0)
        self.assertFloatEqual(f(short, s1), 0.0)
        self.assertFloatEqual(f(short, s4), 1.0)
        self.assertFloatEqual(f(s4, short), 1.0)
        self.assertFloatEqual(f(s1, s2), 0.4)
         
        f = for_seq(lt_5)
        self.assertFloatEqual(f(s3,s3), 1.0)
        self.assertFloatEqual(f(s3,s4), 0.0)
        self.assertFloatEqual(f(s2,s3), 0.6)

        f = for_seq(diff)
        self.assertFloatEqual(f(s1,s1), 0.0)
        self.assertFloatEqual(f(s4,s1), 2.0)
        self.assertFloatEqual(f(s1,s4), -2.0)

        #test behavior with different aggregator
        f = for_seq(diff)
        self.assertFloatEqual(f(s1,s5), 0)
        f = for_seq(diff, aggregator=sum)
        self.assertFloatEqual(f(s1,s5), 0)
        f = for_seq(diff, aggregator=sumsq)
        self.assertFloatEqual(f(s1,s5), 2.0)

        #test behavior with different normalizer
        f = for_seq(diff, aggregator=sumsq, normalizer=None)
        self.assertFloatEqual(f(s1,s5), 10)
        f = for_seq(diff, aggregator=sumsq)
        self.assertFloatEqual(f(s1,s5), 2.0)
        f = for_seq(diff, aggregator=sumsq, normalizer=times_two)
        self.assertFloatEqual(f(s1,s5), 20)
        f = for_seq(diff, aggregator=sumsq)
        self.assertFloatEqual(f(s5,short), 4)
        f = for_seq(diff, aggregator=sumsq, normalizer=long_norm)
        self.assertFloatEqual(f(s5,short), 0.8)
        


class Filter_Criteria_Tests(TestCase):
    """Tests of standalone functions used as filter criteria"""

    def test_trans_except(self):
        """trans_except should return trans table mapping non-good chars to x"""
        a = trans_except('Aa', '-')
        none = trans_except('', '*')
        some = trans_except('zxcvbnm,.zxcvbnm,.', 'V')

        self.assertEqual('abcABA'.translate(a), 'a--A-A')
        self.assertEqual(''.translate(a), '')
        self.assertEqual('12345678'.translate(a), '--------')

        self.assertEqual(''.translate(none), '')
        self.assertEqual('abcdeEFGHI12345&*(!@'.translate(none), '*'*20)

        self.assertEqual('qazwsxedcrfv'.translate(some),'VVzVVxVVcVVv') 

    def test_trans_all(self):
        """trans_all should return trans table mapping all bad chars to x"""
        a = trans_all('Aa', '-')
        none = trans_all('', '*')
        some = trans_all('zxcvbnm,.zxcvbnm,.', 'V')

        self.assertEqual('abcABA'.translate(a), '-bc-B-')
        self.assertEqual(''.translate(a), '')
        self.assertEqual('12345678'.translate(a), '12345678')

        self.assertEqual(''.translate(none), '')
        self.assertEqual('abcdeEFGHI12345&*(!@'.translate(none), \
            'abcdeEFGHI12345&*(!@')

        self.assertEqual('qazwsxedcrfv'.translate(some),'qaVwsVedVrfV') 

    def test_make_trans(self):
        """make_trans should return trans table mapping chars to default"""
        a = make_trans()
        self.assertEqual('abc123'.translate(a), 'abc123')
        a = make_trans('a', 'x')
        self.assertEqual('abc123'.translate(a), 'xbc123')
        a = make_trans('ac', 'xa')
        self.assertEqual('abc123'.translate(a), 'xba123')
        a = make_trans('ac', 'xa', '.')
        self.assertEqual('abc123'.translate(a), 'x.a...')
        self.assertRaises(ValueError, make_trans, 'ac', 'xa', 'av')

    def test_find_any(self):
        """find_any should be True if one of the words is in the string"""
        
        f = find_any('ab')
        self.assertEqual(f(''),0) #empty
        self.assertRaises(AttributeError,f,None) # none
        self.assertEqual(f('cde'),0) #none of the elements
        self.assertEqual(f('axxx'),1) #one of the elements
        self.assertEqual(f('bxxx'),1) #one of the elements
        self.assertEqual(f('axxxb'),1) #all elements
        self.assertEqual(f('aaaa'),1) #repeated element

        # works on any sequence
        f = find_any(['foo','bar'])
        self.assertEqual(f("joe"),0)
        self.assertEqual(f("only foo"),1)
        self.assertEqual(f("bar and foo"),1)
        
        # does NOT work on numbers
        
    def test_find_no(self):
        """find_no should be True if none of the words in the string"""
       
        f = find_no('ab')
        self.assertEqual(f(''),1) #empty
        self.assertRaises(AttributeError,f,None) # none
        self.assertEqual(f('cde'),1) #none of the elements
        self.assertEqual(f('axxx'),0) #one of the elements
        self.assertEqual(f('bxxx'),0) #one of the elements
        self.assertEqual(f('axxxb'),0) #all elements
        self.assertEqual(f('aaaa'),0) #repeated element

        # works on any sequence
        f = find_no(['foo','bar'])
        self.assertEqual(f("joe"),1)
        self.assertEqual(f("only foo"),0)
        self.assertEqual(f("bar and foo"),0)
        
        # does NOT work on numbers

    def test_find_all(self):
        """find_all should be True if all words appear in the string"""

        f = find_all('ab')
        self.assertEqual(f(''),0) #empty
        self.assertRaises(AttributeError,f,None) # none
        self.assertEqual(f('cde'),0) #none of the elements
        self.assertEqual(f('axxx'),0) #one of the elements
        self.assertEqual(f('bxxx'),0) #one of the elements
        self.assertEqual(f('axxxb'),1) #all elements
        self.assertEqual(f('aaaa'),0) #repeated element

        # works on any sequence
        f = find_all(['foo','bar'])
        self.assertEqual(f("joe"),0)
        self.assertEqual(f("only foo"),0)
        self.assertEqual(f("bar and foo"),1)
        
        # does NOT work on numbers
        
    def test_keep_if_more(self):
        """keep_if_more should be True if #items in s > x"""
        
        self.assertRaises(ValueError, keep_if_more,'lksfj','ksfd') #not int
        self.assertRaises(IndexError,keep_if_more,'ACGU',-3) #negative
        
        f = keep_if_more('a',0) #zero
        self.assertEqual(f(''),0)
        self.assertEqual(f('a'),1)
        self.assertEqual(f('b'),0)
        
        # works on strings
        f = keep_if_more('ACGU',5) #positive
        self.assertEqual(f(''),0)
        self.assertEqual(f('ACGUAGCUioooNNNNNA'),1)
        self.assertEqual(f('NNNNNNN'),0)

        # works on words
        f = keep_if_more(['foo'],1)
        self.assertEqual(f(''),0)
        self.assertEqual(f(['foo', 'bar','foo']),1)
        self.assertEqual(f(['joe']),0)

        # works on numbers
        f = keep_if_more([0,1],3)
        self.assertEqual(f(''),0)
        self.assertEqual(f([0,1,2,3,4,5]),0)
        self.assertEqual(f([0,1,0,1]),1)

    def test_exclude_if_more(self):
        """exclude_if_more should be True if #items in s <= x"""

        self.assertRaises(ValueError, exclude_if_more,'lksfj','ksfd') #not int
        self.assertRaises(IndexError,exclude_if_more,'ACGU',-3) #negative
        
        f = exclude_if_more('a',0) #zero
        self.assertEqual(f(''),1)
        self.assertEqual(f('a'),0)
        self.assertEqual(f('b'),1)
        
        # works on strings
        f = exclude_if_more('ACGU',5) #positive
        self.assertEqual(f(''),1)
        self.assertEqual(f('ACGUAGCUioooNNNNNA'),0)
        self.assertEqual(f('NNNNNNN'),1)

        # works on words
        f = exclude_if_more(['foo'],1)
        self.assertEqual(f(''),1)
        self.assertEqual(f(['foo', 'bar','foo']),0)
        self.assertEqual(f(['joe']),1)

        # works on numbers
        f = exclude_if_more([0,1],3)
        self.assertEqual(f(''),1)
        self.assertEqual(f([0,1,2,3,4,5]),1)
        self.assertEqual(f([0,1,0,1]),0)
        
    def test_keep_if_more_other(self):
        """keep_if_more_other should be True if #other items > x"""

        self.assertRaises(ValueError, keep_if_more_other,'lksfj','ks') #not int
        self.assertRaises(IndexError,keep_if_more_other,'ACGU',-3) #negative
        
        f = keep_if_more_other('a',0) #zero
        self.assertEqual(f(''),0)
        self.assertEqual(f('a'),0)
        self.assertEqual(f('b'),1)
        
        # works on strings
        f = keep_if_more_other('ACGU',5) #positive
        self.assertEqual(f(''),0)
        self.assertEqual(f('ACGUNNNNN'),0)
        self.assertEqual(f('ACGUAGCUioooNNNNNA'),1)
        self.assertEqual(f('NNNNNNN'),1)

        # works on words
        f = keep_if_more_other(['foo'],1)
        self.assertEqual(f(''),0)
        self.assertEqual(f(['foo', 'bar','foo']),0)
        self.assertEqual(f(['joe','oef']),1)

        # works on numbers
        f = keep_if_more_other([0,1],3)
        self.assertEqual(f(''),0)
        self.assertEqual(f([0,1,2,3,4,5]),1)
        self.assertEqual(f([0,1,0,1]),0)
        
    def test_exclude_if_more_other(self):
        """exclude_if_more_other should be True if #other items <= x"""
        self.assertRaises(ValueError, exclude_if_more_other,'lks','ks') #not int
        self.assertRaises(IndexError,exclude_if_more_other,'ACGU',-3) #negative
        
        f = exclude_if_more_other('a',0) #zero
        self.assertEqual(f(''),1)
        self.assertEqual(f('a'),1)
        self.assertEqual(f('b'),0)
        
        # works on strings
        f = exclude_if_more_other('ACGU',5) #positive
        self.assertEqual(f(''),1)
        self.assertEqual(f('ACGUNNNNN'),1)
        self.assertEqual(f('ACGUAGCUioooNNNNNA'),0)
        self.assertEqual(f('NNNNNNN'),0)

        # works on words
        f = exclude_if_more_other(['foo'],1)
        self.assertEqual(f(''),1)
        self.assertEqual(f(['foo', 'bar','foo']),1)
        self.assertEqual(f(['joe','oef']),0)

        # works on numbers
        f = exclude_if_more_other([0,1],3)
        self.assertEqual(f(''),1)
        self.assertEqual(f([0,1,2,3,4,5]),0)
        self.assertEqual(f([0,1,0,1]),1)

    def test_keep_chars(self):
        """keep_chars returns a string containing only chars in keep"""
        f = keep_chars('ab c3*[')
        self.assertEqual(f(''),'') #empty
        self.assertRaises(AttributeError,f,None) #None
        
        #one character, case sensitive
        self.assertEqual(f('b'),'b')
        self.assertEqual(f('g'),'')
        self.assertEqual(f('xyz123'),'3')
        self.assertEqual(f('xyz  123'),'  3')
        
        #more characters, case sensitive
        self.assertEqual(f('kjbwherzcagebcujrkcs'),'bcabcc')
        self.assertEqual(f('f[ffff*ff*fff3fff'),'[**3')

        # case insensitive
        f = keep_chars('AbC',False)
        self.assertEqual(f('abcdef'),'abc')
        self.assertEqual(f('ABCDEF'),'ABC')
        self.assertEqual(f('aBcDeF'),'aBc')

    def test_exclude_chars(self):
        """exclude_chars returns string containing only chars not in exclude"""
        
        f = exclude_chars('ab c3*[')
        self.assertEqual(f(''),'') #empty
        self.assertRaises(AttributeError,f,None) #None
        
        #one character, case sensitive
        self.assertEqual(f('b'),'')
        self.assertEqual(f('g'),'g')
        self.assertEqual(f('xyz123'),'xyz12')
        self.assertEqual(f('xyz  123'),'xyz12')
        
        #more characters, case sensitive
        self.assertEqual(f('axxxbxxxcxxx'),'xxxxxxxxx')

        # case insensitive
        f = exclude_chars('AbC',False)
        self.assertEqual(f('abcdef'),'def')
        self.assertEqual(f('ABCDEF'),'DEF')
        self.assertEqual(f('aBcDeF'),'DeF')

    def test_reorder(self):
        """reorder should always use the same order when invoked"""
        list_test = reorder([3,2,1])
        dict_test = reorder(['x','y','z'])
        multi_test = reorder([3,2,2])
        null_test = reorder([])

        first_seq = 'abcde'
        second_seq = [3,4,5,6,7]
        empty_list = []
        empty_dict = {}
        full_dict = {'a':3, 'c':5, 'x':'abc','y':'234','z':'qaz'}

        for i in (first_seq, second_seq, empty_list, empty_dict):
            self.assertEqual(null_test(i), [])

        self.assertEqual(list_test(first_seq), ['d','c','b'])
        self.assertEqual(list_test(second_seq), [6,5,4])
        self.assertEqual(multi_test(first_seq), ['d','c','c'])
        self.assertEqual(dict_test(full_dict), ['abc','234','qaz'])

        self.assertRaises(KeyError, dict_test, empty_dict)
        self.assertRaises(IndexError, list_test, empty_list)
        
    def test_reorder_inplace(self):
        """reorder_inplace should replace object's data with new order"""
        attr_test = reorder_inplace([3,2,1], 'Data')
        obj_test = reorder_inplace([3,2,2])

        seq = [3,4,5,6,7]

        class obj(object):
            pass

        o = obj()
        o.XYZ = [9, 7, 5]
        o.Data = ['a','b','c','d','e']
        orig_data = o.Data

        self.assertEqual(obj_test(seq), [6,5,5])
        self.assertEqual(seq, [6,5,5])
        assert attr_test(o) is o
        self.assertEqual(o.XYZ, [9,7,5])
        self.assertEqual(o.Data, ['d','c','b'])
        assert orig_data is o.Data
    
    def test_float_from_string(self):
        """float_from_string should ignore funny chars"""
        ffs = float_from_string
        self.assertEqual(ffs('3.5'), 3.5)
        self.assertEqual(ffs('     -3.45e-10   '), float('     -3.45e-10   '))
        self.assertEqual(ffs('jsdjhsdf[]()0.001IVUNZSDFl]]['), 0.001)

    def test_first_index(self):
        """first_index should return index of first occurrence where f(s)"""
        vowels = 'aeiou'
        is_vowel = lambda x: x in vowels
        s1 = 'ebcua'
        s2 = 'bcbae'
        s3 = ''
        s4 = 'cbd'
        self.assertEqual(first_index(s1, is_vowel), 0)
        self.assertEqual(first_index(s2, is_vowel), 3)
        self.assertEqual(first_index(s3, is_vowel), None)
        self.assertEqual(first_index(s4, is_vowel), None)
          
    def test_last_index(self):
        """last_index should return index of last occurrence where f(s)"""
        vowels = 'aeiou'
        is_vowel = lambda x: x in vowels
        s1 = 'ebcua'
        s2 = 'bcbaef'
        s3 = ''
        s4 = 'cbd'
        self.assertEqual(last_index(s1, is_vowel), 4)
        self.assertEqual(last_index(s2, is_vowel), 4)
        self.assertEqual(last_index(s3, is_vowel), None)
        self.assertEqual(last_index(s4, is_vowel), None)

    def test_first_index_in_set(self):
        """first_index_in_set should return index of first occurrence """
        vowels = 'aeiou'
        s1 = 'ebcua'
        s2 = 'bcbae'
        s3 = ''
        s4 = 'cbd'
        self.assertEqual(first_index_in_set(s1, vowels), 0)
        self.assertEqual(first_index_in_set(s2, vowels), 3)
        self.assertEqual(first_index_in_set(s3, vowels), None)
        self.assertEqual(first_index_in_set(s4, vowels), None)
          
    def test_last_index_in_set(self):
        """last_index_in_set should return index of last occurrence"""
        vowels = 'aeiou'
        s1 = 'ebcua'
        s2 = 'bcbaef'
        s3 = ''
        s4 = 'cbd'
        self.assertEqual(last_index_in_set(s1, vowels), 4)
        self.assertEqual(last_index_in_set(s2, vowels), 4)
        self.assertEqual(last_index_in_set(s3, vowels), None)
        self.assertEqual(last_index_in_set(s4, vowels), None)

    def test_first_index_not_in_set(self):
        """first_index_not_in_set should return index of first occurrence """
        vowels = 'aeiou'
        s1 = 'ebcua'
        s2 = 'bcbae'
        s3 = ''
        s4 = 'cbd'
        self.assertEqual(first_index_not_in_set(s1, vowels), 1)
        self.assertEqual(first_index_not_in_set(s2, vowels), 0)
        self.assertEqual(first_index_not_in_set(s3, vowels), None)
        self.assertEqual(first_index_not_in_set(s4, vowels), 0)
          
    def test_last_index_not_in_set(self):
        """last_index_not_in_set should return index of last occurrence"""
        vowels = 'aeiou'
        s1 = 'ebcua'
        s2 = 'bcbaef'
        s3 = ''
        s4 = 'cbd'
        self.assertEqual(last_index_not_in_set(s1, vowels), 2)
        self.assertEqual(last_index_not_in_set(s2, vowels), 5)
        self.assertEqual(last_index_not_in_set(s3, vowels), None)
        self.assertEqual(last_index_not_in_set(s4, vowels), 2)

    def test_first(self):
        """first should return first occurrence where f(s)"""
        vowels = 'aeiou'
        is_vowel = lambda x: x in vowels
        s1 = 'ebcua'
        s2 = 'bcbae'
        s3 = ''
        s4 = 'cbd'
        self.assertEqual(first(s1, is_vowel), 'e')
        self.assertEqual(first(s2, is_vowel), 'a')
        self.assertEqual(first(s3, is_vowel), None)
        self.assertEqual(first(s4, is_vowel), None)
          
    def test_last(self):
        """last should return last occurrence where f(s)"""
        vowels = 'aeiou'
        is_vowel = lambda x: x in vowels
        s1 = 'ebcua'
        s2 = 'bcbaef'
        s3 = ''
        s4 = 'cbd'
        self.assertEqual(last(s1, is_vowel), 'a')
        self.assertEqual(last(s2, is_vowel), 'e')
        self.assertEqual(last(s3, is_vowel), None)
        self.assertEqual(last(s4, is_vowel), None)

    def test_first_in_set(self):
        """first_in_set should return first occurrence """
        vowels = 'aeiou'
        s1 = 'ebcua'
        s2 = 'bcbae'
        s3 = ''
        s4 = 'cbd'
        self.assertEqual(first_in_set(s1, vowels), 'e')
        self.assertEqual(first_in_set(s2, vowels), 'a')
        self.assertEqual(first_in_set(s3, vowels), None)
        self.assertEqual(first_in_set(s4, vowels), None)
          
    def test_last_in_set(self):
        """last_in_set should return last occurrence"""
        vowels = 'aeiou'
        s1 = 'ebcua'
        s2 = 'bcbaef'
        s3 = ''
        s4 = 'cbd'
        self.assertEqual(last_in_set(s1, vowels), 'a')
        self.assertEqual(last_in_set(s2, vowels), 'e')
        self.assertEqual(last_in_set(s3, vowels), None)
        self.assertEqual(last_in_set(s4, vowels), None)

    def test_first_not_in_set(self):
        """first_not_in_set should return first occurrence """
        vowels = 'aeiou'
        s1 = 'ebcua'
        s2 = 'bcbae'
        s3 = ''
        s4 = 'cbd'
        self.assertEqual(first_not_in_set(s1, vowels), 'b')
        self.assertEqual(first_not_in_set(s2, vowels), 'b')
        self.assertEqual(first_not_in_set(s3, vowels), None)
        self.assertEqual(first_not_in_set(s4, vowels), 'c')
          
    def test_last_not_in_set(self):
        """last_not_in_set should return last occurrence"""
        vowels = 'aeiou'
        s1 = 'ebcua'
        s2 = 'bcbaef'
        s3 = ''
        s4 = 'cbd'
        self.assertEqual(last_not_in_set(s1, vowels), 'c')
        self.assertEqual(last_not_in_set(s2, vowels), 'f')
        self.assertEqual(last_not_in_set(s3, vowels), None)
        self.assertEqual(last_not_in_set(s4, vowels), 'd')

    def test_perm(self):
        """perm should return correct permutations"""
        self.assertEqual(list(perm('abc')), ['abc','acb','bac','bca','cab','cba']) 

    def test_comb(self):
        """comb should return correct combinations"""
        self.assertEqual(list(comb(range(5), 0)),
                [])
        self.assertEqual(list(comb(range(5), 1)),
                [[0], [1], [2], [3], [4]])
        self.assertEqual(list(comb(range(5), 2)),
                [[0, 1], [0, 2], [0, 3], [0, 4], [1, 2], [1, 3], [1, 4], [2, 3],
                [2, 4], [3, 4]])
        self.assertEqual(list(comb(range(5), 3)),
               [[0, 1, 2], [0, 1, 3], [0, 1, 4], [0, 2, 3], [0, 2, 4], [0, 3, 4],
                [1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]])
        self.assertEqual(list(comb(range(5), 4)),
                [[0, 1, 2, 3], [0, 1, 2, 4], [0, 1, 3, 4], [0, 2, 3, 4], [1, 2, 3, 4]])
        self.assertEqual(list(comb(range(5), 5)),
                [[0, 1, 2, 3, 4]])


    def test_cross_comb(self):
        """cross_comb should produce correct combinations"""
        v1 = range(2)
        v2 = range(3)
        v3 = list('abc')
        vv1 = ([e] for e in v1)
        v1_x_v2 = [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2]]
        v1v2v3 = [[0, 0, 'a'], [0, 0, 'b'], [0, 0, 'c'], [0, 1, 'a'],
                  [0, 1, 'b'], [0, 1, 'c'], [0, 2, 'a'], [0, 2, 'b'],
                  [0, 2, 'c'], [1, 0, 'a'], [1, 0, 'b'], [1, 0, 'c'],
                  [1, 1, 'a'], [1, 1, 'b'], [1, 1, 'c'], [1, 2, 'a'],
                  [1, 2, 'b'], [1, 2, 'c']]
        self.assertEqual(list( _increment_comb(vv1, v2)), v1_x_v2)
        self.assertEqual(list( cross_comb([v1, v2])), v1_x_v2)
        self.assertEqual(list(cross_comb([v1, v2, v3])), v1v2v3)



 #run tests if invoked from the commandline
if __name__ == '__main__':
    main()