Improve readability of test cases further.

test/stream_fluent_test.cxx

@@ -12,67 +12,64 @@
 #include "stream/streams.hpp"
 #include "stream/streams/fluent.hpp"
 
+using ::testing::ElementsAreArray;
 using ::testing::Eq;
 
-using int_t = int const &;
-
 TEST(FluentStreamTest, CollectToObjectPreservesElements) {
-  std::vector<int> v{1, 2, 3, 4, 5};
-  auto s = stream::make_stream(v);
-  std::set<int> o{};
-  s > o;
-  for (int i : v ) {
-    EXPECT_THAT(o.count(i), Eq(1));
-  }
+  std::vector<int> input{1, 2, 3, 4, 5};
+  auto s = stream::make_stream(input);
+  std::set<int> out{};
+  
+  EXPECT_THAT(s > out, ElementsAreArray(input));
 }
 
 TEST(FluentStreamTest, MapToSelfIsSelfs) {
-  std::vector<int> v{1, 2, 3, 4, 5};
-  auto identity = [](int_t i) { return i; };
-  auto s = stream::make_stream(v) | identity;
-  std::vector<int> o{s.begin(), s.end()};
-  EXPECT_THAT(o, Eq(v));
+  std::vector<int> input{1, 2, 3, 4, 5};
+  auto identity = [](int i) { return i; };
+  auto s = stream::make_stream(input) | identity;
+
+  EXPECT_THAT(s.collect(), Eq(input));
 }
 
 TEST(FluentStreamTest, MapCanAlterValues) {
-  std::vector<int> v{1, 2, 3, 4, 5};
+  std::vector<int> input{1, 2, 3, 4, 5};
   std::vector<int> expected{3, 5, 7, 9, 11};
-  auto fmap = [](int_t i) { return 2*i+1; };
-  auto s = stream::make_stream(v) | fmap;
-  std::vector<int> o{s.begin(), s.end()};
-  EXPECT_THAT(o, Eq(expected));
+  auto fmap = [](int i) { return 2*i+1; };
+  auto s = stream::make_stream(input) | fmap;
+
+  EXPECT_THAT(s.collect(), Eq(expected));
 }
 
 TEST(FluentStreamTest, NoOpFilterReturnOriginal) {
-  std::vector<int> v{1, 2, 3, 4, 5};
-  auto pass = [](int_t) { return true; };
-  auto s = stream::make_stream(v) | pass;
-  std::vector<int> o{s.begin(), s.end()};
-  EXPECT_THAT(o, Eq(v));
+  std::vector<int> input{1, 2, 3, 4, 5};
+  auto pass = [](int) { return true; };
+  auto s = stream::make_stream(input) | pass;
+
+  EXPECT_THAT(s.collect(), Eq(input));
 }
 
 TEST(FluentStreamTest, CanFilterOutElements) {
-  std::vector<int> v{1, 2, 3, 4, 5};
+  std::vector<int> input{1, 2, 3, 4, 5};
   std::vector<int> expected{2, 4};
-  auto even = [](int_t i) { return i%2 == 0; };
-  auto s = stream::make_stream(v) | even;
-  std::vector<int> o{s.begin(), s.end()};
-  EXPECT_THAT(o, Eq(expected));
+  auto even = [](int i) { return i%2 == 0; };
+  auto s = stream::make_stream(input) | even;
+
+  EXPECT_THAT(s.collect(), Eq(expected));
 }
 
 TEST(FluentStreamTest, AccumulateDefaultsToAdd) {
-  std::vector<int> v{1, 2, 3, 4, 5};
-  auto even = [](int_t i) { return i%2 == 0; };
-  auto sum = [](int_t lhs, int_t rhs) { return lhs + rhs; };
-  auto s = stream::make_stream(v) | even;
+  std::vector<int> input{1, 2, 3, 4, 5};
+  auto even = [](int i) { return i%2 == 0; };
+  auto sum = [](int lhs, int rhs) { return lhs + rhs; };
+  auto s = stream::make_stream(input) | even;
   EXPECT_THAT(s > sum, Eq(6));
 }
 
 TEST(FluentStreamTest, FlatmapJoinsIterableOutputs) {
   std::vector<int> vv{1, 2, 3, 4, 5};
-  auto next3 = [](int_t i) { return std::vector<int>{i, i+1, i+2}; };
+  auto next3 = [](int i) { return std::vector<int>{i, i+1, i+2}; };
   std::vector<int> expected{1, 2, 3, 2, 3, 4, 3, 4, 5, 4, 5, 6, 5, 6, 7};
   auto s = stream::make_stream(vv) || next3;
-  std::vector<int> o{s.begin(), s.end()};
-  EXPECT_THAT(o, Eq(expected));
+
+  EXPECT_THAT(s.collect(), Eq(expected));
 }

test/stream_test.cxx

@@ -12,149 +12,158 @@
 
 #include "stream/streams.hpp"
 
+using ::testing::ElementsAreArray;
 using ::testing::Eq;
 
 // Workaround for OSX and pointer-to-member-functions
 template class std::basic_string<char>;
 
-using int_t = int const &;
-
 TEST(StreamTest, IteratorPreservesElements) {
-  std::vector<int> v{1, 2, 3, 4, 5};
-  auto s = stream::make_stream(v);
-  std::vector<int> o{s.begin(), s.end()};
-  EXPECT_THAT(v, o);
+  std::vector<int> input{1, 2, 3, 4, 5};
+  auto s = stream::make_stream(input);
+  std::vector<int> out{s.begin(), s.end()};
+  
+  EXPECT_THAT(out, Eq(input));
 }
 
 TEST(StreamTest, CollectPreservesElements) {
-  std::vector<int> v{1, 2, 3, 4, 5};
-  auto s = stream::make_stream(v);
-  std::vector<int> o{s.begin(), s.end()};
-  std::vector<int> o2{s.collect()};
-  EXPECT_THAT(v, o);
-  EXPECT_THAT(v, o2);
+  std::vector<int> input{1, 2, 3, 4, 5};
+  auto s = stream::make_stream(input);
+  std::vector<int> out{s.collect()};
+  
+  EXPECT_THAT(out, Eq(input));
 }
 
 TEST(StreamTest, CollectToObjectPreservesElements) {
-  std::vector<int> v{1, 2, 3, 4, 5};
-  auto s = stream::make_stream(v);
-  std::set<int> o{};
-  s.collect(o);
-  for (int i : v) {
-    EXPECT_THAT(o.count(i), Eq(1));
-  }
+  std::vector<int> input{1, 2, 3, 4, 5};
+  auto s = stream::make_stream(input);
+  std::set<int> out{};
+  s.collect(out);
+  
+  EXPECT_THAT(out, ElementsAreArray(input));
 }
 
 TEST(StreamTest, MapToSelfIsSelfs) {
-  std::vector<int> v{1, 2, 3, 4, 5};
-  auto identity = [](int_t i) { return i; };
-  auto s = stream::make_stream(v).map( identity );
-  std::vector<int> o{s.begin(), s.end()};
-  EXPECT_THAT(v, o);
+  std::vector<int> input{1, 2, 3, 4, 5};
+  auto identity = [](int i) { return i; };
+  auto s = stream::make_stream(input).map(identity);
+
+  EXPECT_THAT(s.collect(), Eq(input));
 }
 
 TEST(StreamTest, MapCanAlterValues) {
-  std::vector<int> v{1, 2, 3, 4, 5};
+  std::vector<int> input{1, 2, 3, 4, 5};
   std::vector<int> expected{3, 5, 7, 9, 11};
-  auto fmap = [](int_t i) { return 2*i+1; };
-  auto s = stream::make_stream(v).map( fmap );
-  std::vector<int> o{s.begin(), s.end()};
-  EXPECT_THAT(expected, o);
+  auto fmap = [](int i) { return 2*i+1; };
+  auto s = stream::make_stream(input).map( fmap );
+
+  EXPECT_THAT(s.collect(), Eq(expected));
 }
 
 TEST(StreamTest, CanBuildFromSingleElement) {
-  int_t value = 11;
-  auto even = [](int_t i) { return i%2==0; };
-  auto s = stream::make_stream(&value).filter( even );
+  int value = 11;
+  auto even = [](int i) { return i%2==0; };
+  auto s = stream::make_stream(&value).filter(even);
+  
   EXPECT_TRUE(s.empty());
 }
 
 TEST(StreamTest, CanBuildFromIterators) {
-  std::vector<int> v{1, 2, 3, 4, 5};
+  std::vector<int> input{1, 2, 3, 4, 5};
   std::vector<int> expected{5, 7};
-  auto fmap = [](int_t i) { return 2*i+1; };
-  auto s = stream::make_stream(v.begin()+1, v.begin()+3).map(fmap);
-  std::vector<int> o{s.begin(), s.end()};
-  EXPECT_THAT(o, Eq(expected));
+  auto fmap = [](int i) { return 2*i+1; };
+  auto s = stream::make_stream(input.begin()+1, input.begin()+3).map(fmap);
+
+  EXPECT_THAT(s.collect(), Eq(expected));
 }
 
 TEST(StreamTest, NoOpFilterReturnOriginal) {
-  std::vector<int> v{1, 2, 3, 4, 5};
-  auto pass = [](int_t) { return true; };
-  auto s = stream::make_stream(v).filter( pass );
-  std::vector<int> o{s.begin(), s.end()};
-  EXPECT_THAT(o, Eq(v));
+  std::vector<int> input{1, 2, 3, 4, 5};
+  auto pass = [](int) { return true; };
+  auto s = stream::make_stream(input).filter( pass );
+  
+  EXPECT_THAT(s.collect(), Eq(input));
 }
 
 TEST(StreamTest, CanFilterOutElements) {
-  std::vector<int> v{1, 2, 3, 4, 5};
+  std::vector<int> input{1, 2, 3, 4, 5};
   std::vector<int> expected{2, 4};
-  auto even = [](int_t i) { return i%2 == 0; };
-  auto s = stream::make_stream(v).filter(even);
-  std::vector<int> o{s.begin(), s.end()};
-  EXPECT_THAT(o, Eq(expected));
+  auto even = [](int i) { return i%2 == 0; };
+  auto s = stream::make_stream(input).filter(even);
+
+  EXPECT_THAT(s.collect(), Eq(expected));
 }
 
 TEST(StreamTest, AccumulateDefaultsToAdd) {
-  std::vector<int> v{1, 2, 3, 4, 5};
-  auto even = [](int_t i) { return i%2 == 0; };
-  auto s = stream::make_stream(v).filter( even );
+  std::vector<int> input{1, 2, 3, 4, 5};
+  auto even = [](int i) { return i%2 == 0; };
+  auto s = stream::make_stream(input).filter( even );
+
   EXPECT_THAT(s.accumulate(0), Eq(6));
 }
 
 TEST(StreamTest, AccumulateCanTakeCustomAccumulator) {
-  std::vector<int> v{1, 2, 3, 4, 5};
-  auto even = [](int_t i) { return i%2 == 0; };
-  auto prod = [](int_t lhs, int_t rhs) { return lhs * rhs; };
-  auto s = stream::make_stream(v).filter(even);
+  std::vector<int> input{1, 2, 3, 4, 5};
+  auto even = [](int i) { return i%2 == 0; };
+  auto prod = [](int lhs, int rhs) { return lhs * rhs; };
+  auto s = stream::make_stream(input).filter(even);
+ 
   EXPECT_THAT(s.accumulate(prod, 0), Eq(0));
   EXPECT_THAT(s.accumulate(prod, 1), Eq(8));
 }
 
 TEST(StreamTest, FlatmapJoinsIterableOutputs) {
   std::vector<int> vv{1, 2, 3, 4, 5};
-  auto next3 = [](int_t i) { return std::vector<int>{i, i+1, i+2}; };
+  auto next3 = [](int i) { return std::vector<int>{i, i+1, i+2}; };
   std::vector<int> expected{1, 2, 3, 2, 3, 4, 3, 4, 5, 4, 5, 6, 5, 6, 7};
   auto s = stream::make_stream(vv).flatmap(next3);
-  std::vector<int> o{s.begin(), s.end()};
-  EXPECT_THAT(o, Eq(expected));
+ 
+  EXPECT_THAT(s.collect(), Eq(expected));
 }
 
 TEST(StreamTest, CanDereferenceElements) {
   int val = 5;
-  std::vector<int*> v{&val};
-  auto data = stream::make_stream(v).deref().collect();
-  EXPECT_THAT(data.front(), val);
+  std::vector<int*> input{&val};
+  auto data = stream::make_stream(input).deref().collect();
+  
+  EXPECT_THAT(data.front(), Eq(val));
 }
 
 TEST(StreamTest, CanForEachConsume) {
   int hits = 0;
-  std::vector<int> v{1, 2, 3, 4, 5};
-  stream::make_stream(v).each([&hits](int_t){ ++hits; });
-  EXPECT_THAT(hits, 5);
+  std::vector<int> input{1, 2, 3, 4, 5};
+  stream::make_stream(input).each([&hits](int){ ++hits; });
+ 
+  EXPECT_THAT(hits, Eq(5));
 }
 
 TEST(StreamTest, CanFetchMemPtr) {
   struct test { int val; };
-  std::vector<test> v{{1}, {3}, {2}};
+  std::vector<test> input{{1}, {3}, {2}};
   std::vector<int> expected{1, 3, 2};
-  auto out = stream::make_stream(v).map(&test::val).collect();
+  auto out = stream::make_stream(input).map(&test::val).collect();
+ 
   EXPECT_THAT(out, Eq(expected));
 }
 
 TEST(StreamTest, CanMapToMemFn) {
-  std::vector<std::string> v{"hello", "goodbye"};
+  std::vector<std::string> input{"hello", "goodbye"};
   std::vector<std::string::size_type> expected{5, 7};
-  auto out = stream::make_stream(v).map(&std::string::size).collect();
+  auto out = stream::make_stream(input).map(&std::string::size).collect();
+
   EXPECT_THAT(out, Eq(expected));
 }
 
 TEST(StreamTest, CastStreamToParentType) {
   struct base { char cat[4] = "cat"; };
   struct test : base { test(int v) : val(v) {} int val; };
-  std::vector<test> v{{1}, {3}, {2}};
-  auto strm = stream::make_stream(v).cast<base>();
-  auto first = stream::make_stream(v).map([](test const & t) { return (void*)&t; }).collect();
-  auto second = strm.map([](base const & t) { return (void*)&t; }).collect();
+  std::vector<test> input{{1}, {3}, {2}};
+  
+  auto addressof_void = [](auto const & p) { return (void*)&p; };
+  
+  auto strm = stream::make_stream(input).cast<base>();
+  auto first = stream::make_stream(input).map(addressof_void).collect();
+  auto second = strm.map(addressof_void).collect();
+
   EXPECT_THAT(first, second);
 }