proxygen
Functions
PolyTest.cpp File Reference
#include <folly/Poly.h>
#include <folly/Conv.h>
#include <folly/poly/Nullable.h>
#include <folly/poly/Regular.h>
#include <folly/portability/GTest.h>
#include <array>

Go to the source code of this file.

Functions

 TEST (Poly, SemiRegular)
 
 TEST (Poly, EqualityComparable)
 
 TEST (Poly, StrictlyOrderable)
 
 TEST (Poly, SemiRegularReference)
 
 TEST (Poly, Conversions)
 
 TEST (Poly, EqualityComparableReference)
 
 TEST (Poly, Singular)
 
 TEST (Poly, SingleInheritance)
 
 TEST (Poly, MultipleInheritance)
 
 TEST (Poly, OverloadedMembers)
 
 TEST (Poly, NullablePointer)
 
 TEST (Poly, Move)
 
 TEST (Poly, RValueRef)
 
 TEST (Poly, Function)
 
 TEST (Poly, DiamondInheritance)
 
 TEST (Poly, Sig)
 
 TEST (Poly, Addable)
 
 TEST (Poly, PolyRefAsArg)
 

Function Documentation

TEST ( Poly  ,
SemiRegular   
)

Definition at line 73 of file PolyTest.cpp.

References EXPECT_EQ, EXPECT_THROW, folly::poly_type(), folly::f14::swap(), folly::swap(), and folly::value().

73  {
74  {
75  // A small object, storable in-situ:
76  Poly<ISemiRegular> p = 42;
77  EXPECT_EQ(typeid(int), poly_type(p));
78  EXPECT_EQ(42, poly_cast<int>(p));
79  EXPECT_THROW(poly_cast<short>(p), BadPolyCast);
80  Poly<ISemiRegular> p2 = p;
81  EXPECT_EQ(typeid(int), poly_type(p2));
82  EXPECT_EQ(42, poly_cast<int>(p2));
83  EXPECT_THROW(poly_cast<short>(p2), BadPolyCast);
84  }
85 
86  EXPECT_EQ(0, Big::s_count);
87  {
88  // A big object, stored on the heap:
89  Poly<ISemiRegular> p = Big(42);
90  EXPECT_EQ(1, Big::s_count);
91  EXPECT_EQ(typeid(Big), poly_type(p));
92  EXPECT_EQ(42, poly_cast<Big>(p).value());
93  EXPECT_THROW(poly_cast<short>(p), BadPolyCast);
94  Poly<ISemiRegular> p2 = p;
95  EXPECT_EQ(2, Big::s_count);
96  EXPECT_EQ(typeid(Big), poly_type(p2));
97  EXPECT_EQ(42, poly_cast<Big>(p2).value());
98  EXPECT_THROW(poly_cast<short>(p2), BadPolyCast);
99  }
100  EXPECT_EQ(0, Big::s_count);
101 
102  // four swap cases
103  //
104 
105  {
106  // A small object, storable in-situ:
107  Poly<ISemiRegular> p = 42;
108  EXPECT_EQ(typeid(int), poly_type(p));
109  EXPECT_EQ(42, poly_cast<int>(p));
110  EXPECT_THROW(poly_cast<short>(p), BadPolyCast);
111  // A small object, storable in-situ:
112  Poly<ISemiRegular> p2 = 4.2;
113  EXPECT_EQ(typeid(double), poly_type(p2));
114  EXPECT_EQ(4.2, poly_cast<double>(p2));
115  EXPECT_THROW(poly_cast<short>(p2), BadPolyCast);
116  std::swap(p, p2);
117  EXPECT_EQ(typeid(double), poly_type(p));
118  EXPECT_EQ(4.2, poly_cast<double>(p));
119  EXPECT_THROW(poly_cast<short>(p), BadPolyCast);
120  EXPECT_EQ(typeid(int), poly_type(p2));
121  EXPECT_EQ(42, poly_cast<int>(p2));
122  EXPECT_THROW(poly_cast<short>(p2), BadPolyCast);
123  using std::swap;
124  swap(p, p2);
125  EXPECT_EQ(typeid(int), poly_type(p));
126  EXPECT_EQ(42, poly_cast<int>(p));
127  EXPECT_THROW(poly_cast<short>(p), BadPolyCast);
128  EXPECT_EQ(typeid(double), poly_type(p2));
129  EXPECT_EQ(4.2, poly_cast<double>(p2));
130  EXPECT_THROW(poly_cast<short>(p2), BadPolyCast);
131  }
132 
133  EXPECT_EQ(0, Big::s_count);
134  EXPECT_EQ(0, BigDouble::s_count);
135  {
136  // A big object, stored on the heap:
137  Poly<ISemiRegular> p = Big(42);
138  EXPECT_EQ(1, Big::s_count);
139  EXPECT_EQ(typeid(Big), poly_type(p));
140  EXPECT_EQ(42, poly_cast<Big>(p).value());
141  EXPECT_THROW(poly_cast<short>(p), BadPolyCast);
142  // A big object, stored on the heap:
143  Poly<ISemiRegular> p2 = BigDouble(4.2);
144  EXPECT_EQ(1, BigDouble::s_count);
145  EXPECT_EQ(typeid(BigDouble), poly_type(p2));
146  EXPECT_EQ(4.2, poly_cast<BigDouble>(p2).value());
147  EXPECT_THROW(poly_cast<short>(p2), BadPolyCast);
148  std::swap(p, p2);
149  EXPECT_EQ(1, Big::s_count);
150  EXPECT_EQ(1, BigDouble::s_count);
151  EXPECT_EQ(typeid(BigDouble), poly_type(p));
152  EXPECT_EQ(4.2, poly_cast<BigDouble>(p).value());
153  EXPECT_THROW(poly_cast<short>(p), BadPolyCast);
154  EXPECT_EQ(typeid(Big), poly_type(p2));
155  EXPECT_EQ(42, poly_cast<Big>(p2).value());
156  EXPECT_THROW(poly_cast<short>(p2), BadPolyCast);
157  using std::swap;
158  swap(p, p2);
159  EXPECT_EQ(1, Big::s_count);
160  EXPECT_EQ(1, BigDouble::s_count);
161  EXPECT_EQ(typeid(Big), poly_type(p));
162  EXPECT_EQ(42, poly_cast<Big>(p).value());
163  EXPECT_THROW(poly_cast<short>(p), BadPolyCast);
164  EXPECT_EQ(typeid(BigDouble), poly_type(p2));
165  EXPECT_EQ(4.2, poly_cast<BigDouble>(p2).value());
166  EXPECT_THROW(poly_cast<short>(p2), BadPolyCast);
167  }
168  EXPECT_EQ(0, BigDouble::s_count);
169  EXPECT_EQ(0, Big::s_count);
170 
171  EXPECT_EQ(0, Big::s_count);
172  {
173  // A big object, stored on the heap:
174  Poly<ISemiRegular> p = Big(42);
175  EXPECT_EQ(1, Big::s_count);
176  EXPECT_EQ(typeid(Big), poly_type(p));
177  EXPECT_EQ(42, poly_cast<Big>(p).value());
178  EXPECT_THROW(poly_cast<short>(p), BadPolyCast);
179  // A small object, storable in-situ:
180  Poly<ISemiRegular> p2 = 4.2;
181  EXPECT_EQ(typeid(double), poly_type(p2));
182  EXPECT_EQ(4.2, poly_cast<double>(p2));
183  EXPECT_THROW(poly_cast<short>(p2), BadPolyCast);
184  std::swap(p, p2);
185  EXPECT_EQ(1, Big::s_count);
186  EXPECT_EQ(typeid(double), poly_type(p));
187  EXPECT_EQ(4.2, poly_cast<double>(p));
188  EXPECT_THROW(poly_cast<short>(p), BadPolyCast);
189  EXPECT_EQ(typeid(Big), poly_type(p2));
190  EXPECT_EQ(42, poly_cast<Big>(p2).value());
191  EXPECT_THROW(poly_cast<short>(p2), BadPolyCast);
192  using std::swap;
193  swap(p, p2);
194  EXPECT_EQ(1, Big::s_count);
195  EXPECT_EQ(typeid(Big), poly_type(p));
196  EXPECT_EQ(42, poly_cast<Big>(p).value());
197  EXPECT_THROW(poly_cast<short>(p), BadPolyCast);
198  EXPECT_EQ(typeid(double), poly_type(p2));
199  EXPECT_EQ(4.2, poly_cast<double>(p2));
200  EXPECT_THROW(poly_cast<short>(p2), BadPolyCast);
201  }
202  EXPECT_EQ(0, Big::s_count);
203 
204  EXPECT_EQ(0, BigDouble::s_count);
205  {
206  // A small object, storable in-situ:
207  Poly<ISemiRegular> p = 42;
208  EXPECT_EQ(typeid(int), poly_type(p));
209  EXPECT_EQ(42, poly_cast<int>(p));
210  EXPECT_THROW(poly_cast<short>(p), BadPolyCast);
211  // A big object, stored on the heap:
212  Poly<ISemiRegular> p2 = BigDouble(4.2);
213  EXPECT_EQ(1, BigDouble::s_count);
214  EXPECT_EQ(typeid(BigDouble), poly_type(p2));
215  EXPECT_EQ(4.2, poly_cast<BigDouble>(p2).value());
216  EXPECT_THROW(poly_cast<short>(p2), BadPolyCast);
217  std::swap(p, p2);
218  EXPECT_EQ(1, BigDouble::s_count);
219  EXPECT_EQ(typeid(BigDouble), poly_type(p));
220  EXPECT_EQ(4.2, poly_cast<BigDouble>(p).value());
221  EXPECT_THROW(poly_cast<short>(p), BadPolyCast);
222  EXPECT_EQ(typeid(int), poly_type(p2));
223  EXPECT_EQ(42, poly_cast<int>(p2));
224  EXPECT_THROW(poly_cast<short>(p2), BadPolyCast);
225  using std::swap;
226  swap(p, p2);
227  EXPECT_EQ(1, BigDouble::s_count);
228  EXPECT_EQ(typeid(int), poly_type(p));
229  EXPECT_EQ(42, poly_cast<int>(p));
230  EXPECT_THROW(poly_cast<short>(p), BadPolyCast);
231  EXPECT_EQ(typeid(BigDouble), poly_type(p2));
232  EXPECT_EQ(4.2, poly_cast<BigDouble>(p2).value());
233  EXPECT_THROW(poly_cast<short>(p2), BadPolyCast);
234  }
235  EXPECT_EQ(0, BigDouble::s_count);
236 }
folly::poly_type
std::type_info const & poly_type(detail::PolyRoot< I > const &that) noexcept
Definition: Poly.h:358
EXPECT_THROW
#define EXPECT_THROW(statement, expected_exception)
Definition: gtest.h:1843
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
value
static const char *const value
Definition: Conv.cpp:50
folly::f14::swap
void swap(SwapTrackingAlloc< T > &, SwapTrackingAlloc< T > &)
Definition: F14TestUtil.h:414
TEST ( Poly  ,
EqualityComparable   
)

Definition at line 238 of file PolyTest.cpp.

References EXPECT_FALSE, EXPECT_THROW, and EXPECT_TRUE.

238  {
239  {
240  Poly<IEqualityComparable> p = 42;
241  Poly<IEqualityComparable> q = 42;
242  EXPECT_TRUE(p == q);
243  EXPECT_TRUE(q == p);
244  EXPECT_FALSE(p != q);
245  EXPECT_FALSE(q != p);
246  p = 43;
247  EXPECT_FALSE(p == q);
248  EXPECT_FALSE(q == p);
249  EXPECT_TRUE(p != q);
250  EXPECT_TRUE(q != p);
251  }
252  {
253  // empty not equal
254  Poly<IEqualityComparable> p;
255  Poly<IEqualityComparable> q = 42;
256  EXPECT_FALSE(p == q);
257  EXPECT_FALSE(q == p);
258  }
259  {
260  // empty equal
261  Poly<IEqualityComparable> p;
262  Poly<IEqualityComparable> q;
263  EXPECT_TRUE(p == q);
264  EXPECT_TRUE(q == p);
265  }
266  {
267  // mismatched types throws
268  Poly<IEqualityComparable> p = 4.2;
269  Poly<IEqualityComparable> q = 42;
270  EXPECT_THROW((void)(q == p), BadPolyCast);
271  }
272 }
EXPECT_THROW
#define EXPECT_THROW(statement, expected_exception)
Definition: gtest.h:1843
EXPECT_TRUE
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
EXPECT_FALSE
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
TEST ( Poly  ,
StrictlyOrderable   
)

Definition at line 274 of file PolyTest.cpp.

References EXPECT_FALSE, EXPECT_THROW, and EXPECT_TRUE.

274  {
275  {
276  // A small object, storable in-situ:
277  Poly<IStrictlyOrderable> p = 42;
278  Poly<IStrictlyOrderable> q = 43;
279  EXPECT_TRUE(p < q);
280  EXPECT_TRUE(p <= q);
281  EXPECT_FALSE(p > q);
282  EXPECT_FALSE(p >= q);
283  EXPECT_TRUE(q > p);
284  EXPECT_TRUE(q >= p);
285  EXPECT_FALSE(q < p);
286  EXPECT_FALSE(q <= p);
287  }
288  {
289  // A big object, stored on the heap:
290  Poly<IStrictlyOrderable> p = Big(42);
291  Poly<IStrictlyOrderable> q = Big(43);
292  EXPECT_TRUE(p < q);
293  }
294  {
295  // if equal, no one is bigger
296  Poly<IStrictlyOrderable> p = 42;
297  Poly<IStrictlyOrderable> q = 42;
298  EXPECT_FALSE(p < q);
299  EXPECT_TRUE(p <= q);
300  EXPECT_FALSE(p > q);
301  EXPECT_TRUE(p >= q);
302  EXPECT_FALSE(q < p);
303  EXPECT_TRUE(q <= p);
304  EXPECT_FALSE(q > p);
305  EXPECT_TRUE(q >= p);
306  }
307  {
308  // empty is always smaller
309  Poly<IStrictlyOrderable> p;
310  Poly<IStrictlyOrderable> q = 42;
311  EXPECT_TRUE(p < q);
312  EXPECT_FALSE(q < p);
313  }
314  {
315  // mismatched types throws
316  Poly<IStrictlyOrderable> p = 4.2;
317  Poly<IStrictlyOrderable> q = 42;
318  EXPECT_THROW((void)(p < q), BadPolyCast);
319  EXPECT_THROW((void)(q < p), BadPolyCast);
320  }
321 }
EXPECT_THROW
#define EXPECT_THROW(statement, expected_exception)
Definition: gtest.h:1843
EXPECT_TRUE
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
EXPECT_FALSE
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
TEST ( Poly  ,
SemiRegularReference   
)

Definition at line 323 of file PolyTest.cpp.

References EXPECT_EQ, EXPECT_THROW, i, folly::poly_type(), folly::f14::swap(), folly::swap(), and folly::value().

323  {
324  int i = 42;
325  Poly<ISemiRegular&> p = i;
326  EXPECT_EQ(42, i);
327  EXPECT_EQ(typeid(int), poly_type(p));
328  EXPECT_EQ(42, poly_cast<int>(p));
329  EXPECT_EQ(&i, &poly_cast<int>(p));
330  EXPECT_THROW(poly_cast<short>(p), BadPolyCast);
331  Poly<ISemiRegular&> p2 = p;
332  EXPECT_EQ(typeid(int), poly_type(p2));
333  EXPECT_EQ(42, poly_cast<int>(p2));
334  EXPECT_EQ(&i, &poly_cast<int>(p2));
335  EXPECT_THROW(poly_cast<short>(p2), BadPolyCast);
336  std::swap(p, p2);
337  EXPECT_EQ(typeid(int), poly_type(p2));
338  EXPECT_EQ(42, poly_cast<int>(p2));
339  EXPECT_EQ(&i, &poly_cast<int>(p2));
340  EXPECT_THROW(poly_cast<short>(p2), BadPolyCast);
341  using std::swap;
342  swap(p, p2);
343  EXPECT_EQ(typeid(int), poly_type(p2));
344  EXPECT_EQ(42, poly_cast<int>(p2));
345  EXPECT_EQ(&i, &poly_cast<int>(p2));
346  EXPECT_THROW(poly_cast<short>(p2), BadPolyCast);
347  // Can't default-initialize reference-like Poly's:
348  static_assert(!std::is_default_constructible<Poly<ISemiRegular&>>::value, "");
349 }
i
i
Definition: gtest_output_test_golden_lin.txt:83
folly::poly_type
std::type_info const & poly_type(detail::PolyRoot< I > const &that) noexcept
Definition: Poly.h:358
EXPECT_THROW
#define EXPECT_THROW(statement, expected_exception)
Definition: gtest.h:1843
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
value
static const char *const value
Definition: Conv.cpp:50
folly::f14::swap
void swap(SwapTrackingAlloc< T > &, SwapTrackingAlloc< T > &)
Definition: F14TestUtil.h:414
TEST ( Poly  ,
Conversions   
)

Definition at line 351 of file PolyTest.cpp.

References EXPECT_EQ, i, and folly::value().

351  {
352  int i = 42;
353  Poly<ISemiRegular> p1 = i;
354  Poly<ISemiRegular&> p2 = p1;
355  EXPECT_EQ(&poly_cast<int>(p1), &poly_cast<int>(p2));
356  Poly<ISemiRegular const&> p3 = p1;
357  Poly<ISemiRegular const&> p4 = p2;
358  EXPECT_EQ(&poly_cast<int>(p3), &poly_cast<int>(p1));
359  EXPECT_EQ(&poly_cast<int>(p4), &poly_cast<int>(p1));
360  static_assert(
361  !std::is_constructible<Poly<ISemiRegular&>, Poly<ISemiRegular const&>&>::
362  value,
363  "");
364  static_assert(
365  !std::is_constructible<Poly<ISemiRegular>, Poly<ISemiRegular const&>&>::
366  value,
367  "");
368 }
i
i
Definition: gtest_output_test_golden_lin.txt:83
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
value
static const char *const value
Definition: Conv.cpp:50
TEST ( Poly  ,
EqualityComparableReference   
)

Definition at line 370 of file PolyTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, FOLLY_POLY_MEMBERS, folly::foo, testing::gmock_matchers_test::foo, and i.

370  {
371  int i = 42;
372  int j = 42;
373  Poly<IEqualityComparable&> p1 = i;
374  Poly<IEqualityComparable&> p2 = j;
375  EXPECT_EQ(&i, &poly_cast<int>(p1));
376  EXPECT_EQ(&j, &poly_cast<int>(p2));
377  EXPECT_TRUE(p1 == p2);
378  EXPECT_FALSE(p1 != p2);
379  j = 43;
380  EXPECT_FALSE(p1 == p2);
381  EXPECT_TRUE(p1 != p2);
382  EXPECT_EQ(42, poly_cast<int>(p1));
383  EXPECT_EQ(43, poly_cast<int>(p2));
384 }
i
i
Definition: gtest_output_test_golden_lin.txt:83
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
EXPECT_TRUE
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
EXPECT_FALSE
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
TEST ( Poly  ,
Singular   
)

Definition at line 411 of file PolyTest.cpp.

References bar, EXPECT_EQ, FOLLY_POLY_MEMBERS, folly::foo, i, folly::poly_type(), and string.

411  {
412  Poly<Foo> p = foo_{42};
413  int i = 1;
414  p.foo(i);
415  EXPECT_EQ(43, i);
416  EXPECT_EQ(typeid(foo_), poly_type(p));
417 }
i
i
Definition: gtest_output_test_golden_lin.txt:83
folly::poly_type
std::type_info const & poly_type(detail::PolyRoot< I > const &that) noexcept
Definition: Poly.h:358
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
TEST ( Poly  ,
SingleInheritance   
)

Definition at line 448 of file PolyTest.cpp.

References bar, baz(), upload::const, EXPECT_EQ, fizz, FOLLY_POLY_MEMBERS, folly::foo, i, folly::poly_type(), and string.

448  {
449  Poly<FooBar> p = foo_bar{42};
450  int i = 1;
451  p.foo(i);
452  EXPECT_EQ(43, i);
453  EXPECT_EQ("43", p.bar(1));
454  EXPECT_EQ(typeid(foo_bar), poly_type(p));
455 
456  Poly<Foo> q = p; // OK, conversion works.
457  q.foo(i);
458  EXPECT_EQ(85, i);
459 
460  Poly<Foo&> r = p;
461  r->foo(i);
462  EXPECT_EQ(127, i);
463  const_cast<Poly<Foo&> const&>(r)->foo(i);
464  EXPECT_EQ(169, i);
465 
466  Poly<FooBar const&> cr = p;
467  // cr->foo(i); // ERROR: calls a non-const member through a const reference
468  cr->bar(i); // OK
469 }
i
i
Definition: gtest_output_test_golden_lin.txt:83
folly::poly_type
std::type_info const & poly_type(detail::PolyRoot< I > const &that) noexcept
Definition: Poly.h:358
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
testing::gmock_matchers_test::foo
const int foo
Definition: gmock-matchers_test.cc:2452
upload.const
const
Definition: upload.py:398
TEST ( Poly  ,
MultipleInheritance   
)

Definition at line 517 of file PolyTest.cpp.

References EXPECT_EQ, FOLLY_POLY_MEMBER, FOLLY_POLY_MEMBERS, i, folly::poly_type(), and testing::Property().

517  {
518  Poly<FooBarBazFizz> p = foo_bar_baz_fizz{42};
519  int i = 1;
520  p.foo(i);
521  EXPECT_EQ(43, i);
522  EXPECT_EQ("43", p.bar(1));
523  EXPECT_EQ("3", p.baz(1, 2));
524  EXPECT_EQ("fizz", p.fizz());
525  EXPECT_EQ(typeid(foo_bar_baz_fizz), poly_type(p));
526 }
i
i
Definition: gtest_output_test_golden_lin.txt:83
folly::poly_type
std::type_info const & poly_type(detail::PolyRoot< I > const &that) noexcept
Definition: Poly.h:358
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
TEST ( Poly  ,
OverloadedMembers   
)

Definition at line 561 of file PolyTest.cpp.

References EXPECT_EQ, and folly::poly_type().

561  {
562  Poly<Property> p = has_property{42};
563  EXPECT_EQ(typeid(has_property), poly_type(p));
564  EXPECT_EQ(42, p.prop());
565  p.prop(68);
566  EXPECT_EQ(68, p.prop());
567 }
folly::poly_type
std::type_info const & poly_type(detail::PolyRoot< I > const &that) noexcept
Definition: Poly.h:358
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
TEST ( Poly  ,
NullablePointer   
)

Definition at line 569 of file PolyTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_THROW, EXPECT_TRUE, folly::poly_empty(), folly::poly_type(), and s.

569  {
570  Poly<INullablePointer> p = nullptr;
571  Poly<INullablePointer> q{};
572  EXPECT_EQ(typeid(void), poly_type(p));
573  EXPECT_TRUE(poly_empty(p));
574  EXPECT_TRUE(p == q);
575  EXPECT_FALSE(p != q);
576  EXPECT_TRUE(p == nullptr);
577  EXPECT_TRUE(nullptr == p);
578  EXPECT_FALSE(p != nullptr);
579  EXPECT_FALSE(nullptr != p);
580 
581  // No null references ever.
582  Poly<INullablePointer> r = 42;
583  Poly<INullablePointer&> s = r;
584  static_assert(!poly_empty(s), "");
585  EXPECT_THROW(Poly<INullablePointer&> r_(q), BadPolyAccess);
586 }
folly::poly_type
std::type_info const & poly_type(detail::PolyRoot< I > const &that) noexcept
Definition: Poly.h:358
EXPECT_THROW
#define EXPECT_THROW(statement, expected_exception)
Definition: gtest.h:1843
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
folly::poly_empty
bool poly_empty(detail::PolyRoot< I > const &that) noexcept
Definition: Poly.h:383
EXPECT_TRUE
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
s
static set< string > s
Definition: StringKeyedBenchmark.cpp:48
EXPECT_FALSE
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
TEST ( Poly  ,
Move   
)

Definition at line 598 of file PolyTest.cpp.

References EXPECT_EQ, i, folly::poly_move(), and folly::value().

598  {
599  {
600  int i = 42;
601  Poly<IMoveOnly&> p = i;
602  static_assert(
603  !std::is_convertible<Poly<IMoveOnly&>, Poly<IMoveOnly&&>>::value, "");
604  auto q = poly_move(p);
605  static_assert(std::is_same<decltype(q), Poly<IMoveOnly&&>>::value, "");
606  EXPECT_EQ(&poly_cast<int>(p), &poly_cast<int>(q));
607  }
608  {
609  int i = 42;
610  Poly<ISemiRegular const&> p = i;
611  auto q = poly_move(p);
612  static_assert(
613  std::is_same<decltype(q), Poly<ISemiRegular const&>>::value, "");
614  EXPECT_EQ(&poly_cast<int>(p), &poly_cast<int>(q));
615  }
616  {
617  Poly<IMoveOnly> p = MoveOnly_{};
618  static_assert(!std::is_copy_constructible<Poly<IMoveOnly>>::value, "");
619  auto q = poly_move(p);
620  static_assert(std::is_same<decltype(q), Poly<IMoveOnly>>::value, "");
621  }
622 }
i
i
Definition: gtest_output_test_golden_lin.txt:83
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
value
static const char *const value
Definition: Conv.cpp:50
folly::poly_move
constexpr Poly< I > && poly_move(detail::PolyRoot< I > &that) noexcept
Definition: Poly.h:426
TEST ( Poly  ,
RValueRef   
)

Definition at line 624 of file PolyTest.cpp.

References folly::gen::as(), EXPECT_EQ, FOLLY_POLY_MEMBER, FOLLY_POLY_MEMBERS, i, folly::gen::move, and folly::value().

624  {
625  int i = 42;
626  Poly<ISemiRegular&&> p = std::move(i);
627  static_assert(std::is_same<decltype(poly_cast<int>(p)), int&>::value, "");
628  EXPECT_EQ(&i, &poly_cast<int>(p));
629 }
i
i
Definition: gtest_output_test_golden_lin.txt:83
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
folly::gen::move
constexpr detail::Map< Move > move
Definition: Base-inl.h:2567
value
static const char *const value
Definition: Conv.cpp:50
TEST ( Poly  ,
Function   
)

Definition at line 654 of file PolyTest.cpp.

References EXPECT_EQ, and fun().

654  {
655  Function<int(int, int)> fun = std::plus<int>{};
656  EXPECT_EQ(42, fun(22, 20));
657  fun = std::multiplies<int>{};
658  EXPECT_EQ(22 * 20, fun(22, 20));
659 }
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
fun
void fun()
Definition: BenchmarkTest.cpp:28
TEST ( Poly  ,
DiamondInheritance   
)

Definition at line 666 of file PolyTest.cpp.

References folly::eq, EXPECT_EQ, EXPECT_THROW, folly::poly_type(), and folly::value().

666  {
667  {
668  // A small object, storable in-situ:
669  Poly<IDiamond> p = 42;
670  EXPECT_EQ(typeid(int), poly_type(p));
671  EXPECT_EQ(42, poly_cast<int>(p));
672  EXPECT_THROW(poly_cast<short>(p), BadPolyCast);
673  Poly<IDiamond> p2 = p;
674  EXPECT_EQ(typeid(int), poly_type(p2));
675  EXPECT_EQ(42, poly_cast<int>(p2));
676  EXPECT_THROW(poly_cast<short>(p2), BadPolyCast);
677  Poly<IEqualityComparable&> eq = p;
678  EXPECT_EQ(&poly_cast<int>(p), &poly_cast<int>(eq));
679  }
680 
681  EXPECT_EQ(0, Big::s_count);
682  {
683  // A big object, stored on the heap:
684  Poly<IDiamond> p = Big(42);
685  EXPECT_EQ(1, Big::s_count);
686  EXPECT_EQ(typeid(Big), poly_type(p));
687  EXPECT_EQ(42, poly_cast<Big>(p).value());
688  EXPECT_THROW(poly_cast<short>(p), BadPolyCast);
689  Poly<IDiamond> p2 = p;
690  EXPECT_EQ(2, Big::s_count);
691  EXPECT_EQ(typeid(Big), poly_type(p2));
692  EXPECT_EQ(42, poly_cast<Big>(p2).value());
693  EXPECT_THROW(poly_cast<short>(p2), BadPolyCast);
694  Poly<IEqualityComparable&> eq = p;
695  EXPECT_EQ(&poly_cast<Big>(p), &poly_cast<Big>(eq));
696  }
697  EXPECT_EQ(0, Big::s_count);
698 }
folly::poly_type
std::type_info const & poly_type(detail::PolyRoot< I > const &that) noexcept
Definition: Poly.h:358
EXPECT_THROW
#define EXPECT_THROW(statement, expected_exception)
Definition: gtest.h:1843
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
value
static const char *const value
Definition: Conv.cpp:50
TEST ( Poly  ,
Sig   
)

Definition at line 737 of file PolyTest.cpp.

References a, b, upload::const, EXPECT_EQ, FOLLY_POLY_MEMBERS, folly::operator+(), and folly::T.

737  {
738  {
739  auto m0 = folly::sig<int() const>(&Struct::property);
740  EXPECT_EQ(static_cast<int (Struct::*)() const>(&Struct::property), m0);
741  auto m1 = folly::sig<int()>(&Struct::property);
742  EXPECT_EQ(static_cast<int (Struct::*)() const>(&Struct::property), m1);
743 
744  auto m2 = folly::sig<int() const>(&Struct2::property);
745  EXPECT_EQ(static_cast<int (Struct2::*)() const>(&Struct2::property), m2);
746  auto m3 = folly::sig<int()>(&Struct2::property);
747  EXPECT_EQ(static_cast<int (Struct2::*)() const>(&Struct2::property), m3);
748 
749  auto m4 = folly::sig<long()>(&Struct2::meow);
750  EXPECT_EQ(&Struct2::meow, m4);
751 
752  auto m5 = folly::sig<int()>(&Struct2::purr);
753  EXPECT_EQ(static_cast<int (Struct2::*)()>(&Struct2::purr), m5);
754  auto m6 = folly::sig<int() const>(&Struct2::purr);
755  EXPECT_EQ(static_cast<int (Struct2::*)() const>(&Struct2::purr), m6);
756  }
757  {
758  auto m0 = folly::sig<int(Struct const&)>(&::property);
759  EXPECT_EQ(static_cast<int (*)(Struct const&)>(&::property), m0);
760  auto m1 = folly::sig<int(Struct&)>(&::property);
761  EXPECT_EQ(static_cast<int (*)(Struct const&)>(&::property), m1);
762 
763  auto m2 = folly::sig<long(Struct2&)>(&::meow);
764  EXPECT_EQ(&::meow, m2);
765 
766  auto m3 = folly::sig<int(Struct2&)>(&::purr);
767  EXPECT_EQ(static_cast<int (*)(Struct2&)>(&::purr), m3);
768  auto m4 = folly::sig<int(Struct2 const&)>(&::purr);
769  EXPECT_EQ(static_cast<int (*)(Struct2 const&)>(&::purr), m4);
770  }
771 }
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
upload.const
const
Definition: upload.py:398
TEST ( Poly  ,
Addable   
)

Definition at line 793 of file PolyTest.cpp.

References a, b, c, cc, EXPECT_EQ, FOLLY_POLY_MEMBERS, folly::poly_type(), folly::value(), and x.

793  {
794  Poly<IAddable> a = 2, b = 3;
795  Poly<IAddable> c = a + b;
796  EXPECT_EQ(typeid(int), poly_type(c));
797  EXPECT_EQ(5, poly_cast<int>(c));
798 
799  Poly<IAddable const&> aref = a, bref = b;
800  auto cc = aref + bref;
801  static_assert(std::is_same<decltype(cc), Poly<IAddable>>::value, "");
802  EXPECT_EQ(typeid(int), poly_type(cc));
803  EXPECT_EQ(5, poly_cast<int>(cc));
804  b = 4;
805  EXPECT_EQ(5, poly_cast<int>(cc));
806  cc = aref + bref;
807  EXPECT_EQ(6, poly_cast<int>(cc));
808 }
folly::poly_type
std::type_info const & poly_type(detail::PolyRoot< I > const &that) noexcept
Definition: Poly.h:358
b
char b
Definition: OptionalTest.cpp:53
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
cc
The non test part of the code is expected to have failures gtest_output_test_ cc
Definition: gtest_output_test_golden_lin.txt:10
a
char a
Definition: OptionalTest.cpp:53
value
static const char *const value
Definition: Conv.cpp:50
c
char c
Definition: OptionalTest.cpp:53
TEST ( Poly  ,
PolyRefAsArg   
)

Definition at line 830 of file PolyTest.cpp.

830  {
831  folly::Poly<folly::poly::IRegular> x = 42;
832  Frobnicator frob = my_frobnicator{};
833  // should not throw:
834  frob.frobnicate(x);
835  // should not throw:
836  frob.frobnicate(folly::Poly<folly::poly::IRegular&>(x));
837 }
x
Definition: InvokeTest.cpp:58