def calculate_done(self): for item in self: if item.product_id.categ_id.parent_id.name == 'Producto Terminado': list_serial_pt = Enumerable( self.workorder_ids[0].summary_out_serial_ids).where( lambda x: x.product_id.id == item.product_id.id).count( ) for move in item.move_raw_ids.filtered( lambda x: not x.needs_lots): move.active_move_line_ids.sudo().unlink() component_ids = Enumerable(item.bom_id.bom_line_ids).where( lambda x: x.product_id.id == move.product_id.id) self.env['stock.move.line'].create({ 'product_id': move.product_id.id, 'production_id': item.id, 'qty_done': list_serial_pt * component_ids.first_or_default().product_qty, 'location_id': item.location_src_id.id, 'product_uom_id': move.product_id.uom_id.id, 'location_dest_id': self.env['stock.location'].search( [('usage', '=', 'production')], limit=1).id, 'move_id': move.id, 'lot_produced_id': item.finished_move_line_ids.filtered( lambda x: x.product_id.id == item.product_id.id). lot_id.id })
def DBSCANForMatches(self, matches, R, DENSITY): values = Enumerable(list()) for match in matches: values.append( MinimumSetCoverAlgorithm.ComputeMatchValue(match)) values = values.order_by(lambda v: v).to_list() return self.DBSCAN(values, R, DENSITY)
def test_issue22(self): def my_iter(): for i in range(10): yield i def low_iter(): for i in range(5): yield i def high_iter(): for k in range(5): yield k + 5 data = my_iter() a = Enumerable(data) low = a.where(lambda x: x < 5) high = a.where(lambda x: x >= 5) self.assertListEqual( [(0, 5), (1, 6), (2, 7), (3, 8), (4, 9)], low.zip(high).to_list() ) self.assertListEqual( [(0, 5), (1, 6), (2, 7), (3, 8), (4, 9)], list(zip(low, high)) )
def test_group_by(self): simple_grouped = self.simple.group_by(key_names=['id']) self.assertEqual(simple_grouped.count(), 3, u"Three grouped elements in simple grouped") for g in simple_grouped: self.assertEqual( g.key.id, g.first(), u"Each id in simple grouped should match first value") complex_grouped = self.complex.group_by(key_names=['value'], key=lambda x: x['value']) self.assertEqual(complex_grouped.count(), 3, u"Three grouped elements in complex grouped") for g in complex_grouped: self.assertEqual( g.key.value, g.select(lambda x: x['value']).first(), u"Each value in complex grouped should mach first value") locations_grouped = Enumerable(_locations) \ .group_by( key_names=['country', 'city'], key=lambda x: [x[0], x[1]]) self.assertEqual(locations_grouped.count(), 7, u"Seven grouped elements in locations grouped") london = locations_grouped \ .single( lambda c: c.key.city == 'London' and c.key.country == 'England' ) self.assertEqual(london.sum(lambda c: c[3]), 240000, u"Sum of London, England location does not equal")
def test_issue22_join(self): class Val(object): def __init__(self, number, power): self.number = number self.power = power def __str__(self): return "VAL {0}: {1}".format(self.number, self.power) def powers_of_2(): for i in range(2): yield Val(i, 2**i) def powers_of_10(): for i in range(2): yield Val(i, 10**i) en2 = Enumerable(powers_of_2()) en10 = Enumerable(powers_of_10()) joined = en2.join( en10, lambda x: x.number, lambda y: y.number, lambda r: (r[0].power, r[1].power), ) truth = zip([2**i for i in range(2)], [10**y for y in range(2)]) self.assertListEqual(list(truth), joined.to_list())
def test_issue_52_2(self): e1 = Enumerable([{ "value": 1 }, { "value": 2 }, { "value": 3 }, { "value": 0 }]) e2 = Enumerable([1, 2, 3, 1, 2, 1]) res = e1.group_join( e2, outer_key=lambda x: x["value"], inner_key=lambda y: y, result_func=lambda r: (r[0], r[1].to_list()), ) self.assertListEqual( [ ({ "value": 1 }, [1, 1, 1]), ({ "value": 2 }, [2, 2]), ({ "value": 3 }, [3]), ], res.to_list(), )
def get_credit_spreads_portfolio(): """Find the current credit spreads in the portfolio""" # retrieve open option positions add_event_log('function[get_credit_spreads_portfolio] Entering') open_positions = rs.options.get_open_option_positions() add_event_log( 'function[get_credit_spreads_portfolio] {0}'.format(open_positions)) # list of CreditSpread objects credit_list: list = list() # two positions are required to make a credit spread if only one position remains there are no more spreads. while len(open_positions) > 1: # checks the update time stamp pairs = Enumerable(open_positions).where(lambda x: x['updated_at'][ 0:19:1] == open_positions[0]['updated_at'][0:19:1]).to_list() # pairs are updated at the same time. two positions updated within 1 second of each other belong together. if len(pairs) == 2: # get option specific details for the long and short positions long = rs.helper.request_get( Enumerable(pairs).where(lambda x: x['type'] == 'long').select( lambda x: x['option'])[0]) short = rs.helper.request_get( Enumerable(pairs).where(lambda x: x['type'] == 'short').select( lambda x: x['option'])[0]) # define the variables in the credit spread object symbol = long['chain_symbol'] expiration_date: str = long['expiration_date'] quantity = int(float(pairs[0]['quantity'])) option_type: str = long['type'] buy_strike: float = float(long['strike_price']) sell_strike: float = float(short['strike_price']) buy_price: float = abs( float( Enumerable(pairs).where(lambda x: x['type'] == 'long'). select(lambda x: x['average_price'])[0])) sell_price: float = abs( float( Enumerable(pairs).where(lambda x: x['type'] == 'short'). select(lambda x: x['average_price'])[0])) purchase_date = long['created_at'][0:10:1] # add Credit Spread object to the credit spread list my_spread = CreditSpread(symbol, expiration_date, quantity, buy_strike, sell_strike, buy_price, sell_price, option_type, purchase_date) credit_list.append(my_spread) # remove the current item from list to prevent duplicate Credit Spread objects open_positions.pop(0) else: # remove current item if the number is anything other than two open_positions.pop(0) # return the list of Credit Spread objects add_event_log('function[get_credit_spreads_portfolio] Exiting') return credit_list
def test_except(self): self.assertRaises(TypeError, self.empty.except_, []) self.assertListEqual( self.empty.except_(self.empty).to_list(), [], u"Complement of two empty enumerables yields empty list") self.assertListEqual( self.empty.except_(self.simple).to_list(), [], u"Complement of empty and simple enumerables yields empty list") self.assertListEqual( self.simple.except_(self.empty).to_list(), _simple, u"Complement of simple and empty enumerables yields simple list") self.assertListEqual( self.simple.except_(self.simple).to_list(), [], u"Complement of simple and simple enumerables yields empty list") self.assertListEqual( self.simple.except_(Enumerable([2])).to_list(), [1, 3], u"Complement of simple and [2] yields [1,3]") self.assertListEqual( self.simple.except_(self.complex).to_list(), _simple, u"Complement of simple and complex yields simple") self.assertListEqual( self.complex.except_(self.simple).to_list(), _complex, u"Complement of complex and simple yields complex") self.assertListEqual( self.complex.except_(self.complex).to_list(), [], u"Complement of complex and complex yields empty") self.assertListEqual( self.complex.except_(Enumerable([{ 'value': 1 }])).to_list(), [{ 'value': 2 }, { 'value': 3 }], "Should yield [{'value': 2}, 'value': 3]")
def task_2_linq(): cur = con.cursor() try: cur.execute(''' select * from visits; ''') visits = Enumerable(cur.fetchall()) con.commit() cur.close() non_exitors = (visits.group_by( key_names=['id_emp', 'visit_type'], key=lambda t: (t[0], t[4]))).select( lambda a: { 'visit_type': a.key.visit_type, 'id_emp': a.key.id_emp, 'count': a.count() }).where(lambda r: r['visit_type'] == 2 and r[ 'count'] > 1).to_list() print(non_exitors) except: con.rollback()
def test_intersect(self): self.assertRaises(TypeError, self.empty.intersect, []) self.assertListEqual( self.empty.intersect(self.empty).to_list(), [], u"Intersect of two empty enumerables yield empty list") self.assertListEqual( self.empty.intersect(self.simple).to_list(), [], u"Intersect of empty and simple enumerables yields empty list") self.assertListEqual( self.simple.intersect(self.simple).to_list(), _simple, u"Intersect of two simple enumerables yields simple list") self.assertListEqual( self.simple.intersect(Enumerable([2])).to_list(), [2], u"Intersect of simple enumerable and [2] yields [2]") self.assertListEqual( self.simple.intersect(self.complex).to_list(), [], u"Intersect of simple and complex enumerable yields empty list") self.assertListEqual( self.complex.intersect(self.complex).to_list(), _complex, u"Intersect of two complex enumeraable yields complex list") self.assertListEqual( self.complex.intersect(Enumerable([{'value': 1}])).to_list(), [{'value': 1}], "Should yield {'value': 1}")
def test_select_many(self): self.assertListEqual([], Enumerable([[], [], []]).select_many().to_list()) self.assertListEqual( [1, 2, 3, 4, 5, 6, 7, 8, 9], Enumerable([[1, 2, 3], [4, 5, 6], [7, 8, 9]]).select_many().to_list(), ) self.assertEqual( 9, Enumerable([[1, 2, 3], [4, 5, 6], [7, 8, 9]]).select_many().count() ) self.assertListEqual( [1, 2, 3, 4, 5, 6, 7, 8, 9], Enumerable( [ {"key": 1, "values": [1, 2, 3]}, {"key": 2, "values": [4, 5, 6]}, {"key": 3, "values": [7, 8, 9]}, ] ) .select_many(lambda x: x["values"]) .to_list(), ) self.assertEqual( 9, Enumerable( [ {"key": 1, "values": [1, 2, 3]}, {"key": 2, "values": [4, 5, 6]}, {"key": 3, "values": [7, 8, 9]}, ] ) .select_many(lambda x: x["values"]) .count(), )
def save_to_json(final_list): posts = [] for j in range(len(final_list[0])): posts.append({ 'id': final_list[0][j], 'author': final_list[1][j], 'text': final_list[2][j], 'links': '\n'.join(final_list[3][j]), 'images': '\n'.join(final_list[4][j]) }) with open('posts.json', 'a+') as f: f.seek(0, 2) if f.tell() == 0: json.dump(posts, f, indent=2, ensure_ascii=False) else: lst = load_from_json() collection = Enumerable(posts) result = collection.select(lambda x: check_equals(x, lst)) result = result.to_list() result = [x for x in result if x] f.seek(f.tell()-1, 0) f.truncate() for i in range(len(result)): f.write(' ,\n') json.dump(result[i], f, indent=2, ensure_ascii=False) f.write('\n]') print('json файл сохранен')
def equip_item(self, inventory_item_id): """Marks the item as equipped which will add to a character's stats Arguments: inventory_item_id {string} -- Identifies the item in the inventory """ if self.inventory is None: self.inventory = [] item = Enumerable(self.inventory).first_or_default(lambda x: x.inv_id == inventory_item_id) if item is None: raise Exception("The item does not exist in the inventory") if not self.can_use_2h and item.slot == 14: raise Exception("Cannot equip a two-handed weapon") # else: # self.attack_speed = damage_base[self.player_class]['speed'] * 1.25 if not self.can_dual_wield and item.slot == 13: raise Exception("Cannot equip a weapon in the off hand") existing_item = Enumerable(self.inventory).first_or_default(lambda x: x.slot == item.slot and x.equipped) if existing_item is not None: self.unequip_item(existing_item.inv_id) #existing_item.equipped = False item.equipped = True self.calc_stats() self.updated_at = datetime.utcnow() super(CharacterModel, self).save()
def test_then_by(self): locations = Enumerable(_locations) self.assertListEqual( locations.order_by(lambda l: l[0]) .then_by(lambda l: l[1]) .select(lambda l: u"{0}, {1}".format(l[1], l[0])) .to_list(), [ u'Liverpool, England', u'Liverpool, England', u'London, England', u'London, England', u'London, England', u'Manchester, England', u'Manchester, England', u'Edinburgh, Scotland', u'Glasgow, Scotland', u'Glasgow, Scotland', u'Bangor, Wales', u'Cardiff, Wales', u'Cardiff, Wales' ], u"then_by locations ordering is not correct") self.assertRaises( NullArgumentError, locations.order_by(lambda l: l[0]).then_by, None)
def test_then_by_descending(self): locations = Enumerable(_locations) self.assertListEqual( locations.order_by(lambda l: l[0]) .then_by(lambda l: l[1]) .then_by_descending(lambda l: l[3]) .select(lambda l: u"{0}, {1}: {2}".format( l[1], l[0], l[3] )) .to_list(), [ u'Liverpool, England: 29700', u'Liverpool, England: 25000', u'London, England: 90000', u'London, England: 80000', u'London, England: 70000', u'Manchester, England: 50000', u'Manchester, England: 45600', u'Edinburgh, Scotland: 20000', u'Glasgow, Scotland: 12500', u'Glasgow, Scotland: 12000', u'Bangor, Wales: 12800', u'Cardiff, Wales: 30000', u'Cardiff, Wales: 29700' ], u"then_by_descending ordering is not correct" )
def test_then_by(self): locations = Enumerable(_locations) self.assertRaises( NullArgumentError, locations.order_by(lambda l: l[0]).then_by, None ) self.assertListEqual( [ u"Liverpool, England", u"Liverpool, England", u"London, England", u"London, England", u"London, England", u"Manchester, England", u"Manchester, England", u"Edinburgh, Scotland", u"Glasgow, Scotland", u"Glasgow, Scotland", u"Bangor, Wales", u"Cardiff, Wales", u"Cardiff, Wales", ], locations.order_by(lambda l: l[0]) .then_by(lambda l: l[1]) .select(lambda l: u"{0}, {1}".format(l[1], l[0])) .to_list(), )
def test_marks_except(self): marks1 = Enumerable([{'course': 'Chemistry', 'mark': 90}, {'course': 'Biology', 'mark': 85}]) marks2 = Enumerable([{'course': 'Chemistry', 'mark': 65}, {'course': 'Computer Science', 'mark': 96}]) self.assertListEqual( marks1.except_(marks2, lambda c: c['course']).to_list(), [{'course': 'Biology', 'mark': 85}] )
def test_union(self): self.assertListEqual([], self.empty.union(self.empty).to_list()) self.assertListEqual( _simple, self.empty.union(self.simple).order_by(lambda x: x).to_list()) self.assertListEqual( _simple, self.simple.union(self.empty).order_by(lambda x: x).to_list()) self.assertListEqual( _complex, self.empty.union( self.complex).order_by(lambda x: x["value"]).to_list(), ) self.assertListEqual( _complex, self.complex.union( self.empty).order_by(lambda x: x["value"]).to_list(), ) self.assertListEqual( _simple + [4, 5], self.simple.union(Enumerable([4, 5])).order_by(lambda x: x).to_list(), ) self.assertListEqual( _simple + [4, 5], self.simple.union(Enumerable([1, 4, 5])).order_by(lambda x: x).to_list(), ) self.assertListEqual( _complex + [{ "value": 4 }, { "value": 5 }], self.complex.union( Enumerable([{ "value": 4 }, { "value": 5 }]), lambda x: x["value"]).order_by(lambda x: x["value"]).to_list(), ) self.assertListEqual( _complex + [{ "value": 4 }, { "value": 5 }], self.complex.union( Enumerable([{ "value": 1 }, { "value": 4 }, { "value": 5 }]), lambda x: x["value"], ).order_by(lambda x: x["value"]).order_by( lambda x: x["value"]).to_list(), )
def test_marks_except(self): marks1 = Enumerable([{ "course": "Chemistry", "mark": 90 }, { "course": "Biology", "mark": 85 }]) marks2 = Enumerable([ { "course": "Chemistry", "mark": 65 }, { "course": "Computer Science", "mark": 96 }, ]) self.assertListEqual( [{ "course": "Biology", "mark": 85 }], marks1.except_(marks2, lambda c: c["course"]).to_list(), )
def parseInference(query): config = Config() attCouples = Enumerable( query.split(';')).select(lambda x: x.split('=')).to_list() row = Enumerable( config.evidences()).select(lambda x: getVals(x, attCouples)).to_list() row.append(None) return Snapshot(row)
def test_reverse(self): test = self.simple.reverse() self.assertListEqual(test.to_list(), [3, 2, 1]) words = u"the quick brown fox jumps over the lazy dog".split(" ") self.assertListEqual(words, ["the", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"]) test = Enumerable(words).reverse() self.assertEqual(u" ".join(test.to_list()), u"dog lazy the over jumps fox brown quick the")
def test_issue19(self): foo = Enumerable([1]) bar = Enumerable([1]) self.assertEqual(foo.intersect(bar).count(), 1) foo = Enumerable([1]) bar = Enumerable([1]).distinct() self.assertEqual(foo.intersect(bar).count(), 1)
def test_distinct(self): self.assertListEqual([], self.empty.distinct().to_list()) six.assertCountEqual( self, _simple, self.simple.concat(self.simple).distinct().to_list()) locations = Enumerable(_locations).distinct(lambda x: x[0]) self.assertEqual(locations.count(), 3)
def CreatePageDatabaseRelation(self, choosen_relations, page): choosen_relations = Enumerable(choosen_relations) field_column_relation = dict() for field in page.GetFields(): field_column_relation[field] = choosen_relations.where( lambda fc: fc.field.Equals(field)).first() return PageDatabaseRelation( page, field_column_relation.values(), MinimumSetCoverAlgorithm().current_best_value)
def test_all(self): test = Enumerable([1, 1, 1]).all(lambda x: x == 1) self.assertTrue(test) test = Enumerable([]).all(lambda x: x == 1) self.assertTrue(test) test = self.simple.all(lambda x: x == 1) self.assertFalse(test)
def search_links(post): post_links = post.find_all('a', {"target": "_blank"}) if len(post_links) > 0: post_links_collection = Enumerable(post_links) links = post_links_collection.select(lambda x: 'https://vk.com'+x.attrs["href"]) links = links.to_list() links = sorted(set(links)) return links else: return ["Ссылки отсутсвуют."]
def test_aggregate(self): words = u"the quick brown fox jumps over the lazy dog".split(" ") self.assertListEqual(words, ["the", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"]) test = Enumerable(words).aggregate(self.reverse) self.assertEqual(test, "dog lazy the over jumps fox brown quick the") self.assertRaises(NoElementsError, Enumerable().aggregate, [lambda x: x[0] + x[1], 0]) test = self.simple.aggregate(self.sum, seed=0) self.assertEqual(test, 6)
def find_dep_2(): cursor = connection.cursor(cursor_factory=DictCursor) cursor.execute('select * from employee') employee = Enumerable(cursor.fetchall()) cursor.close() dep = (employee.group_by(key_names=['department'], key = lambda x: x['department']))\ .select(lambda g: {'department': g.key.department, 'cnt':g.count()}).where(lambda g: g['cnt'] > 10)\ .to_list() print(dep)
def test_select_many(self): empty = Enumerable([[], [], []]) simple = Enumerable([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) __complex = Enumerable([ { "key": 1, "values": [1, 2, 3] }, { "key": 2, "values": [4, 5, 6] }, { "key": 3, "values": [7, 8, 9] }, ]) self.assertListEqual([], empty.select_many().to_list()) self.assertListEqual([1, 2, 3, 4, 5, 6, 7, 8, 9], simple.select_many().to_list()) self.assertListEqual( [1, 2, 3, 4, 5, 6, 7, 8, 9], __complex.select_many(lambda x: x["values"]).to_list(), )
def test_multiple_concatenate(self): simple = Enumerable([1, 2, 3]) simple.add(4) self.assertEqual(4, simple.count()) simple.add(5) self.assertEqual(5, simple.count()) self.assertEqual(5, simple.last())
def update_character_hp(self, char_id, attack_amt): character = Enumerable( self.characters).first_or_default(lambda x: x.id == char_id) character.prev_hp = character.curr_hp if character.curr_hp - attack_amt <= 0: character.curr_hp = 0 character.status = 'DEAD' self.is_active = False else: character.curr_hp -= attack_amt self.save()
def test_group_by(self): simple_grouped = self.simple.group_by(key_names=['id']) self.assertEqual( simple_grouped.count(), 3, u"Three grouped elements in simple grouped") for g in simple_grouped: self.assertEqual( g.key.id, g.first(), u"Each id in simple grouped should match first value") complex_grouped = self.complex.group_by( key_names=['value'], key=lambda x: x['value']) self.assertEqual( complex_grouped.count(), 3, u"Three grouped elements in complex grouped") for g in complex_grouped: self.assertEqual( g.key.value, g.select(lambda x: x['value']).first(), u"Each value in complex grouped should mach first value") locations_grouped = Enumerable(_locations) \ .group_by( key_names=['country', 'city'], key=lambda x: [x[0], x[1]]) self.assertEqual( locations_grouped.count(), 7, u"Seven grouped elements in locations grouped") london = locations_grouped \ .single( lambda c: c.key.city == 'London' and c.key.country == 'England' ) self.assertEqual( london.sum(lambda c: c[3]), 240000, u"Sum of London, England location does not equal")
def test_distinct(self): self.assertListEqual( self.empty.distinct().to_list(), [], u"Distinct empty enumerable yields empty list") self.assertListEqual( self.simple.concat(self.simple).distinct().to_list(), _simple, u"Distinct yields simple list") locations = Enumerable(_locations).distinct(lambda x: x[0]) self.assertEqual( locations.count(), 3, u"Three distinct countries in locations enumerable") self.assertListEqual( locations.to_list(), [ ('England', 'London', 'Branch1', 90000), ('Scotland', 'Edinburgh', 'Branch1', 20000), ('Wales', 'Cardiff', 'Branch1', 29700) ], u"Distinct locations do not match")
def test_select_many(self): empty = Enumerable([[], [], []]) simple = Enumerable([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) __complex = Enumerable( [ {'key': 1, 'values': [1, 2, 3]}, {'key': 2, 'values': [4, 5, 6]}, {'key': 3, 'values': [7, 8, 9]} ] ) self.assertListEqual( empty.select_many().to_list(), [], u"Should yield empty list") self.assertListEqual( simple.select_many().to_list(), [1, 2, 3, 4, 5, 6, 7, 8, 9], u"Should yield simple enumerable with single list") self.assertListEqual( __complex.select_many(lambda x: x['values']).to_list(), simple.select_many().to_list(), u"Should yield simple enumerable with single list")
def setUp(self): self.empty = Enumerable(_empty) self.simple = Enumerable(_simple) self.complex = Enumerable(_complex)
class TestFunctions(TestCase): def setUp(self): self.empty = Enumerable(_empty) self.simple = Enumerable(_simple) self.complex = Enumerable(_complex) def test_to_list(self): self.assertListEqual( self.empty.to_list(), _empty, u"Empty to_list not correct") self.assertListEqual( self.simple.to_list(), _simple, u"Simple to_list not correct") self.assertListEqual( self.complex.to_list(), _complex, u"Complex to_list not correct") def test_sum(self): self.assertEqual( self.empty.sum(), 0, u"Sum of empty enumerable should be 0") self.assertEqual( self.simple.sum(), 6, u"Sum of simple enumerable should be 6") self.assertEqual( self.complex.sum(lambda x: x['value']), 6, u"Sum of complex enumerable should be 6") def test_count(self): self.assertEqual( self.empty.count(), 0, u"Empty enumerable has 0 elements") self.assertEqual( self.simple.count(), 3, u"Simple enumerable has 3 elements") self.assertEqual( self.complex.count(), 3, u"Complex enumerable has 3 elements") def test_select(self): self.assertEqual( self.empty.select(lambda x: x['value']).count(), 0, u"Empty enumerable should still have 0 elements") simple_select = self.simple.select(lambda x: {'value': x}) self.assertDictEqual( simple_select.first(), {'value': 1}, u"Transformed simple enumerable element is dictionary") self.assertEqual( simple_select.count(), 3, u"Transformed simple enumerable has 3 elements") complex_select = self.complex.select(lambda x: x['value']) self.assertEqual( complex_select.count(), 3, u"Transformed complex enumerable has 3 elements") self.assertIsInstance( complex_select.first(), int, u"Transformed complex enumerable element is integer" ) def test_max_min(self): self.assertRaises(NoElementsError, self.empty.min) self.assertEqual( self.simple.min(), 1, u"Minimum value of simple enumerable is 1") self.assertEqual( self.complex.min(lambda x: x['value']), 1, u"Min value of complex enumerable is 1" ) self.assertRaises(NoElementsError, self.empty.max) self.assertEqual( self.simple.max(), 3, u"Max value of simple enumerable is 3") self.assertEqual( self.complex.max(lambda x: x['value']), 3, u"Max value of complex enumerable is 3") def test_avg(self): avg = float(2) self.assertRaises(NoElementsError, self.empty.avg) self.assertEqual( self.simple.avg(), avg, u"Avg value of simple enumerable is {0:.5f}".format(avg)) self.assertEqual( self.complex.avg(lambda x: x['value']), avg, u"Avg value of complex enumerable is {0:.5f}".format(avg)) def test_first_last(self): self.assertRaises(NoElementsError, self.empty.first) self.assertEqual( self.empty.first_or_default(), None, u"First or default should be None") self.assertIsInstance( self.simple.first(), int, u"First element in simple enumerable is int") self.assertEqual( self.simple.first(), 1, u"First element in simple enumerable is 1") self.assertEqual( self.simple.first(), self.simple.first_or_default(), u"First and first or default should equal") self.assertIsInstance( self.complex.first(), dict, u"First element in complex enumerable is dict") self.assertDictEqual( self.complex.first(), {'value': 1}, u"First element in complex enumerable is not correct dict") self.assertDictEqual( self.complex.first(), self.complex.first_or_default(), u"First and first or default should equal") self.assertEqual( self.simple.first(), self.complex.select(lambda x: x['value']).first(), u"First values in simple and complex should equal") self.assertRaises(NoElementsError, self.empty.last) self.assertEqual( self.empty.last_or_default(), None, u"Last or default should be None") self.assertIsInstance( self.simple.last(), int, u"Last element in simple enumerable is int") self.assertEqual( self.simple.last(), 3, u"Last element in simple enumerable is 3") self.assertEqual( self.simple.last(), self.simple.last_or_default(), u"Last and last or default should equal") self.assertIsInstance( self.complex.last(), dict, u"Last element in complex enumerable is dict") self.assertDictEqual( self.complex.last(), {'value': 3}, u"Last element in complex enumerable is not correct dict") self.assertDictEqual( self.complex.last(), self.complex.last_or_default(), u"Last and last or default should equal") self.assertEqual( self.simple.last(), self.complex.select(lambda x: x['value']).last(), u"Last values in simple and complex should equal") def test_sort(self): self.assertRaises(NullArgumentError, self.simple.order_by, None) self.assertRaises( NullArgumentError, self.simple.order_by_descending, None) self.assertListEqual( self.simple.order_by(lambda x: x).to_list(), self.simple.to_list(), u"Simple enumerable sort ascending should yield same list") self.assertListEqual( self.simple.order_by_descending(lambda x: x).to_list(), sorted(self.simple, key=lambda x: x, reverse=True), u"Simple enumerable sort descending should yield reverse list") self.assertListEqual( self.complex.order_by(lambda x: x['value']).to_list(), self.complex.to_list(), u"Complex enumerable sort ascending should yield same list") self.assertListEqual( self.complex.order_by_descending(lambda x: x['value']).to_list(), sorted(self.complex, key=lambda x: x['value'], reverse=True), u"Complex enumerable sort descending should yield reverse list") self.assertListEqual( self.simple.order_by(lambda x: x).to_list(), self.complex.select( lambda x: x['value'] ).order_by(lambda x: x).to_list(), u"Projection and sort ascending of complex should yield simple") def test_median(self): self.assertRaises(NoElementsError, self.empty.median) median = float(2) self.assertEqual( self.simple.median(), median, u"Median of simple enumerable should be {0:.5f}".format(median)) self.assertEqual( self.complex.median(lambda x: x['value']), median, u"Median of complex enumerable should be {0:.5f}".format(median)) def test_skip_take(self): self.assertListEqual( self.empty.skip(2).to_list(), [], u"Skip 2 of empty list should yield empty list") self.assertListEqual( self.empty.take(2).to_list(), [], u"Take 2 of empty list should yield empty list") self.assertListEqual( self.simple.skip(3).to_list(), [], u"Skip 3 of simple enumerable should yield empty list") self.assertListEqual( self.simple.take(4).to_list(), _simple, u"Take 4 of simple enumerable should yield simple list") self.assertEqual( self.simple.skip(1).take(1).first(), 2, u"Skip 1 and take 1 of simple should yield 2") self.assertEqual( self.complex.select(lambda x: x['value']).skip(1).take(1).first(), 2, u"Skip 1 and take 1 of complex with projection should yield 2") def test_filter(self): self.assertListEqual( self.empty.where(lambda x: x == 0).to_list(), [], u"Filter on empty list should yield empty list") self.assertListEqual( self.simple.where(lambda x: x == 2).to_list(), [2], u"Filter where element equals 2 should yield list with 1 element") self.assertListEqual( self.complex.where(lambda x: x['value'] == 2).to_list(), [{'value': 2}], u"Filter where element value is 2 should give list with 1 element") self.assertListEqual( self.complex.where(lambda x: x['value'] == 2) .select(lambda x: x['value']) .to_list(), self.simple.where(lambda x: x == 2).to_list(), u"Should equal filter of simple enumerable") self.assertListEqual( self.simple.where(lambda x: x == 0).to_list(), self.empty.to_list(), u"Should yield an empty list") def test_single_single_or_default(self): self.assertRaises(NullArgumentError, self.empty.single, None) self.assertRaises( NoMatchingElement, self.empty.single, lambda x: x == 0) self.assertRaises( NoMatchingElement, self.simple.single, lambda x: x == 0) self.assertRaises( NoMatchingElement, self.complex.single, lambda x: x['value'] == 0) self.assertRaises( MoreThanOneMatchingElement, self.simple.single, lambda x: x > 0) self.assertRaises( MoreThanOneMatchingElement, self.complex.single, lambda x: x['value'] > 0) self.assertRaises( MoreThanOneMatchingElement, self.simple.single_or_default, lambda x: x > 0) self.assertRaises( MoreThanOneMatchingElement, self.complex.single_or_default, lambda x: x['value'] > 0) simple_single = self.simple.single(lambda x: x == 2) self.assertIsInstance( simple_single, int, u"Should yield int") self.assertEqual( simple_single, 2, u"Should yield 2") complex_single = self.complex.single(lambda x: x['value'] == 2) self.assertIsInstance( complex_single, dict, "Should yield dict") self.assertDictEqual( complex_single, {'value': 2}, u"Yield '{'value':2}'") self.assertEqual( simple_single, self.complex.select(lambda x: x['value']).single(lambda x: x == 2), u"Projection and single on complex should yield single on simple") self.assertEqual( self.empty.single_or_default(lambda x: x == 0), None, u"Single or default on empty list should yield None") self.assertEqual( self.simple.single_or_default(lambda x: x == 0), None, u"Should yield None") self.assertEqual( self.complex.single_or_default(lambda x: x['value'] == 0), None, u"Should yield None") def test_select_many(self): empty = Enumerable([[], [], []]) simple = Enumerable([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) __complex = Enumerable( [ {'key': 1, 'values': [1, 2, 3]}, {'key': 2, 'values': [4, 5, 6]}, {'key': 3, 'values': [7, 8, 9]} ] ) self.assertListEqual( empty.select_many().to_list(), [], u"Should yield empty list") self.assertListEqual( simple.select_many().to_list(), [1, 2, 3, 4, 5, 6, 7, 8, 9], u"Should yield simple enumerable with single list") self.assertListEqual( __complex.select_many(lambda x: x['values']).to_list(), simple.select_many().to_list(), u"Should yield simple enumerable with single list") def test_concat(self): self.assertListEqual( self.empty.concat(self.empty).to_list(), [], u"Concatenation of 2 empty lists gives empty list") self.assertListEqual( self.empty.concat(self.simple).to_list(), _simple, u"Concatenation of empty to simple yields simple") self.assertListEqual( self.simple.concat(self.empty).to_list(), _simple, u"Concatenation of simple to empty yields simple") def test_group_by(self): simple_grouped = self.simple.group_by(key_names=['id']) self.assertEqual( simple_grouped.count(), 3, u"Three grouped elements in simple grouped") for g in simple_grouped: self.assertEqual( g.key.id, g.first(), u"Each id in simple grouped should match first value") complex_grouped = self.complex.group_by( key_names=['value'], key=lambda x: x['value']) self.assertEqual( complex_grouped.count(), 3, u"Three grouped elements in complex grouped") for g in complex_grouped: self.assertEqual( g.key.value, g.select(lambda x: x['value']).first(), u"Each value in complex grouped should mach first value") locations_grouped = Enumerable(_locations) \ .group_by( key_names=['country', 'city'], key=lambda x: [x[0], x[1]]) self.assertEqual( locations_grouped.count(), 7, u"Seven grouped elements in locations grouped") london = locations_grouped \ .single( lambda c: c.key.city == 'London' and c.key.country == 'England' ) self.assertEqual( london.sum(lambda c: c[3]), 240000, u"Sum of London, England location does not equal") def test_distinct(self): self.assertListEqual( self.empty.distinct().to_list(), [], u"Distinct empty enumerable yields empty list") self.assertListEqual( self.simple.concat(self.simple).distinct().to_list(), _simple, u"Distinct yields simple list") locations = Enumerable(_locations).distinct(lambda x: x[0]) self.assertEqual( locations.count(), 3, u"Three distinct countries in locations enumerable") self.assertListEqual( locations.to_list(), [ ('England', 'London', 'Branch1', 90000), ('Scotland', 'Edinburgh', 'Branch1', 20000), ('Wales', 'Cardiff', 'Branch1', 29700) ], u"Distinct locations do not match") def test_default_if_empty(self): self.assertListEqual( self.empty.default_if_empty().to_list(), [None], u"Should yield None singleton") self.assertListEqual( self.simple.default_if_empty().to_list(), _simple, u"Default if empty of simple enumerable should yield simple list") self.assertListEqual( self.complex.default_if_empty().to_list(), _complex, u"Should yield complex list") def test_any(self): self.assertRaises(NullArgumentError, self.simple.any, None) self.assertFalse( self.empty.any(lambda x: x == 1), u"Empty enumerable does not contain any elements that equal 1") self.assertTrue( self.simple.any(lambda x: x == 1), u"Simple enumerable does contain elements that equal 1") self.assertFalse( self.complex.any(lambda x: x['value'] < 1), u"Complex enumerable does not contain any elements with value < 1") self.assertTrue( self.complex.any(lambda x: x['value'] >= 1), u"Complex enumerable does contain elements with value >= 1") def test_contains(self): self.assertFalse( self.empty.contains(1), u"Empty enumerable should not contain 1 as element") self.assertTrue( self.simple.contains(1), u"Simple enumerable should contain 1 as element") self.assertTrue( self.complex.select(lambda x: x['value']).contains(1), u"Complex enumerable should contain 1 as an element value") def test_intersect(self): self.assertRaises(TypeError, self.empty.intersect, []) self.assertListEqual( self.empty.intersect(self.empty).to_list(), [], u"Intersect of two empty enumerables yield empty list") self.assertListEqual( self.empty.intersect(self.simple).to_list(), [], u"Intersect of empty and simple enumerables yields empty list") self.assertListEqual( self.simple.intersect(self.simple).to_list(), _simple, u"Intersect of two simple enumerables yields simple list") self.assertListEqual( self.simple.intersect(Enumerable([2])).to_list(), [2], u"Intersect of simple enumerable and [2] yields [2]") self.assertListEqual( self.simple.intersect(self.complex).to_list(), [], u"Intersect of simple and complex enumerable yields empty list") self.assertListEqual( self.complex.intersect(self.complex).to_list(), _complex, u"Intersect of two complex enumeraable yields complex list") self.assertListEqual( self.complex.intersect(Enumerable([{'value': 1}])).to_list(), [{'value': 1}], "Should yield {'value': 1}") def test_except(self): self.assertRaises(TypeError, self.empty.except_, []) self.assertListEqual( self.empty.except_(self.empty).to_list(), [], u"Complement of two empty enumerables yields empty list") self.assertListEqual( self.empty.except_(self.simple).to_list(), [], u"Complement of empty and simple enumerables yields empty list") self.assertListEqual( self.simple.except_(self.empty).to_list(), _simple, u"Complement of simple and empty enumerables yields simple list") self.assertListEqual( self.simple.except_(self.simple).to_list(), [], u"Complement of simple and simple enumerables yields empty list") self.assertListEqual( self.simple.except_(Enumerable([2])).to_list(), [1, 3], u"Complement of simple and [2] yields [1,3]") self.assertListEqual( self.simple.except_(self.complex).to_list(), _simple, u"Complement of simple and complex yields simple") self.assertListEqual( self.complex.except_(self.simple).to_list(), _complex, u"Complement of complex and simple yields complex") self.assertListEqual( self.complex.except_(self.complex).to_list(), [], u"Complement of complex and complex yields empty") self.assertListEqual( self.complex.except_(Enumerable([{'value': 1}])).to_list(), [{'value': 2}, {'value': 3}], "Should yield [{'value': 2}, 'value': 3]") def test_marks_intersect(self): marks1 = Enumerable([{'course': 'Chemistry', 'mark': 90}, {'course': 'Biology', 'mark': 85}]) marks2 = Enumerable([{'course': 'Chemistry', 'mark': 65}, {'course': 'Computer Science', 'mark': 96}]) self.assertListEqual( marks1.intersect(marks2, lambda c: c['course']).to_list(), [{'course': 'Chemistry', 'mark': 90}] ) def test_marks_except(self): marks1 = Enumerable([{'course': 'Chemistry', 'mark': 90}, {'course': 'Biology', 'mark': 85}]) marks2 = Enumerable([{'course': 'Chemistry', 'mark': 65}, {'course': 'Computer Science', 'mark': 96}]) self.assertListEqual( marks1.except_(marks2, lambda c: c['course']).to_list(), [{'course': 'Biology', 'mark': 85}] ) def test_union(self): self.assertListEqual( self.empty.union(self.empty).to_list(), [], u"Union of two empty enumerables yields empty list") self.assertListEqual( self.empty.union(self.simple).to_list(), _simple, u"Union of empty and simple yield simple") self.assertListEqual( self.simple.union(self.empty).to_list(), _simple, u"Union of simple and empty yield simple") self.assertListEqual( self.empty.union(self.complex).to_list(), _complex, u"Union of empty and complex yield complex") self.assertListEqual( self.complex.union(self.empty).to_list(), _complex, u"Union of complex and empty yield complex") simple_extended = _simple + [4, 5] self.assertListEqual( self.simple.union(Enumerable([4, 5])).to_list(), simple_extended, u"Union of simple and [4,5] yield simple + [4,5]") self.assertListEqual( self.simple.union(Enumerable([1, 4, 5])) .order_by(lambda x: x).to_list(), simple_extended, u"Union of simple and [1,4,5] yield simple + [4,5]") complex_extended = _complex + [{'value': 4}, {'value': 5}] self.assertListEqual( self.complex.union( Enumerable([{'value': 4}, {'value': 5}]), lambda x: x['value']).to_list(), complex_extended, u"Should yield complex + [{'value': 4}, {'value': 5}]") self.assertListEqual( self.complex.union( Enumerable([{'value': 1}, {'value': 4}, {'value': 5}]), lambda x: x['value']).order_by(lambda x: x['value']).to_list(), complex_extended, u"Should yield complex + [{'value': 4}, {'value': 5}]") def test_join(self): self.assertRaises(TypeError, self.empty.join, []) self.assertListEqual( self.empty.join(self.empty).to_list(), [], u"Joining 2 empty lists should yield empty list") self.assertListEqual( self.empty.join(self.simple).to_list(), [], u"Joining empty to simple yields empty list") self.assertListEqual( self.empty.join(self.complex).to_list(), [], u"Joining complex to simple yields empty list") self.assertListEqual( self.simple.join(self.empty).to_list(), [], u"Joining simple to empty yields empty list") self.assertListEqual( self.simple.join(self.simple) .order_by(lambda x: (x[0], x[1])).to_list(), [(1, 1), (2, 2), (3, 3)], u"Joining simple to simple yields [(1,1), (2,2), (3,3)]") self.assertListEqual( self.simple.join( self.complex, inner_key=lambda x: x['value'], result_func=lambda x: (x[0], x[1]['value'])).order_by( lambda x: (x[0], x[1]) ).to_list(), [(1, 1), (2, 2), (3, 3)], u"Should yield [(1,1), (2,2), (3,3)]") self.assertListEqual( self.complex.join( self.complex, result_func=lambda x: (x[0]['value'], x[1]['value'])).order_by( lambda x: (x[0], x[1])).to_list(), [(1, 1), (2, 2), (3, 3)], u"Should yield [(1,1), (2,2), (3,3)]") def test_group_join(self): self.assertRaises(TypeError, self.empty.group_join, []) self.assertListEqual( self.empty.group_join(self.empty).to_list(), [], u"Group join 2 empty yields empty") simple_empty_gj = self.simple.group_join(self.empty) self.assertEqual( simple_empty_gj.count(), 3, u"Should have 3 elements") for i, e in enumerate(simple_empty_gj): self.assertEqual( e[0], i + 1, u"number property should be {0}".format(i + 1)) self.assertEqual( e[1].count(), 0, u"Should have 0 elements") self.assertEqual( e[1].first_or_default(), None, u"Value of first element should be None") simple_gj = self.simple.group_join( self.simple, result_func=lambda x: { 'number': x[0], 'collection': x[1] }) for i, e in enumerate(simple_gj): self.assertEqual( e['number'], i + 1, u"number property should be {0}".format(i + 1)) self.assertEqual( e['collection'].count(), 1, u"Should only have one element") self.assertEqual( e['collection'].first(), i + 1, u"Value of first element should equal {0}".format(i + 1)) complex_simple_gj = self.complex.group_join( self.simple, outer_key=lambda x: x['value']) for i, e in enumerate(complex_simple_gj): self.assertEqual( e[0]['value'], i + 1, u"value property of each element should be {0}".format(i + 1)) self.assertEqual( e[1].count(), 1, u"Should only have one element") self.assertEqual( e[1].first(), i + 1, u"Value of first element should equal {0}".format(i + 1)) simple_gj = self.simple.group_join( Enumerable([2, 3]), result_func=lambda x: { 'number': x[0], 'collection': x[1] }).to_list() self.assertEqual( len(simple_gj), 3, u"Should be 3 elements") for i, e in enumerate(simple_gj): self.assertEqual( e['number'], i + 1, u"number property should be {0}".format(i + 1)) self.assertEqual( e['collection'].count(), 0 if i == 0 else 1, u"should have {0} element(s)".format(0 if i == 0 else 1)) self.assertListEqual( e['collection'].to_list(), [] if i == 0 else [i + 1], u"Collection should equal {0}".format( [] if i == 0 else [i + 1]) ) def test_then_by(self): locations = Enumerable(_locations) self.assertListEqual( locations.order_by(lambda l: l[0]) .then_by(lambda l: l[1]) .select(lambda l: u"{0}, {1}".format(l[1], l[0])) .to_list(), [ u'Liverpool, England', u'Liverpool, England', u'London, England', u'London, England', u'London, England', u'Manchester, England', u'Manchester, England', u'Edinburgh, Scotland', u'Glasgow, Scotland', u'Glasgow, Scotland', u'Bangor, Wales', u'Cardiff, Wales', u'Cardiff, Wales' ], u"then_by locations ordering is not correct") self.assertRaises( NullArgumentError, locations.order_by(lambda l: l[0]).then_by, None) def test_then_by_descending(self): locations = Enumerable(_locations) self.assertListEqual( locations.order_by(lambda l: l[0]) .then_by(lambda l: l[1]) .then_by_descending(lambda l: l[3]) .select(lambda l: u"{0}, {1}: {2}".format( l[1], l[0], l[3] )) .to_list(), [ u'Liverpool, England: 29700', u'Liverpool, England: 25000', u'London, England: 90000', u'London, England: 80000', u'London, England: 70000', u'Manchester, England: 50000', u'Manchester, England: 45600', u'Edinburgh, Scotland: 20000', u'Glasgow, Scotland: 12500', u'Glasgow, Scotland: 12000', u'Bangor, Wales: 12800', u'Cardiff, Wales: 30000', u'Cardiff, Wales: 29700' ], u"then_by_descending ordering is not correct" ) def reverse(self, result, element): return element + " " + result def sum(self, result, element): return result + element def test_aggregate(self): words = u"the quick brown fox jumps over the lazy dog".split(" ") self.assertListEqual(words, ["the", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"]) test = Enumerable(words).aggregate(self.reverse) self.assertEqual(test, "dog lazy the over jumps fox brown quick the") self.assertRaises(NoElementsError, Enumerable().aggregate, [lambda x: x[0] + x[1], 0]) test = self.simple.aggregate(self.sum, seed=0) self.assertEqual(test, 6) def test_all(self): test = Enumerable([1, 1, 1]).all(lambda x: x == 1) self.assertTrue(test) test = Enumerable([]).all(lambda x: x == 1) self.assertTrue(test) test = self.simple.all(lambda x: x == 1) self.assertFalse(test) def test_append(self): test = self.simple.append(4) self.assertEqual(test.count(), 4) self.assertEqual(test.element_at(3), 4) def test_prepend(self): test = self.simple.prepend(4) self.assertEqual(test.count(), 4) self.assertEqual(test.element_at(0), 4) def test_empty(self): test = Enumerable.empty() self.assertIsInstance(test, Enumerable) self.assertEqual(test.count(), 0) def test_range(self): test = Enumerable.range(1, 3) self.assertEqual(test.count(), 3) self.assertListEqual(self.simple.to_list(), test.to_list()) def test_repeat(self): test = Enumerable.repeat(u'Z', 10) self.assertEqual(test.count(), 10) self.assertEqual(u"".join(test.to_list()), u'ZZZZZZZZZZ') def test_reverse(self): test = self.simple.reverse() self.assertListEqual(test.to_list(), [3, 2, 1]) words = u"the quick brown fox jumps over the lazy dog".split(" ") self.assertListEqual(words, ["the", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"]) test = Enumerable(words).reverse() self.assertEqual(u" ".join(test.to_list()), u"dog lazy the over jumps fox brown quick the") def test_skip_last(self): test = Enumerable([1, 2, 3, 4, 5]).skip_last(2) self.assertListEqual(test.to_list(), [1, 2, 3]) test = Enumerable(["one", "two", "three", "four", "five"]).skip(1).skip_last(1) self.assertListEqual(test.to_list(), ["two", "three", "four"]) def test_skip_while(self): test = Enumerable([1, 4, 6, 4, 1]).skip_while(lambda x: x < 5) self.assertListEqual(test.to_list(), [6, 4, 1]) test = Enumerable([]).skip_while(lambda x: x < 5) self.assertListEqual(test.to_list(), []) def test_take_last(self): test = Enumerable([1, 2, 3, 4, 5]).take_last(2) self.assertListEqual(test.to_list(), [4, 5]) test = Enumerable(["one", "two", "three", "four", "five"]).take(3).take_last(1) self.assertListEqual(test.to_list(), ["three"]) def test_take_while(self): test = Enumerable([1, 4, 6, 4, 1]).take_while(lambda x: x < 5) self.assertListEqual(test.to_list(), [1, 4]) test = Enumerable([]).skip_while(lambda x: x < 5) self.assertListEqual(test.to_list(), []) def test_zip(self): test = Enumerable(["A", "B", "C", "D"]).zip(Enumerable(["x", "y"]), lambda t: "{0}{1}".format(t[0], t[1])) self.assertListEqual(test.to_list(), ["Ax", "By"])
def test_take_while(self): test = Enumerable([1, 4, 6, 4, 1]).take_while(lambda x: x < 5) self.assertListEqual(test.to_list(), [1, 4]) test = Enumerable([]).skip_while(lambda x: x < 5) self.assertListEqual(test.to_list(), [])
def test_zip(self): test = Enumerable(["A", "B", "C", "D"]).zip(Enumerable(["x", "y"]), lambda t: "{0}{1}".format(t[0], t[1])) self.assertListEqual(test.to_list(), ["Ax", "By"])
def test_take_last(self): test = Enumerable([1, 2, 3, 4, 5]).take_last(2) self.assertListEqual(test.to_list(), [4, 5]) test = Enumerable(["one", "two", "three", "four", "five"]).take(3).take_last(1) self.assertListEqual(test.to_list(), ["three"])
def test_skip_last(self): test = Enumerable([1, 2, 3, 4, 5]).skip_last(2) self.assertListEqual(test.to_list(), [1, 2, 3]) test = Enumerable(["one", "two", "three", "four", "five"]).skip(1).skip_last(1) self.assertListEqual(test.to_list(), ["two", "three", "four"])
def test_empty(self): test = Enumerable.empty() self.assertIsInstance(test, Enumerable) self.assertEqual(test.count(), 0)
def test_repeat(self): test = Enumerable.repeat(u'Z', 10) self.assertEqual(test.count(), 10) self.assertEqual(u"".join(test.to_list()), u'ZZZZZZZZZZ')
def test_range(self): test = Enumerable.range(1, 3) self.assertEqual(test.count(), 3) self.assertListEqual(self.simple.to_list(), test.to_list())