def test_when_run_select_then_return_correct_values(self):
dummies = [Dummy(1, 2), Dummy(2, 4), Dummy(3, 6), Dummy(4, 8)]
values = Enumerable(dummies).select(lambda x: x.A).to_list()
self.assertSequenceEqual(values, [1, 2, 3, 4])
values = Enumerable(dummies).select(lambda x: x.B).to_list()
self.assertSequenceEqual(values, [2, 4, 6, 8])
def test_when_run_where_then_return_correct_values(self):
enumerable = Enumerable(generate)
where_enumerable = enumerable.where(lambda x: x > 2)
self.assertIsInstance(where_enumerable, Enumerable)
values = where_enumerable.to_list()
self.assertSequenceEqual(values, [3, 4, 5, 6, 7])
def test_when_sort_descending_then_return_values_sorted_descending(self):
a = Dummy(1, 8)
b = Dummy(2, 6)
c = Dummy(3, 4)
d = Dummy(4, 2)
dummies = [a, b, c, d]
values = Enumerable(dummies).sort(lambda x: x.B, descending=True)
self.assertSequenceEqual(values.to_list(), [a, b, c, d])
def test_when_create_several_enumerables_from_same_enumerable_then_return_correct_values(
self):
enumerable_1 = Enumerable(generate).where(lambda x: x > 0)
enumerable_2 = enumerable_1.where(lambda x: x > 4)
enumerable_3 = enumerable_1.where(lambda x: x < 4)
self.assertSequenceEqual(enumerable_3.to_list(), [1, 2, 3])
self.assertSequenceEqual(enumerable_2.to_list(), [5, 6, 7])
def test_when_run_where_then_enumerate_only_after_to_list(self):
sequence = []
def less_than_5(x):
w = x < 5
sequence.append(5)
return w
enumerable = Enumerable(generate).where(less_than_5).where(less_than_5)
self.assertTrue(len(sequence) == 0)
enumerable.to_list()
self.assertTrue(len(sequence) > 0)
def test_when_run_where_and_select_in_sequence_then_return_correct_values(
self):
dummies = [Dummy(1, 2), Dummy(2, 4), Dummy(3, 6), Dummy(4, 8)]
values = Enumerable(dummies).where(lambda x: x.A < 3).select(
lambda x: x.B).to_list()
self.assertSequenceEqual(values, [2, 4])
def test_when_group_by_member_then_return_correct_dictionary(self):
a = Dummy(1, "a")
b = Dummy(1, "b")
c = Dummy(2, "c")
d = Dummy(2, "d")
e = Dummy(3, "e")
dummies = [a, b, c, d, e]
values = Enumerable(dummies).group_by(lambda x: x.A)
self.assertIsInstance(values, dict)
self.assertDictEqual(values, {1: [a, b], 2: [c, d], 3: [e]})
def test_when_run_several_where_in_sequence_then_run_interleaved(self):
sequence = []
def less_than_5(x):
w = x < 5
sequence.append(5)
return w
def greater_than_2(x):
w = x > 2
sequence.append(2)
return w
enumerable = Enumerable(generate)
values = enumerable.where(greater_than_2).where(less_than_5).to_list()
self.assertSequenceEqual(values, [3, 4])
self.assertSequenceEqual(sequence,
[2, 2, 2, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5])
def test_when_run_to_list_several_times_then_enumerate_only_once(self):
sequence = []
def less_than_5(x):
w = x < 5
sequence.append(5)
return w
enumerable = Enumerable(generate).where(less_than_5)
enumerable.to_list()
counter = len(sequence)
enumerable.to_list()
self.assertEqual(counter, len(sequence))
def test_when_create_enumerable_with_string_then_raise_type_error(self):
with self.assertRaises(TypeError):
Enumerable("test")
def test_when_create_enumerable_with_dictionary_then_raise_type_error(
self):
with self.assertRaises(TypeError):
Enumerable({"1": 1, "2": 2, "3": 3})
def test_when_create_enumerable_with_generator_then_raise_type_error(self):
with self.assertRaises(TypeError):
Enumerable(generate())
def test_when_create_enumerable_with_generator_function_then_create_valid_enumerable(
self):
self.assertIsNotNone(Enumerable(generate))
def test_when_create_enumerable_with_tuple_then_create_valid_enumerable(
self):
self.assertIsNotNone(Enumerable((1, 2, 3)))
self.assertIsNotNone(Enumerable(("a", "b", "c")))
def test_when_create_enumerable_with_list_then_create_valid_enumerable(
self):
self.assertIsNotNone(Enumerable([1, 2, 3]))
self.assertIsNotNone(Enumerable(["a", "b", "c"]))
def test_when_run_any_and_none_is_true_then_return_false(self):
dummies = [Dummy(1, 2), Dummy(2, 4), Dummy(3, 6), Dummy(4, 8)]
all_true = Enumerable(dummies).any(lambda x: x.B > 8)
self.assertFalse(all_true)
def test_when_run_any_and_at_least_one_is_true_then_return_true(self):
dummies = [Dummy(1, 2), Dummy(2, 4), Dummy(3, 6), Dummy(4, 8)]
all_true = Enumerable(dummies).any(lambda x: x.B > 7)
self.assertTrue(all_true)
def test_when_run_all_and_all_are_true_then_return_true(self):
dummies = [Dummy(1, 2), Dummy(2, 4), Dummy(3, 6), Dummy(4, 8)]
all_true = Enumerable(dummies).all(lambda x: x.B > 1)
self.assertTrue(all_true)
def test_when_run_for_each_then_execute_method_on_each_element(self):
dummies = [Dummy(1, 2), Dummy(2, 4), Dummy(3, 6), Dummy(4, 8)]
values = []
Enumerable(dummies).for_each(lambda x: values.append(x.B))
self.assertSequenceEqual(values, [2, 4, 6, 8])
