class TestFunctions(TestCase): def setUp(self): self.empty = Enumerable(_empty) self.simple = Enumerable(_simple) self.complex = Enumerable(_complex) def test_iter(self): self.assertListEqual(_simple, list(iter(self.simple))) self.assertListEqual(_empty, list(iter(self.empty))) self.assertListEqual(_complex, list(iter(self.complex))) def test_iter_select(self): self.assertListEqual(_empty, list(iter(self.empty.select(lambda x: x)))) self.assertListEqual(_simple, list(iter(self.simple.select(lambda x: x)))) self.assertListEqual( _simple, list(iter(self.complex.select(lambda x: x["value"]))) ) def test_iter_where(self): self.assertListEqual(_empty, list(iter(self.empty.where(lambda x: x == 2)))) self.assertListEqual([2], list(iter(self.simple.where(lambda x: x == 2)))) self.assertListEqual( [{"value": 2}], list(iter(self.complex.where(lambda x: x["value"] == 2))) ) def test_len(self): self.assertEqual(0, len(self.empty)) self.assertEqual(3, len(self.simple)) def test_get_item(self): self.assertIsNone(self.empty[0]) self.assertEqual(2, self.simple[1]) self.assertDictEqual({"value": 2}, self.complex[1]) def test_get_item_select(self): self.assertIsNone(self.empty.select(lambda x: x["value"])[0]) self.assertEqual(2, self.complex.select(lambda x: x["value"])[1]) self.assertEqual({"value": 2}, self.simple.select(lambda x: {"value": x})[1]) def test_to_list(self): self.assertListEqual(_empty, self.empty.to_list()) self.assertListEqual(_simple, self.simple.to_list()) self.assertListEqual(_complex, self.complex.to_list()) def test_sum(self): self.assertEqual(0, self.empty.sum()) self.assertEqual(6, self.simple.sum()) def test_sum_with_filter(self): self.assertEqual(6, self.complex.sum(lambda x: x["value"])) def test_count(self): self.assertEqual(self.empty.count(), 0) self.assertEqual(self.simple.count(), 3) self.assertEqual(self.complex.count(), 3) def test_count_with_filter(self): self.assertEqual(self.empty.count(lambda x: x == 1), 0) self.assertEqual(self.simple.count(lambda x: x == 1), 1) self.assertEqual(self.complex.count(lambda x: x["value"] > 1), 2) def test_select(self): self.assertListEqual( [], Enumerable.empty().select(lambda x: x["value"]).to_list() ) self.assertListEqual( [{"value": 1}, {"value": 2}, {"value": 3}], Enumerable([1, 2, 3]).select(lambda x: {"value": x}).to_list(), ) self.assertListEqual( [1, 2, 3], Enumerable( [ {"value": 1}, {"value": 2}, {"value": 3}, ] ) .select(lambda x: x["value"]) .to_list(), ) def test_min(self): self.assertRaises(NoElementsError, self.empty.min) self.assertEqual(1, self.simple.min()) self.assertEqual(1, self.complex.min(lambda x: x["value"])) def test_max(self): self.assertRaises(NoElementsError, self.empty.max) self.assertEqual(3, self.simple.max()) self.assertEqual(3, self.complex.max(lambda x: x["value"])) def test_avg(self): avg = float(2) self.assertRaises(NoElementsError, self.empty.avg) self.assertEqual(self.simple.avg(), avg) self.assertEqual(self.complex.avg(lambda x: x["value"]), avg) def test_element_at(self): self.assertRaises(IndexError, self.empty.element_at, 0) self.assertEqual(2, self.simple.element_at(1)) self.assertDictEqual({"value": 2}, self.complex.element_at(1)) def test_first(self): self.assertRaises(IndexError, self.empty.first) self.assertIsInstance(self.simple.first(), int) self.assertEqual(1, self.simple.order_by(lambda x: x).first()) self.assertIsInstance(self.complex.first(), dict) self.assertDictEqual( {"value": 1}, self.complex.order_by(lambda x: x["value"]).first() ) def test_first_or_default(self): self.assertIsNone(self.empty.first_or_default()) self.assertIsInstance(self.simple.first_or_default(), int) self.assertDictEqual({"value": 1}, self.complex.first_or_default()) def test_last(self): self.assertRaises(IndexError, self.empty.last) self.assertIsInstance(self.simple.last(), int) self.assertEqual(3, self.simple.order_by(lambda x: x).last()) self.assertIsInstance(self.complex.last(), dict) self.assertDictEqual( {"value": 3}, self.complex.order_by(lambda x: x["value"]).last() ) self.assertDictEqual( self.complex.order_by(lambda x: x["value"]).last(), self.complex.order_by(lambda x: x["value"]).last_or_default(), ) def test_last_or_default(self): self.assertIsNone(self.empty.last_or_default()) self.assertEqual(3, self.simple.order_by(lambda x: x).last_or_default()) self.assertIsInstance(self.complex.last_or_default(), dict) self.assertDictEqual( {"value": 3}, self.complex.order_by(lambda x: x["value"]).last_or_default() ) def test_order_by(self): self.assertRaises(NullArgumentError, self.simple.order_by, None) self.assertListEqual(_simple, self.simple.order_by(lambda x: x).to_list()) self.assertListEqual( _complex, self.complex.order_by(lambda x: x["value"]).to_list() ) def test_order_by_descending(self): self.assertRaises(NullArgumentError, self.simple.order_by_descending, None) self.assertListEqual( [3, 2, 1], self.simple.order_by_descending(lambda x: x).to_list() ) self.assertListEqual( [{"value": 3}, {"value": 2}, {"value": 1}], self.complex.order_by_descending(lambda x: x["value"]).to_list(), ) def test_order_by_with_select(self): self.assertListEqual( _simple, self.complex.select(lambda x: x["value"]).order_by(lambda x: x).to_list(), ) def test_order_by_descending_with_select(self): self.assertListEqual( [3, 2, 1], self.complex.select(lambda x: x["value"]) .order_by_descending(lambda x: x) .to_list(), ) def test_order_by_with_where(self): self.assertListEqual( [2, 3], self.simple.where(lambda x: x >= 2).order_by(lambda x: x).to_list() ) def test_order_by_descending_with_where(self): self.assertListEqual( [3, 2], self.simple.where(lambda x: x >= 2) .order_by_descending(lambda x: x) .to_list(), ) def test_median(self): self.assertRaises(NoElementsError, self.empty.median) median = float(2) self.assertEqual(median, self.simple.median()) self.assertEqual(median, self.complex.median(lambda x: x["value"])) def test_skip(self): self.assertListEqual([], Enumerable().skip(2).to_list()) self.assertListEqual([], Enumerable([1, 2, 3]).skip(3).to_list()) self.assertListEqual([2, 3], Enumerable([1, 2, 3]).skip(1).to_list()) def test_take(self): self.assertListEqual(_simple, self.simple.take(4).to_list()) def test_skip_with_take(self): self.assertListEqual([2], self.simple.skip(1).take(1).to_list()) def test_skip_take_with_select(self): self.assertListEqual( [2], self.complex.select(lambda x: x["value"]).skip(1).take(1).to_list() ) def test_filter(self): self.assertListEqual([], self.empty.where(lambda x: x == 0).to_list()) self.assertListEqual([2], self.simple.where(lambda x: x == 2).to_list()) self.assertListEqual( [{"value": 2}], self.complex.where(lambda x: x["value"] == 2).to_list() ) self.assertListEqual([], self.simple.where(lambda x: x == 0).to_list()) def test_select_with_filter(self): self.assertListEqual( [2], Enumerable([{"value": 1}, {"value": 2}, {"value": 3}]) .where(lambda x: x["value"] == 2) .select(lambda x: x["value"]) .to_list(), ) def test_single(self): self.assertRaises(NoMatchingElement, self.empty.single, lambda x: x == 0) self.assertRaises(NoMatchingElement, self.empty.single, None) self.assertRaises(NoMatchingElement, self.simple.single, lambda x: x == 0) self.assertRaises(MoreThanOneMatchingElement, self.simple.single, None) self.assertRaises( NoMatchingElement, self.complex.single, lambda x: x["value"] == 0 ) self.assertRaises(MoreThanOneMatchingElement, self.complex.single, None) self.assertRaises( MoreThanOneMatchingElement, self.simple.single, lambda x: x > 0 ) self.assertRaises( MoreThanOneMatchingElement, self.complex.single, lambda x: x["value"] > 0 ) def test_single(self): simple_single = self.simple.single(lambda x: x == 2) self.assertIsInstance(simple_single, int) self.assertEqual(2, simple_single) complex_single = self.complex.single(lambda x: x["value"] == 2) self.assertIsInstance(complex_single, dict) self.assertDictEqual({"value": 2}, complex_single) select_single = self.complex.select(lambda x: x["value"]).single( lambda x: x == 2 ) self.assertEqual(2, select_single) def test_single_or_default(self): self.assertRaises( MoreThanOneMatchingElement, self.simple.single_or_default, lambda x: x > 0 ) self.assertIsNone(self.simple.single_or_default(lambda x: x > 3)) self.assertRaises( MoreThanOneMatchingElement, self.complex.single_or_default, lambda x: x["value"] > 0, ) 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 test_concat(self): self.assertListEqual([], Enumerable().concat(Enumerable()).to_list()) self.assertListEqual( [1, 2, 3], Enumerable().concat(Enumerable([1, 2, 3])).to_list() ) self.assertListEqual( [1, 2, 3], Enumerable([1, 2, 3]).concat(Enumerable()).to_list() ) self.assertListEqual( [1, 2, 3, 1, 2, 3], Enumerable([1, 2, 3]) .concat( Enumerable( [ {"value": 1}, {"value": 2}, {"value": 3}, ] ).select(lambda c: c["value"]) ) .to_list(), ) self.assertListEqual( [1, 2, 3, 1, 2, 3], Enumerable( [ {"value": 1}, {"value": 2}, {"value": 3}, ] ) .select(lambda c: c["value"]) .concat(Enumerable([1, 2, 3])) .to_list(), ) self.assertListEqual( [1, 2, 3, {"value": 1}, {"value": 2}, {"value": 3}], Enumerable([1, 2, 3]) .concat( Enumerable( [ {"value": 1}, {"value": 2}, {"value": 3}, ] ) ) .to_list(), ) def test_concat_mutating(self): empty = Enumerable() empty.concat(Enumerable()) self.assertListEqual([], empty.to_list()) simple = Enumerable() simple.concat(Enumerable([1, 2, 3])) self.assertListEqual([1, 2, 3], simple.to_list()) double_simple = Enumerable([1, 2, 3]) double_simple.concat( Enumerable( [ {"value": 1}, {"value": 2}, {"value": 3}, ] ).select(lambda c: c["value"]) ) self.assertListEqual([1, 2, 3, 1, 2, 3], double_simple.to_list()) simple_complex = Enumerable([1, 2, 3]) simple_complex.concat( Enumerable( [ {"value": 1}, {"value": 2}, {"value": 3}, ] ) ) self.assertListEqual( [1, 2, 3, {"value": 1}, {"value": 2}, {"value": 3}], simple_complex.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 test_group_by(self): simple_grouped = Enumerable([1, 2, 3]).group_by(key_names=["id"]) self.assertEqual(3, simple_grouped.count()) second = simple_grouped.single(lambda s: s.key.id == 2) self.assertListEqual([2], second.to_list()) complex_grouped = Enumerable( [{"value": 1}, {"value": 2}, {"value": 3}] ).group_by(key_names=["value"], key=lambda x: x["value"]) self.assertEqual(complex_grouped.count(), 3) self.assertListEqual( [1, 2, 3], complex_grouped.select(lambda x: x.key.value) .order_by(lambda x: x) .to_list(), ) locations_grouped = Enumerable(_locations).group_by( key_names=["country", "city"], key=lambda x: [x[0], x[1]] ) self.assertEqual(locations_grouped.count(), 7) london = locations_grouped.single( lambda c: c.key.city == "London" and c.key.country == "England" ) self.assertEqual(240000, london.sum(lambda c: c[3])) def test_distinct(self): self.assertListEqual([], Enumerable.empty().distinct().to_list()) six.assertCountEqual( self, [1, 2, 3], Enumerable([1, 2, 3]).concat(Enumerable([1, 2, 3])).distinct().to_list(), ) locations = Enumerable(_locations).distinct(lambda x: x[0]) self.assertEqual(locations.count(), 3) def test_default_if_empty(self): self.assertListEqual([None], self.empty.default_if_empty().to_list()) six.assertCountEqual(self, _simple, self.simple.default_if_empty().to_list()) six.assertCountEqual(self, _complex, self.complex.default_if_empty().to_list()) def test_any(self): self.assertFalse(Enumerable.empty().any(lambda x: x == 1)) self.assertFalse(Enumerable.empty().any()) self.assertTrue(Enumerable([1, 2, 3]).any(lambda x: x == 1)) self.assertTrue(Enumerable([1, 2, 3]).any()) self.assertTrue(Enumerable([{"value": 1}, {"value": 2}, {"value": 3}]).any()) self.assertFalse( Enumerable([{"value": 1}, {"value": 2}, {"value": 3}]).any( lambda x: x["value"] < 1 ) ) self.assertTrue( Enumerable([{"value": 1}, {"value": 2}, {"value": 3}]).any( lambda x: x["value"] >= 1 ) ) def test_contains(self): self.assertFalse(self.empty.contains(1)) self.assertTrue(self.simple.contains(1)) self.assertTrue(self.complex.select(lambda x: x["value"]).contains(1)) def test_intersect(self): self.assertRaises(TypeError, Enumerable.empty().intersect, []) self.assertListEqual([], Enumerable().intersect(Enumerable.empty()).to_list()) self.assertListEqual( [], Enumerable.empty().intersect(Enumerable([1, 2, 3])).to_list() ) self.assertListEqual( [1, 2, 3], Enumerable([1, 2, 3]).intersect(Enumerable([1, 2, 3])).to_list() ) self.assertListEqual( [2], Enumerable([1, 2, 3]).intersect(Enumerable([2])).to_list() ) self.assertListEqual( [], Enumerable([1, 2, 3]) .intersect( Enumerable( [ {"value": 1}, {"value": 2}, {"value": 3}, ] ) ) .to_list(), ) self.assertListEqual( [ {"value": 1}, {"value": 2}, {"value": 3}, ], Enumerable( [ {"value": 1}, {"value": 2}, {"value": 3}, ] ) .intersect( Enumerable( [ {"value": 1}, {"value": 2}, {"value": 3}, ] ) ) .to_list(), ) self.assertListEqual( Enumerable( [ {"value": 1}, {"value": 2}, {"value": 3}, ] ) .intersect(Enumerable([{"value": 1}])) .to_list(), [{"value": 1}], ) def test_except(self): self.assertRaises(TypeError, self.empty.except_, []) self.assertListEqual([], self.empty.except_(self.empty).to_list()) self.assertListEqual([], self.empty.except_(self.simple).to_list()) self.assertListEqual(_simple, self.simple.except_(self.empty).to_list()) self.assertListEqual([], self.simple.except_(self.simple).to_list()) self.assertListEqual([1, 3], self.simple.except_(Enumerable([2])).to_list()) self.assertListEqual(_simple, self.simple.except_(self.complex).to_list()) self.assertListEqual(_complex, self.complex.except_(self.simple).to_list()) self.assertListEqual([], self.complex.except_(self.complex).to_list()) self.assertListEqual( [{"value": 2}, {"value": 3}], self.complex.except_(Enumerable([{"value": 1}])).to_list(), ) 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( [{"course": "Chemistry", "mark": 90}], marks1.intersect(marks2, lambda c: c["course"]).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 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_join(self): self.assertRaises(TypeError, Enumerable.empty().join, []) self.assertListEqual([], Enumerable().join(Enumerable()).to_list()) self.assertListEqual([], Enumerable().join(Enumerable([1, 2, 3])).to_list()) self.assertListEqual( [], Enumerable() .join(Enumerable([{"value": 1}, {"value": 2}, {"value": 3}])) .to_list(), ) self.assertListEqual( [(1, 1), (2, 2), (3, 3)], Enumerable([1, 2, 3]) .join(Enumerable([1, 2, 3])) .order_by(lambda x: (x[0], x[1])) .to_list(), ) self.assertListEqual( [(1, 1), (2, 2), (3, 3)], Enumerable([1, 2, 3]) .join( Enumerable([{"value": 1}, {"value": 2}, {"value": 3}]), 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(), ) self.assertListEqual( [(1, 1), (2, 2), (3, 3)], Enumerable([{"value": 1}, {"value": 2}, {"value": 3}]) .join( Enumerable([{"value": 1}, {"value": 2}, {"value": 3}]), result_func=lambda x: (x[0]["value"], x[1]["value"]), ) .order_by(lambda x: (x[0], x[1])) .to_list(), ) def test_group_join(self): self.assertRaises(TypeError, Enumerable.empty().group_join, []) self.assertListEqual([], Enumerable().group_join(Enumerable()).to_list()) simple_empty_gj = Enumerable([1, 2, 3]).group_join(self.empty) self.assertListEqual([], simple_empty_gj.to_list()) complex_simple_gj = Enumerable( [{"value": 1}, {"value": 2}, {"value": 3}] ).group_join(Enumerable([1, 2, 3, 3]), outer_key=lambda x: x["value"]) self.assertListEqual( [({"value": 1}, [1]), ({"value": 2}, [2]), ({"value": 3}, [3, 3])], complex_simple_gj.select(lambda g: (g[0], g[1].to_list())).to_list(), ) simple_gj = Enumerable([1, 2, 3]).group_join( Enumerable([2, 3]), result_func=lambda x: {"number": x[0], "collection": x[1].to_list()}, ) self.assertEqual(2, simple_gj.count()) self.assertListEqual( [ {"number": 2, "collection": [2]}, {"number": 3, "collection": [3]}, ], simple_gj.to_list(), ) 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_then_by_descending(self): locations = Enumerable(_locations) self.assertListEqual( [ 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", ], 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(), ) 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.assertEqual(0, 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(10, test.count()) self.assertEqual(u"ZZZZZZZZZZ", u"".join(test.to_list())) def test_reverse(self): test = self.empty.reverse() self.assertListEqual(test.to_list(), []) test = self.simple.reverse() self.assertListEqual(test.to_list(), [3, 2, 1]) self.assertEqual(3, test.count()) 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([1, 2, 3], test.to_list()) 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([6, 4, 1], test.to_list()) 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"])
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"])
'gid': 1 }, { 'name': 'Joanne Smith', 'mark': 90, 'gid': 2 }]) group = Enumerable([{'id': 1}, {'id': 2}]) names = students.where(lambda x: x['mark'] > 50) \ .join(group, lambda s: s['gid'], lambda g: g['id'], lambda res: (res[0], res[0].update(res[1]))[0]) \ .select(lambda x: x['name']) \ .order_by(lambda x: x) \ .reverse() \ .distinct() \ .skip(1) \ .count() res = students.any(lambda x: 'o' in x['name']) res2 = students.all(lambda x: 'a' in x['name']) res3 = students.contains({'name': 'Joanne Smith'}, lambda x: x['name']) name1 = students.take(1).concat(students).element_at(2) name2 = students.last() name3 = students.first() print(names) print(res, res2, res3) print(name1) print(name2) print(name3)