/*
- * Copyright 2015 Facebook, Inc.
+ * Copyright 2016 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*/
#include <glog/logging.h>
-#include <gtest/gtest.h>
+
#include <iosfwd>
#include <random>
#include <set>
#include <folly/FBVector.h>
#include <folly/MapUtil.h>
#include <folly/Memory.h>
+#include <folly/String.h>
#include <folly/dynamic.h>
-#include <folly/gen/Base.h>
#include <folly/experimental/TestUtil.h>
+#include <folly/gen/Base.h>
+#include <folly/portability/GTest.h>
using namespace folly::gen;
using namespace folly;
std::vector<X> xs(1);
EXPECT_EQ(2, from(xs)
| field(&X::a)
- | first);
+ | sum);
EXPECT_EQ(3, from(xs)
| field(&X::b)
- | first);
+ | sum);
EXPECT_EQ(4, from(xs)
| field(&X::c)
- | first);
+ | sum);
EXPECT_EQ(2, seq(&xs[0], &xs[0])
| field(&X::a)
- | first);
+ | sum);
// type-verification
empty<X&>() | field(&X::a) | assert_type<const int&>();
empty<X*>() | field(&X::a) | assert_type<const int&>();
}
}
+TEST(Gen, FilterSink) {
+ auto actual
+ = seq(1, 2)
+ | map([](int x) { return vector<int>{x}; })
+ | filter([](vector<int> v) { return !v.empty(); })
+ | as<vector>();
+ EXPECT_FALSE(from(actual) | rconcat | isEmpty);
+}
+
TEST(Gen, Contains) {
{
auto gen =
| as<vector>();
EXPECT_EQ(expected, actual);
}
+ {
+ int64_t limit = 5;
+ take(limit - 5);
+ EXPECT_THROW(take(limit - 6), std::invalid_argument);
+ }
}
EXPECT_EQ(expected, actual);
}
+TEST(Gen, DistinctInfinite) {
+ // distinct should be able to handle an infinite sequence, provided that, of
+ // of cource, is it eventually made finite before returning the result.
+ auto expected = seq(0) | take(5) | as<vector>(); // 0 1 2 3 4
+
+ auto actual =
+ seq(0) // 0 1 2 3 4 5 6 7 ...
+ | mapped([](int i) { return i / 2; }) // 0 0 1 1 2 2 3 3 ...
+ | distinct // 0 1 2 3 4 5 6 7 ...
+ | take(5) // 0 1 2 3 4
+ | as<vector>();
+
+ EXPECT_EQ(expected, actual);
+}
+
+TEST(Gen, DistinctByInfinite) {
+ // Similarly to the DistinctInfinite test case, distinct by should be able to
+ // handle infinite sequences. Note that depending on how many values we take()
+ // at the end, the sequence may infinite loop. This is fine becasue we cannot
+ // solve the halting problem.
+ auto expected = vector<int>{1, 2};
+ auto actual =
+ seq(1) // 1 2 3 4 5 6 7 8 ...
+ | distinctBy([](int i) { return i % 2; }) // 1 2 (but might by infinite)
+ | take(2) // 1 2
+ | as<vector>();
+ // Note that if we had take(3), this would infinite loop
+
+ EXPECT_EQ(expected, actual);
+}
+
TEST(Gen, MinBy) {
EXPECT_EQ(7, seq(1, 10)
| minBy([](int i) -> double {
double d = i - 6.8;
return d * d;
- }));
+ })
+ | unwrap);
}
TEST(Gen, MaxBy) {
auto gen = from({"three", "eleven", "four"});
- EXPECT_EQ("eleven", gen | maxBy(&strlen));
+ EXPECT_EQ("eleven", gen | maxBy(&strlen) | unwrap);
}
TEST(Gen, Min) {
TEST(Gen, Reduce) {
int expected = 2 + 3 + 4 + 5;
auto actual = seq(2, 5) | reduce(add);
- EXPECT_EQ(expected, actual);
+ EXPECT_EQ(expected, actual | unwrap);
}
TEST(Gen, ReduceBad) {
auto gen = seq(1) | take(0);
- try {
- EXPECT_TRUE(true);
- gen | reduce(add);
- EXPECT_TRUE(false);
- } catch (...) {
- }
+ auto actual = gen | reduce(add);
+ EXPECT_FALSE(actual); // Empty sequences are okay, they just yeild 'none'
}
TEST(Gen, Moves) {
}
TEST(Gen, First) {
- auto gen =
- seq(0)
- | filter([](int x) { return x > 3; });
- EXPECT_EQ(4, gen | first);
+ auto gen = seq(0) | filter([](int x) { return x > 3; });
+ EXPECT_EQ(4, gen | first | unwrap);
}
TEST(Gen, FromCopy) {
}
TEST(Gen, notEmpty) {
- EXPECT_TRUE(seq(0) | notEmpty);
EXPECT_TRUE(seq(0, 1) | notEmpty);
EXPECT_TRUE(just(1) | notEmpty);
EXPECT_FALSE(gen::range(0, 0) | notEmpty);
EXPECT_FALSE(from({1}) | take(0) | notEmpty);
- EXPECT_TRUE(seq(1, 3) | cycle | notEmpty);
}
TEST(Gen, isEmpty) {
- EXPECT_FALSE(seq(0) | isEmpty);
EXPECT_FALSE(seq(0, 1) | isEmpty);
EXPECT_FALSE(just(1) | isEmpty);
EXPECT_TRUE(gen::range(0, 0) | isEmpty);
EXPECT_TRUE(from({1}) | take(0) | isEmpty);
- EXPECT_FALSE(seq(1, 3) | cycle | isEmpty);
}
TEST(Gen, Any) {
// test dynamics with various layers of nested arrays.
TEST(Gen, Dynamic) {
- dynamic array1 = {1, 2};
+ dynamic array1 = dynamic::array(1, 2);
EXPECT_EQ(dynamic(3), from(array1) | sum);
dynamic array2 = {{1}, {1, 2}};
EXPECT_EQ(dynamic(4), from(array2) | rconcat | sum);
};
auto s = countdown;
EXPECT_EQ((vector<int> { 1, 2, 3, 1, 2, 1}),
- s | cycle | as<vector>());
+ s | cycle | take(7) | as<vector>());
+ // take necessary as cycle returns an infinite generator
}
}
}
}
+namespace {
+struct DereferenceWrapper {
+ string data;
+ string& operator*() & {
+ return data;
+ }
+ string&& operator*() && {
+ return std::move(data);
+ }
+ explicit operator bool() {
+ return true;
+ }
+};
+bool operator==(const DereferenceWrapper& a, const DereferenceWrapper& b) {
+ return a.data == b.data;
+}
+void PrintTo(const DereferenceWrapper& a, std::ostream* o) {
+ *o << "Wrapper{\"" << cEscape<string>(a.data) << "\"}";
+}
+}
+
+TEST(Gen, DereferenceWithLValueRef) {
+ auto original = vector<DereferenceWrapper>{{"foo"}, {"bar"}};
+ auto copy = original;
+ auto expected = vector<string>{"foo", "bar"};
+ auto actual = from(original) | dereference | as<vector>();
+ EXPECT_EQ(expected, actual);
+ EXPECT_EQ(copy, original);
+}
+
+TEST(Gen, DereferenceWithRValueRef) {
+ auto original = vector<DereferenceWrapper>{{"foo"}, {"bar"}};
+ auto empty = vector<DereferenceWrapper>{{}, {}};
+ auto expected = vector<string>{"foo", "bar"};
+ auto actual = from(original) | move | dereference | as<vector>();
+ EXPECT_EQ(expected, actual);
+ EXPECT_EQ(empty, original);
+}
+
TEST(Gen, Indirect) {
vector<int> vs{1};
- EXPECT_EQ(&vs[0], from(vs) | indirect | first);
+ EXPECT_EQ(&vs[0], from(vs) | indirect | first | unwrap);
}
TEST(Gen, Guard) {
{
int x = 3;
auto j = just(x);
- EXPECT_EQ(&x, j | indirect | first);
+ EXPECT_EQ(&x, j | indirect | first | unwrap);
x = 4;
- EXPECT_EQ(4, j | first);
+ EXPECT_EQ(4, j | sum);
}
{
int x = 3;
const int& cx = x;
auto j = just(cx);
- EXPECT_EQ(&x, j | indirect | first);
+ EXPECT_EQ(&x, j | indirect | first | unwrap);
x = 5;
- EXPECT_EQ(5, j | first);
+ EXPECT_EQ(5, j | sum);
}
{
int x = 3;
auto j = just(std::move(x));
- EXPECT_NE(&x, j | indirect | first);
+ EXPECT_NE(&x, j | indirect | first | unwrap);
x = 5;
- EXPECT_EQ(3, j | first);
+ EXPECT_EQ(3, j | sum);
}
}
EXPECT_EQ(3, gb | count);
vector<string> mode{"zero", "four", "five", "nine"};
- EXPECT_EQ(
- mode,
- gb | maxBy([](const Group<size_t, string>& g) { return g.size(); })
- | as<vector>());
+ EXPECT_EQ(mode,
+ gb | maxBy([](const Group<size_t, string>& g) { return g.size(); })
+ | unwrap
+ | as<vector>());
vector<string> largest{"three", "seven", "eight"};
- EXPECT_EQ(
- largest,
- gb | maxBy([](const Group<size_t, string>& g) { return g.key(); })
- | as<vector>());
+ EXPECT_EQ(largest,
+ gb | maxBy([](const Group<size_t, string>& g) { return g.key(); })
+ | unwrap
+ | as<vector>());
+}
+
+TEST(Gen, Unwrap) {
+ Optional<int> o(4);
+ Optional<int> e;
+ EXPECT_EQ(4, o | unwrap);
+ EXPECT_THROW(e | unwrap, OptionalEmptyException);
+
+ auto oup = folly::make_optional(folly::make_unique<int>(5));
+ // optional has a value, and that value is non-null
+ EXPECT_TRUE(bool(oup | unwrap));
+ EXPECT_EQ(5, *(oup | unwrap));
+ EXPECT_TRUE(oup.hasValue()); // still has a pointer (null or not)
+ EXPECT_TRUE(bool(oup.value())); // that value isn't null
+
+ auto moved1 = std::move(oup) | unwrapOr(folly::make_unique<int>(6));
+ // oup still has a value, but now it's now nullptr since the pointer was moved
+ // into moved1
+ EXPECT_TRUE(oup.hasValue());
+ EXPECT_FALSE(oup.value());
+ EXPECT_TRUE(bool(moved1));
+ EXPECT_EQ(5, *moved1);
+
+ auto moved2 = std::move(oup) | unwrapOr(folly::make_unique<int>(7));
+ // oup's still-valid nullptr value wins here, the pointer to 7 doesn't apply
+ EXPECT_FALSE(moved2);
+
+ oup.clear();
+ auto moved3 = std::move(oup) | unwrapOr(folly::make_unique<int>(8));
+ // oup is empty now, so the unwrapOr comes into play.
+ EXPECT_TRUE(bool(moved3));
+ EXPECT_EQ(8, *moved3);
+
+ {
+ // mixed types, with common type matching optional
+ Optional<double> full(3.3);
+ decltype(full) empty;
+ auto fallback = unwrapOr(4);
+ EXPECT_EQ(3.3, full | fallback);
+ EXPECT_EQ(3.3, std::move(full) | fallback);
+ EXPECT_EQ(3.3, full | std::move(fallback));
+ EXPECT_EQ(3.3, std::move(full) | std::move(fallback));
+ EXPECT_EQ(4.0, empty | fallback);
+ EXPECT_EQ(4.0, std::move(empty) | fallback);
+ EXPECT_EQ(4.0, empty | std::move(fallback));
+ EXPECT_EQ(4.0, std::move(empty) | std::move(fallback));
+ }
+
+ {
+ // mixed types, with common type matching fallback
+ Optional<int> full(3);
+ decltype(full) empty;
+ auto fallback = unwrapOr(5.0); // type: double
+ // if we chose 'int' as the common type, we'd see truncation here
+ EXPECT_EQ(1.5, (full | fallback) / 2);
+ EXPECT_EQ(1.5, (std::move(full) | fallback) / 2);
+ EXPECT_EQ(1.5, (full | std::move(fallback)) / 2);
+ EXPECT_EQ(1.5, (std::move(full) | std::move(fallback)) / 2);
+ EXPECT_EQ(2.5, (empty | fallback) / 2);
+ EXPECT_EQ(2.5, (std::move(empty) | fallback) / 2);
+ EXPECT_EQ(2.5, (empty | std::move(fallback)) / 2);
+ EXPECT_EQ(2.5, (std::move(empty) | std::move(fallback)) / 2);
+ }
+
+ {
+ auto opt = folly::make_optional(std::make_shared<int>(8));
+ auto fallback = unwrapOr(folly::make_unique<int>(9));
+ // fallback must be std::move'd to be used
+ EXPECT_EQ(8, *(opt | std::move(fallback)));
+ EXPECT_TRUE(bool(opt.value())); // shared_ptr copied out, not moved
+ EXPECT_TRUE(bool(opt)); // value still present
+ EXPECT_TRUE(bool(fallback.value())); // fallback value not needed
+
+ EXPECT_EQ(8, *(std::move(opt) | std::move(fallback)));
+ EXPECT_FALSE(opt.value()); // shared_ptr moved out
+ EXPECT_TRUE(bool(opt)); // gutted value still present
+ EXPECT_TRUE(bool(fallback.value())); // fallback value not needed
+
+ opt.clear();
+
+ EXPECT_FALSE(opt); // opt is empty now
+ EXPECT_EQ(9, *(std::move(opt) | std::move(fallback)));
+ EXPECT_FALSE(fallback.value()); // fallback moved out!
+ }
+
+ {
+ // test with nullptr
+ vector<int> v{1, 2};
+ EXPECT_EQ(&v[1], from(v) | indirect | max | unwrap);
+ v.clear();
+ EXPECT_FALSE(from(v) | indirect | max | unwrapOr(nullptr));
+ }
+
+ {
+ // mixed type determined by fallback
+ Optional<std::nullptr_t> empty;
+ int x = 3;
+ EXPECT_EQ(&x, empty | unwrapOr(&x));
+ }
}
int main(int argc, char *argv[]) {
projects / folly.git / blobdiff