def test_whenCollectingToSet_thenReturnASetContainingAllElements(self):
result_set = self.stream.collect(to_collection(set))
self.assertEqual(len(self.COLLECTION), len(result_set))
self.assertIsInstance(result_set, set)
for item in self.COLLECTION:
self.assertTrue(item in result_set)
def test_whenZipping_thenIterateOverTheCollectionsTwoByTwo(self):
expected = [(1, 4), (2, 5), (3, 6)]
result = SequentialStream.zip([1, 2, 3],
[4, 5, 6]).collect(to_collection(list))
self.assertEqual(expected, result)
def test_givenStreamOfLists_whenFlattening_thenReturnStreamOfConcatenatedLists(
self):
result = SequentialStream(
self.BUMPY_COLLECTION).flat_map(SequentialStream).collect(
to_collection(list))
self.assertEqual(self.COLLECTION, result)
def test_whenCollectingToTuple_thenReturnATupleContainingTheCollection(
self):
result = SequentialStream([1, 2, 3, 4,
5]).collect(to_collection(tuple))
self.assertIsInstance(result, tuple)
self.assertEqual((1, 2, 3, 4, 5), result)
def test_givenMethodWhichRequiresAParameter_whenMapping_thenInvokeMethodWithParameter(
self):
calculator_object = AClassWithAMethod(0)
result = SequentialStream.of(1, 2, 3, 4).map(
calculator_object.increment).collect(to_collection(list))
self.assertEqual([1, 2, 3, 4], result)
def test_whenMapping_thenReturnFunctionAppliedToAllElements(self):
expected = [
x for x in map(SequentialStreamTest.DIVIDES_BY_THREE,
self.COLLECTION)
]
result = self.stream.map(
SequentialStreamTest.DIVIDES_BY_THREE).collect(to_collection(list))
self.assertEqual(expected, result)
def test_whenFiltering_thenReturnElementsWhichEvaluateToTrue(self):
expected = [
x for x in filter(SequentialStreamTest.DIVIDES_BY_THREE,
self.COLLECTION)
]
result = self.stream.filter(
SequentialStreamTest.DIVIDES_BY_THREE).collect(to_collection(list))
self.assertEqual(expected, result)
def test_givenAListOfPairs_whenCollectingToDict_thenExpandPairsToKeyValue(
self):
dictionary = self.stream.map(
lambda x: (x, SequentialStreamTest.DIVIDES_BY_THREE(x))).collect(
to_collection(dict))
self.assertEqual(len(self.COLLECTION), len(dictionary.keys()))
self.assertIsInstance(dictionary, dict)
for i in self.COLLECTION:
self.assertEqual(dictionary[i],
SequentialStreamTest.DIVIDES_BY_THREE(i))
def test_sequentialStream_intermediateOp_parallel_filter_collect(self):
s = self.stream.map(squared).parallel().filter(
DIVIDES_BY_THREE).collect(to_collection(list))
c = list(filter(DIVIDES_BY_THREE, map(squared, self.COLLECTION)))
self.assertTrue(s == c)
def test_whenCreatingFromNonIterableElements_thenCreateACollectionContainingAllParameters(
self):
result = SequentialStream.of(1, 2, 3, 4).collect(to_collection(list))
self.assertEqual([1, 2, 3, 4], result)
def test_filter_map(self):
self.assertEqual(
self.stream.filter(DIVIDES_BY_THREE).map(squared).collect(to_collection(tuple)),
tuple(map(squared, filter(DIVIDES_BY_THREE, self.COLLECTION)))
)
def test_whenCollectingToList_thenReturnAListContainingAllElements(self):
result_list = self.stream.collect(to_collection(list))
self.assertIsInstance(result_list, list)
self.assertEqual(self.COLLECTION, result_list)
def test_givenMissingParameters_whenGettingRange_thenReturnInfiniteIterator(
self):
first_25 = SequentialStream.range().limit(25).collect(
to_collection(list))
self.assertEqual([x for x in range(0, 25)], first_25)
def test_givenParameters_whenGettingRange_thenPassParametersToBuiltinRange(
self):
first5 = SequentialStream.range(5).collect(to_collection(list))
self.assertEqual([x for x in range(0, 5)], first5)
def test_filter_filter(self):
self.assertEqual(
self.stream.filter(DIVIDES_BY_THREE).filter(DIVIDES_BY_TWO).collect(to_collection(tuple)),
tuple(filter(DIVIDES_BY_TWO, filter(DIVIDES_BY_THREE, self.COLLECTION)))
)
def test_givenBuiltinType_whenMapping_thenCallConstructorWithASingleParameter(
self):
result = SequentialStream.of("1", "2",
"3").map(int).collect(to_collection(list))
self.assertEqual([1, 2, 3], result)
def test_whenTaking_thenReturnStreamWithOnlyFirstElements(self):
first_elements = SequentialStream(range(0, 30)).limit(5).collect(
to_collection(list))
self.assertEqual([0, 1, 2, 3, 4], first_elements)
def test_givenClassReference_whenMapping_thenCallClassConstructor(self):
squares = SequentialStream.of(1, 2, 3, 4).map(AClassWithAMethod).map(
AClassWithAMethod.get_square).collect(to_collection(list))
self.assertEqual([1, 4, 9, 16], squares)
def test_parallelStream_map_sequential_collect(self):
s = self.parallel_stream.map(squared).sequential().collect(
to_collection(list))
c = list(map(squared, self.COLLECTION))
self.assertTrue(s == c)
def test_givenFunctionWithTwoParameters_whenIteratingOverScalars_thenThrowTypeError(
self):
with self.assertRaises(TypeError):
self.stream.map(lambda x, y: x + y).collect(to_collection(list))
def test_peek(self):
s = self.stream.map(squared).peek(print).collect(to_collection(tuple))
self.assertTupleEqual(s, tuple(map(squared, self.COLLECTION)))
def test_objects_type_is_empty(self):
tup = tuple(repeat(_Empty, 10))
self.assertEqual(ParallelStream(tup).collect(to_collection(tuple)), tup)
def test_givenMultipleIterables_whenCreatingStream_thenIterablesAreConcatenated(
self):
result = SequentialStream(self.BUMPY_COLLECTION,
self.COLLECTION).collect(to_collection(list))
self.assertEqual(self.BUMPY_COLLECTION + self.COLLECTION, result)
def _filter(x) -> bool:
return x % 3 == 0
if __name__ == '__main__':
collection = tuple(range(10_000, 10_100))
times = []
print("Parallel:")
for i in range(100):
t_s = time()
ParallelStream(collection) \
.filter(_filter) \
.map(math.factorial) \
.collect(collector=to_collection(tuple))
t_elapsed = time() - t_s
times.append(t_elapsed)
print(f"Time elapsed on {i}'ths experiment:", t_elapsed)
t_parallel = sum(times) / len(times)
times = []
print("Sequential:")
for i in range(100):
t_s = time()
SequentialStream(collection) \
.filter(_filter) \
.map(math.factorial) \
.collect(collector=to_collection(tuple))
t_elapsed = time() - t_s
times.append(t_elapsed)
def test_parallelStream_filter_sequential_collect(self):
s = self.parallel_stream.filter(DIVIDES_BY_THREE).sequential().collect(
to_collection(list))
c = list(filter(DIVIDES_BY_THREE, self.COLLECTION))
self.assertTrue(s == c)
