Electroneum
Functions
expect.cpp File Reference
#include <gtest/gtest.h>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/utility/string_ref.hpp>
#include <string>
#include <system_error>
#include <type_traits>
#include "common/expect.h"
Include dependency graph for expect.cpp:

Go to the source code of this file.

Functions

 TEST (Expect, Constructions)
 
 TEST (Expect, Conversions)
 
 TEST (Expect, NoExcept)
 
 TEST (Expect, Trivial)
 
 TEST (Expect, Assignment)
 
 TEST (Expect, AssignmentThrowsOnMove)
 
 TEST (Expect, EqualWithStrings)
 
 TEST (Expect, EqualWithVoid)
 
 TEST (Expect, EqualNoCopies)
 
 TEST (Expect, Macros)
 

Function Documentation

◆ TEST() [1/10]

TEST ( Expect  ,
Assignment   
)

Definition at line 325 of file expect.cpp.

326 {
327  expect<std::string> val1{std::string{}};
328  expect<std::string> val2{"foobar"};
329 
330  ASSERT_TRUE(val1.has_value());
331  ASSERT_TRUE(val2.has_value());
332  EXPECT_TRUE(bool(val1));
333  EXPECT_TRUE(bool(val2));
334  EXPECT_TRUE(!val1.has_error());
335  EXPECT_TRUE(!val2.has_error());
336  EXPECT_EQ(val1.value(), std::string{});
337  EXPECT_TRUE(*val1 == std::string{});
338  EXPECT_TRUE(boost::equals(val1->c_str(), ""));
339  EXPECT_TRUE(val2.value() == "foobar");
340  EXPECT_TRUE(*val2 == "foobar");
341  EXPECT_TRUE(boost::equals(val2->c_str(), "foobar"));
342  EXPECT_EQ(val1.error(), std::error_code{});
343  EXPECT_EQ(val2.error(), std::error_code{});
344  EXPECT_TRUE(!val1.equal(std::error_code{}));
345  EXPECT_TRUE(!val2.equal(std::error_code{}));
346  EXPECT_TRUE(!(val1 == std::error_code{}));
347  EXPECT_TRUE(!(std::error_code{} == val1));
348  EXPECT_TRUE(!(val2 == std::error_code{}));
349  EXPECT_TRUE(!(std::error_code{} == val2));
350  EXPECT_TRUE(val1 != std::error_code{});
351  EXPECT_TRUE(std::error_code{} != val1);
352  EXPECT_TRUE(val2 != std::error_code{});
353  EXPECT_TRUE(std::error_code{} != val2);
354  EXPECT_TRUE(!val1.matches(std::error_condition{}));
355  EXPECT_TRUE(!val2.matches(std::error_condition{}));
356 
357  val1 = std::move(val2);
358 
359  ASSERT_TRUE(val1.has_value());
360  ASSERT_TRUE(val2.has_value());
361  EXPECT_TRUE(bool(val1));
362  EXPECT_TRUE(bool(val2));
363  EXPECT_TRUE(!val1.has_error());
364  EXPECT_TRUE(!val2.has_error());
365  EXPECT_EQ(val1.value(), "foobar");
366  EXPECT_TRUE(*val1 == "foobar");
367  EXPECT_TRUE(boost::equals(val1->c_str(), "foobar"));
368  EXPECT_EQ(val2.value(), std::string{});
369  EXPECT_TRUE(*val2 == std::string{});
370  EXPECT_TRUE(boost::equals(val2->c_str(), ""));
371  EXPECT_EQ(val1.error(), std::error_code{});
372  EXPECT_EQ(val2.error(), std::error_code{});
373  EXPECT_TRUE(!val1.equal(std::error_code{}));
374  EXPECT_TRUE(!val2.equal(std::error_code{}));
375  EXPECT_TRUE(!(val1 == std::error_code{}));
376  EXPECT_TRUE(!(std::error_code{} == val1));
377  EXPECT_TRUE(!(val2 == std::error_code{}));
378  EXPECT_TRUE(!(std::error_code{} == val2));
379  EXPECT_TRUE(val1 != std::error_code{});
380  EXPECT_TRUE(std::error_code{} != val1);
381  EXPECT_TRUE(val2 != std::error_code{});
382  EXPECT_TRUE(std::error_code{} != val2);
383  EXPECT_TRUE(!val1.matches(std::error_condition{}));
384  EXPECT_TRUE(!val2.matches(std::error_condition{}));
385 
386  val2 = val1;
387 
388  ASSERT_TRUE(val1.has_value());
389  ASSERT_TRUE(val2.has_value());
390  EXPECT_TRUE(bool(val1));
391  EXPECT_TRUE(bool(val2));
392  EXPECT_TRUE(!val1.has_error());
393  EXPECT_TRUE(!val2.has_error());
394  EXPECT_EQ(val1.value(), "foobar");
395  EXPECT_TRUE(*val1 == "foobar");
396  EXPECT_TRUE(boost::equals(val1->c_str(), "foobar"));
397  EXPECT_EQ(val2.value(), "foobar");
398  EXPECT_TRUE(*val2 == "foobar");
399  EXPECT_TRUE(boost::equals(val2->c_str(), "foobar"));
400  EXPECT_EQ(val1.error(), std::error_code{});
401  EXPECT_EQ(val2.error(), std::error_code{});
402  EXPECT_TRUE(!val1.equal(std::error_code{}));
403  EXPECT_TRUE(!val2.equal(std::error_code{}));
404  EXPECT_TRUE(!(val1 == std::error_code{}));
405  EXPECT_TRUE(!(std::error_code{} == val1));
406  EXPECT_TRUE(!(val2 == std::error_code{}));
407  EXPECT_TRUE(!(std::error_code{} == val2));
408  EXPECT_TRUE(val1 != std::error_code{});
409  EXPECT_TRUE(std::error_code{} != val1);
410  EXPECT_TRUE(val2 != std::error_code{});
411  EXPECT_TRUE(std::error_code{} != val2);
412  EXPECT_TRUE(!val1.matches(std::error_condition{}));
413  EXPECT_TRUE(!val2.matches(std::error_condition{}));
414 
415  val1 = make_error_code(common_error::kInvalidArgument);
416 
417  ASSERT_TRUE(val1.has_error());
418  ASSERT_TRUE(val2.has_value());
419  EXPECT_TRUE(!val1);
420  EXPECT_TRUE(bool(val2));
421  EXPECT_TRUE(!val1.has_value());
422  EXPECT_TRUE(!val2.has_error());
423  EXPECT_EQ(val1.error(), common_error::kInvalidArgument);
424  EXPECT_TRUE(val1 == common_error::kInvalidArgument);
425  EXPECT_TRUE(common_error::kInvalidArgument == val1);
426  EXPECT_STREQ(val2.value().c_str(), "foobar");
427  EXPECT_TRUE(*val2 == "foobar");
428  EXPECT_TRUE(boost::equals(val2->c_str(), "foobar"));
429  EXPECT_NE(val1.error(), std::error_code{});
430  EXPECT_EQ(val2.error(), std::error_code{});
431  EXPECT_TRUE(val1.equal(common_error::kInvalidArgument));
432  EXPECT_TRUE(!val2.equal(std::error_code{}));
433  EXPECT_TRUE(!(val1 == std::error_code{}));
434  EXPECT_TRUE(!(std::error_code{} == val1));
435  EXPECT_TRUE(!(val2 == std::error_code{}));
436  EXPECT_TRUE(!(std::error_code{} == val2));
437  EXPECT_TRUE(val1 != std::error_code{});
438  EXPECT_TRUE(std::error_code{} != val1);
439  EXPECT_TRUE(val2 != std::error_code{});
440  EXPECT_TRUE(std::error_code{} != val2);
441  EXPECT_TRUE(val1.matches(std::errc::invalid_argument));
442  EXPECT_TRUE(!val1.matches(std::error_condition{}));
443  EXPECT_TRUE(!val2.matches(std::error_condition{}));
444 
445  val2 = val1;
446 
447  ASSERT_TRUE(val1.has_error());
448  ASSERT_TRUE(val2.has_error());
449  EXPECT_TRUE(!val1);
450  EXPECT_TRUE(!val2);
451  EXPECT_TRUE(!val1.has_value());
452  EXPECT_TRUE(!val2.has_value());
453  EXPECT_EQ(val1.error(), common_error::kInvalidArgument);
454  EXPECT_TRUE(val1 == common_error::kInvalidArgument);
455  EXPECT_TRUE(common_error::kInvalidArgument == val1);
456  EXPECT_EQ(val2.error(), common_error::kInvalidArgument);
457  EXPECT_TRUE(val2 == common_error::kInvalidArgument);
458  EXPECT_TRUE(common_error::kInvalidArgument == val2);
459  EXPECT_NE(val1.error(), std::error_code{});
460  EXPECT_NE(val2.error(), std::error_code{});
461  EXPECT_TRUE(val1.equal(common_error::kInvalidArgument));
462  EXPECT_TRUE(val2.equal(common_error::kInvalidArgument));
463  EXPECT_TRUE(!(val1 == std::error_code{}));
464  EXPECT_TRUE(!(std::error_code{} == val1));
465  EXPECT_TRUE(!(val2 == std::error_code{}));
466  EXPECT_TRUE(!(std::error_code{} == val2));
467  EXPECT_TRUE(val1 != std::error_code{});
468  EXPECT_TRUE(std::error_code{} != val1);
469  EXPECT_TRUE(val2 != std::error_code{});
470  EXPECT_TRUE(std::error_code{} != val2);
471  EXPECT_TRUE(val1.matches(std::errc::invalid_argument));
472  EXPECT_TRUE(val2.matches(std::errc::invalid_argument));
473  EXPECT_TRUE(!val1.matches(std::error_condition{}));
474  EXPECT_TRUE(!val2.matches(std::error_condition{}));
475 
476  val1 = std::string{"barfoo"};
477 
478  ASSERT_TRUE(val1.has_value());
479  ASSERT_TRUE(val2.has_error());
480  EXPECT_TRUE(bool(val1));
481  EXPECT_TRUE(!val2);
482  EXPECT_TRUE(!val1.has_error());
483  EXPECT_TRUE(!val2.has_value());
484  EXPECT_STREQ(val1.value().c_str(), "barfoo");
485  EXPECT_TRUE(*val1 == "barfoo");
486  EXPECT_TRUE(boost::equals(val1->c_str(), "barfoo"));
487  EXPECT_EQ(val2.error(), common_error::kInvalidArgument);
488  EXPECT_TRUE(val2 == common_error::kInvalidArgument);
489  EXPECT_TRUE(common_error::kInvalidArgument == val2);
490  EXPECT_EQ(val1.error(), std::error_code{});
491  EXPECT_NE(val2.error(), std::error_code{});
492  EXPECT_TRUE(!val1.equal(std::error_code{}));
493  EXPECT_TRUE(val2.equal(common_error::kInvalidArgument));
494  EXPECT_TRUE(!(val1 == std::error_code{}));
495  EXPECT_TRUE(!(std::error_code{} == val1));
496  EXPECT_TRUE(!(val2 == std::error_code{}));
497  EXPECT_TRUE(!(std::error_code{} == val2));
498  EXPECT_TRUE(val1 != std::error_code{});
499  EXPECT_TRUE(std::error_code{} != val1);
500  EXPECT_TRUE(val2 != std::error_code{});
501  EXPECT_TRUE(std::error_code{} != val2);
502  EXPECT_TRUE(val2.matches(std::errc::invalid_argument));
503  EXPECT_TRUE(!val1.matches(std::error_condition{}));
504  EXPECT_TRUE(!val2.matches(std::error_condition{}));
505 
506  val2 = val1;
507 
508  ASSERT_TRUE(val1.has_value());
509  ASSERT_TRUE(val2.has_value());
510  EXPECT_TRUE(bool(val1));
511  EXPECT_TRUE(bool(val2));
512  EXPECT_TRUE(!val1.has_error());
513  EXPECT_TRUE(!val2.has_error());
514  EXPECT_EQ(val1.value(), "barfoo");
515  EXPECT_TRUE(*val1 == "barfoo");
516  EXPECT_TRUE(boost::equals(val1->c_str(), "barfoo"));
517  EXPECT_EQ(val2.value(), "barfoo");
518  EXPECT_TRUE(*val2 == "barfoo");
519  EXPECT_TRUE(boost::equals(val2->c_str(), "barfoo"));
520  EXPECT_EQ(val1.error(), std::error_code{});
521  EXPECT_EQ(val2.error(), std::error_code{});
522  EXPECT_TRUE(!val1.equal(std::error_code{}));
523  EXPECT_TRUE(!val2.equal(std::error_code{}));
524  EXPECT_TRUE(!(val1 == std::error_code{}));
525  EXPECT_TRUE(!(std::error_code{} == val1));
526  EXPECT_TRUE(!(val2 == std::error_code{}));
527  EXPECT_TRUE(!(std::error_code{} == val2));
528  EXPECT_TRUE(val1 != std::error_code{});
529  EXPECT_TRUE(std::error_code{} != val1);
530  EXPECT_TRUE(val2 != std::error_code{});
531  EXPECT_TRUE(std::error_code{} != val2);
532  EXPECT_TRUE(!val1.matches(std::error_condition{}));
533  EXPECT_TRUE(!val2.matches(std::error_condition{}));
534 }
expect
Definition: expect.h:133
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
EXPECT_NE
#define EXPECT_NE(val1, val2)
Definition: gtest.h:1926
EXPECT_TRUE
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
EXPECT_STREQ
#define EXPECT_STREQ(s1, s2)
Definition: gtest.h:1995
ASSERT_TRUE
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
testing::internal::string
::std::string string
Definition: gtest-port.h:1097
testing::internal::move
const T & move(const T &t)
Definition: gtest-port.h:1317
make_error_code
std::error_code make_error_code(::common_error value) noexcept
Definition: error.h:41
common_error::kInvalidArgument
@ kInvalidArgument
A function argument is invalid.
Here is the call graph for this function:

◆ TEST() [2/10]

TEST ( Expect  ,
AssignmentThrowsOnMove   
)

Definition at line 536 of file expect.cpp.

537 {
538  struct construct_error {};
539  struct assignment_error {};
540 
541  struct throw_on_move {
542  std::string msg;
543 
544  throw_on_move(const char* msg) : msg(msg) {}
545  throw_on_move(throw_on_move&&) {
546  throw construct_error{};
547  }
548  throw_on_move(throw_on_move const&) = default;
549  ~throw_on_move() = default;
550  throw_on_move& operator=(throw_on_move&&) {
551  throw assignment_error{};
552  }
553  throw_on_move& operator=(throw_on_move const&) = default;
554  };
555 
556  expect<throw_on_move> val1{expect<const char*>{"foobar"}};
557  expect<throw_on_move> val2{common_error::kInvalidArgument};
558 
559  ASSERT_TRUE(val1.has_value());
560  ASSERT_TRUE(val2.has_error());
561  EXPECT_TRUE(!val1.has_error());
562  EXPECT_TRUE(!val2.has_value());
563  EXPECT_STREQ(val1->msg.c_str(), "foobar");
564  EXPECT_EQ(val2.error(), common_error::kInvalidArgument);
565 
566  EXPECT_THROW(val2 = std::move(val1), construct_error);
567 
568  ASSERT_TRUE(val1.has_value());
569  ASSERT_TRUE(val2.has_error());
570  EXPECT_TRUE(!val1.has_error());
571  EXPECT_TRUE(!val2.has_value());
572  EXPECT_STREQ(val1->msg.c_str(), "foobar");
573  EXPECT_EQ(val2.error(), common_error::kInvalidArgument);
574 
575  EXPECT_THROW(val1 = expect<const char*>{"barfoo"}, assignment_error);
576 
577  ASSERT_TRUE(val1.has_value());
578  ASSERT_TRUE(val2.has_error());
579  EXPECT_TRUE(!val1.has_error());
580  EXPECT_TRUE(!val2.has_value());
581  EXPECT_STREQ(val1->msg.c_str(), "foobar");
582  EXPECT_EQ(val2.error(), common_error::kInvalidArgument);
583 
584  EXPECT_NO_THROW(val2 = val1);
585 
586  ASSERT_TRUE(val1.has_value());
587  ASSERT_TRUE(val2.has_value());
588  EXPECT_TRUE(!val1.has_error());
589  EXPECT_TRUE(!val2.has_error());
590  EXPECT_STREQ(val1->msg.c_str(), "foobar");
591  EXPECT_STREQ(val2->msg.c_str(), "foobar");
592 }
operator=
connection< TProtocol > & operator=(const connection< TProtocol > &obj)
Definition: abstract_tcp_server_cp.h:196
EXPECT_NO_THROW
#define EXPECT_NO_THROW(statement)
Definition: gtest.h:1845
EXPECT_THROW
#define EXPECT_THROW(statement, expected_exception)
Definition: gtest.h:1843
Here is the call graph for this function:

◆ TEST() [3/10]

TEST ( Expect  ,
Constructions   
)

Definition at line 134 of file expect.cpp.

135 {
136  construction_bench<void>();
137  construction_bench<int>();
138 
139  EXPECT_TRUE(std::is_constructible<expect<void>>());
140 
141  EXPECT_TRUE((std::is_constructible<expect<throw_construct>, expect<int>>()));
142 
143  EXPECT_TRUE(std::is_move_constructible<expect<move_only>>());
144  EXPECT_TRUE(std::is_move_assignable<expect<move_only>>());
145 }

◆ TEST() [4/10]

TEST ( Expect  ,
Conversions   
)

Definition at line 147 of file expect.cpp.

148 {
149  struct implicit { implicit(int) {} };
150  struct explicit_only { explicit explicit_only(int) {} };
151 
152  conversion_bench<void>();
153  conversion_bench<int>();
154 
155  EXPECT_TRUE((std::is_convertible<int, expect<int>>()));
156  EXPECT_TRUE((std::is_convertible<int&&, expect<int>>()));
157  EXPECT_TRUE((std::is_convertible<int&, expect<int>>()));
158  EXPECT_TRUE((std::is_convertible<int const, expect<int>>()));
159  EXPECT_TRUE((std::is_convertible<expect<unsigned>, expect<int>>()));
160  EXPECT_TRUE((std::is_convertible<expect<unsigned>&&, expect<int>>()));
161  EXPECT_TRUE((std::is_convertible<expect<unsigned>&, expect<int>>()));
162  EXPECT_TRUE((std::is_convertible<expect<unsigned> const&, expect<int>>()));
163  EXPECT_TRUE((std::is_convertible<expect<int>, expect<implicit>>()));
164  EXPECT_TRUE((std::is_convertible<expect<int>&&, expect<implicit>>()));
165  EXPECT_TRUE((std::is_convertible<expect<int>&, expect<implicit>>()));
166  EXPECT_TRUE((std::is_convertible<expect<int> const&, expect<implicit>>()));
167  EXPECT_TRUE(!(std::is_convertible<expect<int>, expect<explicit_only>>()));
168  EXPECT_TRUE(!(std::is_convertible<expect<int>&&, expect<explicit_only>>()));
169  EXPECT_TRUE(!(std::is_convertible<expect<int>&, expect<explicit_only>>()));
170  EXPECT_TRUE(!(std::is_convertible<expect<int> const&, expect<explicit_only>>()));
171 
172  EXPECT_TRUE((std::is_constructible<expect<int>, int>()));
173  EXPECT_TRUE((std::is_constructible<expect<int>, int&&>()));
174  EXPECT_TRUE((std::is_constructible<expect<int>, int&>()));
175  EXPECT_TRUE((std::is_constructible<expect<int>, int const&>()));
176  EXPECT_TRUE((std::is_constructible<expect<int>, expect<unsigned>>()));
177  EXPECT_TRUE((std::is_constructible<expect<int>, expect<unsigned>&&>()));
178  EXPECT_TRUE((std::is_constructible<expect<int>, expect<unsigned>&>()));
179  EXPECT_TRUE((std::is_constructible<expect<int>, expect<unsigned> const&>()));
180  EXPECT_TRUE((std::is_constructible<expect<implicit>, expect<int>>()));
181  EXPECT_TRUE((std::is_constructible<expect<implicit>, expect<int>&&>()));
182  EXPECT_TRUE((std::is_constructible<expect<implicit>, expect<int>&>()));
183  EXPECT_TRUE((std::is_constructible<expect<implicit>, expect<int> const&>()));
184  EXPECT_TRUE(!(std::is_constructible<expect<explicit_only>, expect<int>>()));
185  EXPECT_TRUE(!(std::is_constructible<expect<explicit_only>, expect<int>&&>()));
186  EXPECT_TRUE(!(std::is_constructible<expect<explicit_only>, expect<int>&>()));
187  EXPECT_TRUE(!(std::is_constructible<expect<explicit_only>, expect<int> const&>()));
188 
189  EXPECT_EQ(expect<int>{expect<short>{100}}.value(), 100);
190 
191  expect<std::string> val1{std::string{}};
192  expect<const char*> val2{"foo"};
193 
194  EXPECT_EQ(val1.value(), std::string{});
195  EXPECT_EQ(val2.value(), std::string{"foo"});
196 
197  const expect<std::string> val3{val2};
198 
199  EXPECT_EQ(val1.value(), std::string{});
200  EXPECT_EQ(val2.value(), std::string{"foo"});
201  EXPECT_EQ(val3.value(), std::string{"foo"});
202 
203  val1 = val2;
204 
205  EXPECT_EQ(val1.value(), "foo");
206  EXPECT_EQ(val2.value(), std::string{"foo"});
207  EXPECT_EQ(val3.value(), "foo");
208 }
expect::value
T & value() &
Definition: expect.h:279
Here is the call graph for this function:

◆ TEST() [5/10]

TEST ( Expect  ,
EqualNoCopies   
)

Definition at line 762 of file expect.cpp.

763 {
764  struct copy_error {};
765 
766  struct throw_on_copy {
767  throw_on_copy() = default;
768  throw_on_copy(int) noexcept {}
769  throw_on_copy(throw_on_copy const&) {
770  throw copy_error{};
771  }
772  ~throw_on_copy() = default;
773  throw_on_copy& operator=(throw_on_copy const&) {
774  throw copy_error{};
775  }
776 
777  bool operator==(throw_on_copy const&) const noexcept { return true; }
778  };
779 
780  expect<throw_on_copy> val1{expect<int>{0}};
781  expect<throw_on_copy> val2{expect<int>{0}};
782 
783  EXPECT_TRUE(val1.equal(val2));
784  EXPECT_TRUE(val2.equal(val1));
785  EXPECT_TRUE(val1 == val2);
786  EXPECT_TRUE(val2 == val1);
787  EXPECT_TRUE(!(val1 != val2));
788  EXPECT_TRUE(!(val2 != val1));
789 
790  EXPECT_TRUE(val1.equal(throw_on_copy{}));
791  EXPECT_TRUE(val1 == throw_on_copy{});
792  EXPECT_TRUE(throw_on_copy{} == val1);
793  EXPECT_TRUE(!(val1 != throw_on_copy{}));
794  EXPECT_TRUE(!(throw_on_copy{} != val1));
795 
796  throw_on_copy val3;
797 
798  EXPECT_TRUE(val1.equal(val3));
799  EXPECT_TRUE(val1 == val3);
800  EXPECT_TRUE(val3 == val1);
801  EXPECT_TRUE(!(val1 != val3));
802  EXPECT_TRUE(!(val3 != val1));
803 
804  expect<throw_on_copy> val4{common_error::kInvalidArgument};
805 
806  EXPECT_TRUE(!val4.equal(throw_on_copy{}));
807  EXPECT_TRUE(!(val4 == throw_on_copy{}));
808  EXPECT_TRUE(!(throw_on_copy{} == val4));
809  EXPECT_TRUE(val4 != throw_on_copy{});
810  EXPECT_TRUE(throw_on_copy{} != val4);
811  EXPECT_TRUE(!val4.equal(val3));
812  EXPECT_TRUE(!(val4 == val3));
813  EXPECT_TRUE(!(val3 == val4));
814  EXPECT_TRUE(val4 != val3);
815  EXPECT_TRUE(val3 != val4);
816 }
demo::operator==
bool operator==(const some_test_data &a, const some_test_data &b)
Definition: transport_defs.h:147
Here is the call graph for this function:

◆ TEST() [6/10]

TEST ( Expect  ,
EqualWithStrings   
)

Definition at line 594 of file expect.cpp.

595 {
596  expect<std::string> val1{std::string{}};
597  expect<std::string> val2{"barfoo"};
598  expect<boost::string_ref> val3{boost::string_ref{}};
599 
600  EXPECT_TRUE(!val1.equal(val2));
601  EXPECT_TRUE(val1.equal(val3));
602  EXPECT_TRUE(!val2.equal(val1));
603  EXPECT_TRUE(!val2.equal(val3));
604  EXPECT_TRUE(val3.equal(val1));
605  EXPECT_TRUE(!val3.equal(val2));
606  EXPECT_TRUE(!(val1 == val2));
607  EXPECT_TRUE(!(val2 == val1));
608  EXPECT_TRUE(val1 == val3);
609  EXPECT_TRUE(val3 == val1);
610  EXPECT_TRUE(!(val2 == val3));
611  EXPECT_TRUE(!(val3 == val2));
612  EXPECT_TRUE(val1 != val2);
613  EXPECT_TRUE(val2 != val1);
614  EXPECT_TRUE(!(val1 != val3));
615  EXPECT_TRUE(!(val3 != val1));
616  EXPECT_TRUE(val2 != val3);
617  EXPECT_TRUE(val3 != val2);
618 
619  EXPECT_TRUE(val1.equal(""));
620  EXPECT_TRUE(val2.equal("barfoo"));
621  EXPECT_TRUE(val3.equal(""));
622  EXPECT_TRUE(!val1.equal(std::error_code{}));
623  EXPECT_TRUE(!val2.equal(std::error_code{}));
624  EXPECT_TRUE(!val3.equal(std::error_code{}));
625  EXPECT_TRUE(val1 == "");
626  EXPECT_TRUE("" == val1);
627  EXPECT_TRUE(val2 == "barfoo");
628  EXPECT_TRUE("barfoo" == val2);
629  EXPECT_TRUE(val3 == "");
630  EXPECT_TRUE("" == val3);
631  EXPECT_TRUE(!(val1 != ""));
632  EXPECT_TRUE(!("" != val1));
633  EXPECT_TRUE(!(val2 != "barfoo"));
634  EXPECT_TRUE(!("barfoo" != val2));
635  EXPECT_TRUE(!(val3 != ""));
636  EXPECT_TRUE(!("" != val3));
637  EXPECT_TRUE(!(val1 == std::error_code{}));
638  EXPECT_TRUE(!(std::error_code{} == val1));
639  EXPECT_TRUE(!(val2 == std::error_code{}));
640  EXPECT_TRUE(!(std::error_code{} == val2));
641  EXPECT_TRUE(!(val3 == std::error_code{}));
642  EXPECT_TRUE(!(std::error_code{} == val3));
643  EXPECT_TRUE(val1 != std::error_code{});
644  EXPECT_TRUE(std::error_code{} != val1);
645  EXPECT_TRUE(val2 != std::error_code{});
646  EXPECT_TRUE(std::error_code{} != val2);
647  EXPECT_TRUE(val3 != std::error_code{});
648  EXPECT_TRUE(std::error_code{} != val3);
649  EXPECT_TRUE(!val1.matches(std::error_condition{}));
650  EXPECT_TRUE(!val2.matches(std::error_condition{}));
651  EXPECT_TRUE(!val3.matches(std::error_condition{}));
652 
653  val2 = make_error_code(common_error::kInvalidArgument);
654 
655  EXPECT_TRUE(!val1.equal(val2));
656  EXPECT_TRUE(val1.equal(val3));
657  EXPECT_TRUE(!val2.equal(val1));
658  EXPECT_TRUE(!val2.equal(val3));
659  EXPECT_TRUE(val3.equal(val1));
660  EXPECT_TRUE(!val3.equal(val2));
661  EXPECT_TRUE(!(val1 == val2));
662  EXPECT_TRUE(!(val2 == val1));
663  EXPECT_TRUE(val1 == val3);
664  EXPECT_TRUE(val3 == val1);
665  EXPECT_TRUE(!(val2 == val3));
666  EXPECT_TRUE(!(val3 == val2));
667  EXPECT_TRUE(val1 != val2);
668  EXPECT_TRUE(val2 != val1);
669  EXPECT_TRUE(!(val1 != val3));
670  EXPECT_TRUE(!(val3 != val1));
671  EXPECT_TRUE(val2 != val3);
672  EXPECT_TRUE(val3 != val2);
673 
674  EXPECT_TRUE(!val1.equal(common_error::kInvalidArgument));
675  EXPECT_TRUE(val2.equal(common_error::kInvalidArgument));
676  EXPECT_TRUE(!val3.equal(common_error::kInvalidArgument));
677  EXPECT_TRUE(val2 == common_error::kInvalidArgument);
678  EXPECT_TRUE(common_error::kInvalidArgument == val2);
679  EXPECT_TRUE(!(val2 != common_error::kInvalidArgument));
680  EXPECT_TRUE(!(common_error::kInvalidArgument != val2));
681  EXPECT_TRUE(val2.matches(std::errc::invalid_argument));
682  EXPECT_TRUE(!val2.matches(std::error_condition{}));
683 
684  val1 = expect<std::string>{"barfoo"};
685 
686  EXPECT_TRUE(!val1.equal(val2));
687  EXPECT_TRUE(!val1.equal(val3));
688  EXPECT_TRUE(!val2.equal(val1));
689  EXPECT_TRUE(!val2.equal(val3));
690  EXPECT_TRUE(!val3.equal(val1));
691  EXPECT_TRUE(!val3.equal(val2));
692  EXPECT_TRUE(!(val1 == val2));
693  EXPECT_TRUE(!(val2 == val1));
694  EXPECT_TRUE(!(val1 == val3));
695  EXPECT_TRUE(!(val3 == val1));
696  EXPECT_TRUE(!(val2 == val3));
697  EXPECT_TRUE(!(val3 == val2));
698  EXPECT_TRUE(val1 != val2);
699  EXPECT_TRUE(val2 != val1);
700  EXPECT_TRUE(val1 != val3);
701  EXPECT_TRUE(val3 != val1);
702  EXPECT_TRUE(val2 != val3);
703  EXPECT_TRUE(val3 != val2);
704 
705  EXPECT_TRUE(val1.equal("barfoo"));
706  EXPECT_TRUE(val1 == "barfoo");
707  EXPECT_TRUE("barfoo" == val1);
708  EXPECT_TRUE(!(val1 != "barfoo"));
709  EXPECT_TRUE(!("barfoo" != val1));
710  EXPECT_TRUE(!val1.equal(common_error::kInvalidArgument));
711  EXPECT_TRUE(!(val1 == common_error::kInvalidArgument));
712  EXPECT_TRUE(!(common_error::kInvalidArgument == val1));
713  EXPECT_TRUE(!(val1 == std::error_code{}));
714  EXPECT_TRUE(!(std::error_code{} == val1));
715  EXPECT_TRUE(!val1.matches(std::error_condition{}));
716  EXPECT_TRUE(!val1.matches(std::errc::invalid_argument));
717 }
Here is the call graph for this function:

◆ TEST() [7/10]

TEST ( Expect  ,
EqualWithVoid   
)

Definition at line 719 of file expect.cpp.

720 {
721  const expect<void> val1;
722  expect<void> val2;
723 
724  EXPECT_TRUE(val1.equal(val2));
725  EXPECT_TRUE(val2.equal(val1));
726  EXPECT_TRUE(!val1.equal(std::error_code{}));
727  EXPECT_TRUE(!val2.equal(std::error_code{}));
728  EXPECT_TRUE(val1 == val2);
729  EXPECT_TRUE(val2 == val1);
730  EXPECT_TRUE(!(val1 == std::error_code{}));
731  EXPECT_TRUE(!(std::error_code{} == val1));
732  EXPECT_TRUE(!(val2 == std::error_code{}));
733  EXPECT_TRUE(!(std::error_code{} == val2));
734  EXPECT_TRUE(!(val1 != val2));
735  EXPECT_TRUE(!(val2 != val1));
736  EXPECT_TRUE(val1 != std::error_code{});
737  EXPECT_TRUE(std::error_code{} != val1);
738  EXPECT_TRUE(!(val2 == std::error_code{}));
739  EXPECT_TRUE(!(std::error_code{} == val2));
740 
741  val2 = make_error_code(common_error::kInvalidArgument);
742 
743  EXPECT_TRUE(!val1.equal(val2));
744  EXPECT_TRUE(!val2.equal(val1));
745  EXPECT_TRUE(!val1.equal(common_error::kInvalidArgument));
746  EXPECT_TRUE(val2.equal(common_error::kInvalidArgument));
747  EXPECT_TRUE(!val2.equal(std::error_code{}));
748  EXPECT_TRUE(!(val1 == val2));
749  EXPECT_TRUE(!(val2 == val1));
750  EXPECT_TRUE(val2 == common_error::kInvalidArgument);
751  EXPECT_TRUE(common_error::kInvalidArgument == val2);
752  EXPECT_TRUE(!(val2 == std::error_code{}));
753  EXPECT_TRUE(!(std::error_code{} == val2));
754  EXPECT_TRUE(val1 != val2);
755  EXPECT_TRUE(val2 != val1);
756  EXPECT_TRUE(!(val2 != common_error::kInvalidArgument));
757  EXPECT_TRUE(!(common_error::kInvalidArgument != val2));
758  EXPECT_TRUE(val2 != std::error_code{});
759  EXPECT_TRUE(std::error_code{} != val2);
760 }
expect< void >::equal
bool equal(expect const &rhs) const noexcept
Definition: expect.h:378
Here is the call graph for this function:

◆ TEST() [8/10]

TEST ( Expect  ,
Macros   
)

Definition at line 818 of file expect.cpp.

818  {
819  EXPECT_TRUE(
820  [] () -> ::common_error {
821  ELECTRONEUM_PRECOND(true);
822  return {common_error::kInvalidErrorCode};
823  } () == common_error::kInvalidErrorCode
824  );
825  EXPECT_TRUE(
826  [] () -> ::common_error {
827  ELECTRONEUM_PRECOND(false);
828  return {common_error::kInvalidErrorCode};
829  } () == common_error::kInvalidArgument
830  );
831  EXPECT_TRUE(
832  [] () -> std::error_code {
833  ELECTRONEUM_PRECOND(true);
834  return {common_error::kInvalidErrorCode};
835  } () == common_error::kInvalidErrorCode
836  );
837  EXPECT_TRUE(
838  [] () -> std::error_code {
839  ELECTRONEUM_PRECOND(false);
840  return {common_error::kInvalidErrorCode};
841  } () == common_error::kInvalidArgument
842  );
843  EXPECT_TRUE(
844  [] () -> expect<void> {
845  ELECTRONEUM_PRECOND(true);
846  return {common_error::kInvalidErrorCode};
847  } () == common_error::kInvalidErrorCode
848  );
849  EXPECT_TRUE(
850  [] () -> expect<void> {
851  ELECTRONEUM_PRECOND(false);
852  return {common_error::kInvalidErrorCode};
853  } () == common_error::kInvalidArgument
854  );
855  EXPECT_TRUE(
856  [] () -> expect<int> {
857  ELECTRONEUM_PRECOND(true);
858  return {common_error::kInvalidErrorCode};
859  } () == common_error::kInvalidErrorCode
860  );
861  EXPECT_TRUE(
862  [] () -> expect<int> {
863  ELECTRONEUM_PRECOND(false);
864  return {common_error::kInvalidErrorCode};
865  } () == common_error::kInvalidArgument
866  );
867 
868  EXPECT_TRUE(
869  [] () -> std::error_code {
870  ELECTRONEUM_CHECK(expect<void>{});
871  return {common_error::kInvalidErrorCode};
872  } () == common_error::kInvalidErrorCode
873  );
874  EXPECT_TRUE(
875  [] () -> std::error_code {
876  ELECTRONEUM_CHECK(expect<void>{common_error::kInvalidArgument});
877  return {common_error::kInvalidErrorCode};
878  } () == common_error::kInvalidArgument
879  );
880  EXPECT_TRUE(
881  [] () -> expect<void> {
882  ELECTRONEUM_CHECK(expect<void>{});
883  return {common_error::kInvalidErrorCode};
884  } () == common_error::kInvalidErrorCode
885  );
886  EXPECT_TRUE(
887  [] () -> expect<void> {
888  ELECTRONEUM_CHECK(expect<void>{common_error::kInvalidArgument});
889  return {common_error::kInvalidErrorCode};
890  } () == common_error::kInvalidArgument
891  );
892  EXPECT_TRUE(
893  [] () -> expect<int> {
894  ELECTRONEUM_CHECK(expect<void>{});
895  return {common_error::kInvalidErrorCode};
896  } () == common_error::kInvalidErrorCode
897  );
898  EXPECT_TRUE(
899  [] () -> expect<int> {
900  ELECTRONEUM_CHECK(expect<void>{common_error::kInvalidArgument});
901  return {common_error::kInvalidErrorCode};
902  } () == common_error::kInvalidArgument
903  );
904 
905  EXPECT_NO_THROW(ELECTRONEUM_UNWRAP(success()));
906  EXPECT_NO_THROW(ELECTRONEUM_UNWRAP(expect<void>{}));
907  EXPECT_NO_THROW(ELECTRONEUM_UNWRAP(expect<int>{0}));
908  EXPECT_THROW(
909  ELECTRONEUM_UNWRAP(expect<void>{common_error::kInvalidArgument}), std::system_error
910  );
911  EXPECT_THROW(
912  ELECTRONEUM_UNWRAP(expect<int>{common_error::kInvalidArgument}), std::system_error
913  );
914 }
ELECTRONEUM_UNWRAP
#define ELECTRONEUM_UNWRAP(...)
Definition: expect.h:60
ELECTRONEUM_PRECOND
#define ELECTRONEUM_PRECOND(...)
If precondition fails, return ::error::kInvalidArgument in current scope.
Definition: expect.h:39
success
expect< void > success() noexcept
Definition: expect.h:397
ELECTRONEUM_CHECK
#define ELECTRONEUM_CHECK(...)
Check expect<void> and return errors in current scope.
Definition: expect.h:47
common_error
common_error
Definition: error.h:33
common_error::kInvalidErrorCode
@ kInvalidErrorCode
Default std::error_code given to expect<T>
Here is the call graph for this function:

◆ TEST() [9/10]

TEST ( Expect  ,
NoExcept   
)

Definition at line 210 of file expect.cpp.

211 {
212  noexcept_bench<void>();
213  noexcept_bench<int>();
214 
215  EXPECT_TRUE(std::is_nothrow_constructible<expect<void>>());
216 
217  EXPECT_TRUE((std::is_nothrow_constructible<expect<int>, int>()));
218  EXPECT_TRUE((std::is_nothrow_constructible<expect<int>, expect<unsigned>>()));
219  EXPECT_TRUE((std::is_nothrow_constructible<expect<int>, expect<unsigned>&&>()));
220  EXPECT_TRUE((std::is_nothrow_constructible<expect<int>, expect<unsigned>&>()));
221  EXPECT_TRUE((std::is_nothrow_constructible<expect<int>, expect<unsigned> const&>()));
222 
223  EXPECT_TRUE(noexcept(expect<int>{std::declval<expect<unsigned>&&>()}));
224  EXPECT_TRUE(noexcept(expect<int>{std::declval<expect<unsigned> const&>()}));
225  EXPECT_TRUE(noexcept(std::declval<expect<int>>().has_value()));
226  EXPECT_TRUE(noexcept(*std::declval<expect<int>>()));
227  EXPECT_TRUE(noexcept(std::declval<expect<int>>().equal(std::declval<expect<unsigned>>())));
228  EXPECT_TRUE(noexcept(std::declval<expect<unsigned>>().equal(std::declval<expect<int>>())));
229  EXPECT_TRUE(noexcept(std::declval<expect<int>>().equal(0)));
230  EXPECT_TRUE(noexcept(std::declval<expect<int>>() == std::declval<expect<unsigned>>()));
231  EXPECT_TRUE(noexcept(std::declval<expect<unsigned>>() == std::declval<expect<int>>()));
232  EXPECT_TRUE(noexcept(std::declval<expect<int>>() == 0));
233  EXPECT_TRUE(noexcept(0 == std::declval<expect<int>>()));
234  EXPECT_TRUE(noexcept(std::declval<expect<int>>() != std::declval<expect<unsigned>>()));
235  EXPECT_TRUE(noexcept(std::declval<expect<unsigned>>() != std::declval<expect<int>>()));
236  EXPECT_TRUE(noexcept(std::declval<expect<int>>() != 0));
237  EXPECT_TRUE(noexcept(0 != std::declval<expect<int>>()));
238 
239  EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_construct>, std::error_code>()));
240  EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_construct>, std::error_code&&>()));
241  EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_construct>, std::error_code&>()));
242  EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_construct>, std::error_code const&>()));
243  EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_construct>, throw_construct>()));
244  EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_construct>, throw_construct&&>()));
245  EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_construct>, throw_construct&>()));
246  EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_construct>, throw_construct const&>()));
247  EXPECT_TRUE(!(std::is_nothrow_constructible<expect<throw_construct>, expect<int>>()));
248  EXPECT_TRUE(!(std::is_nothrow_constructible<expect<throw_construct>, expect<int>&&>()));
249  EXPECT_TRUE(!(std::is_nothrow_constructible<expect<throw_construct>, expect<int>&>()));
250  EXPECT_TRUE(!(std::is_nothrow_constructible<expect<throw_construct>, expect<int> const&>()));
251  EXPECT_TRUE(std::is_nothrow_copy_constructible<expect<throw_construct>>());
252  EXPECT_TRUE(std::is_nothrow_move_constructible<expect<throw_construct>>());
253  EXPECT_TRUE(std::is_nothrow_copy_assignable<expect<throw_construct>>());
254  EXPECT_TRUE(std::is_nothrow_move_assignable<expect<throw_construct>>());
255  EXPECT_TRUE(std::is_nothrow_destructible<expect<throw_construct>>());
256 
257  EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_copies>, std::error_code>()));
258  EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_copies>, std::error_code&&>()));
259  EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_copies>, std::error_code&>()));
260  EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_copies>, std::error_code const&>()));
261  EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_copies>, throw_copies>()));
262  EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_copies>, throw_copies&&>()));
263  EXPECT_TRUE(!(std::is_nothrow_constructible<expect<throw_copies>, throw_copies&>()));
264  EXPECT_TRUE(!(std::is_nothrow_constructible<expect<throw_copies>, throw_copies const&>()));
265  EXPECT_TRUE(!std::is_nothrow_copy_constructible<expect<throw_copies>>());
266  EXPECT_TRUE(std::is_nothrow_move_constructible<expect<throw_copies>>());
267  EXPECT_TRUE(!std::is_nothrow_copy_assignable<expect<throw_copies>>());
268  EXPECT_TRUE(std::is_nothrow_move_assignable<expect<throw_copies>>());
269  EXPECT_TRUE(std::is_nothrow_destructible<expect<throw_copies>>());
270  EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>().equal(std::declval<expect<throw_copies>>())));
271  EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>().equal(std::declval<throw_copies>())));
272  EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>() == std::declval<expect<throw_copies>>()));
273  EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>() == std::declval<throw_copies>()));
274  EXPECT_TRUE(noexcept(std::declval<throw_copies>() == std::declval<expect<throw_copies>>()));
275  EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>() != std::declval<expect<throw_copies>>()));
276  EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>() != std::declval<throw_copies>()));
277  EXPECT_TRUE(noexcept(std::declval<throw_copies>() != std::declval<expect<throw_copies>>()));
278  EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>().equal(std::declval<expect<throw_moves>>())));
279  EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>().equal(std::declval<throw_moves>())));
280  EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>() == std::declval<expect<throw_moves>>()));
281  EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>() == std::declval<throw_moves>()));
282  EXPECT_TRUE(noexcept(std::declval<throw_moves>() == std::declval<expect<throw_copies>>()));
283  EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>() != std::declval<expect<throw_moves>>()));
284  EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>() != std::declval<throw_moves>()));
285  EXPECT_TRUE(noexcept(std::declval<throw_moves>() != std::declval<expect<throw_copies>>()));
286 
287  EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_moves>, std::error_code>()));
288  EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_moves>, std::error_code&&>()));
289  EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_moves>, std::error_code&>()));
290  EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_moves>, std::error_code const&>()));
291  EXPECT_TRUE(!(std::is_nothrow_constructible<expect<throw_moves>, throw_moves>()));
292  EXPECT_TRUE(!(std::is_nothrow_constructible<expect<throw_moves>, throw_moves&&>()));
293  EXPECT_TRUE(!(std::is_nothrow_constructible<expect<throw_moves>, throw_moves&>()));
294  EXPECT_TRUE(!(std::is_nothrow_constructible<expect<throw_moves>, throw_moves const&>()));
295  EXPECT_TRUE(std::is_nothrow_copy_constructible<expect<throw_moves>>());
296  EXPECT_TRUE(!std::is_nothrow_move_constructible<expect<throw_moves>>());
297  EXPECT_TRUE(std::is_nothrow_copy_assignable<expect<throw_moves>>());
298  EXPECT_TRUE(!std::is_nothrow_move_assignable<expect<throw_moves>>());
299  EXPECT_TRUE(std::is_nothrow_destructible<expect<throw_copies>>());
300  EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>().equal(std::declval<expect<throw_moves>>())));
301  EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>().equal(std::declval<throw_moves>())));
302  EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>() == std::declval<expect<throw_moves>>()));
303  EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>() == std::declval<throw_moves>()));
304  EXPECT_TRUE(!noexcept(std::declval<throw_moves>() == std::declval<expect<throw_moves>>()));
305  EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>() != std::declval<expect<throw_moves>>()));
306  EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>() != std::declval<throw_moves>()));
307  EXPECT_TRUE(!noexcept(std::declval<throw_moves>() != std::declval<expect<throw_moves>>()));
308  EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>().equal(std::declval<expect<throw_copies>>())));
309  EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>().equal(std::declval<throw_copies>())));
310  EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>() == std::declval<expect<throw_copies>>()));
311  EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>() == std::declval<throw_copies>()));
312  EXPECT_TRUE(!noexcept(std::declval<throw_copies>() == std::declval<expect<throw_moves>>()));
313  EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>() != std::declval<expect<throw_copies>>()));
314  EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>() != std::declval<throw_copies>()));
315  EXPECT_TRUE(!noexcept(std::declval<throw_copies>() != std::declval<expect<throw_moves>>()));
316 }

◆ TEST() [10/10]

TEST ( Expect  ,
Trivial   
)

Definition at line 318 of file expect.cpp.

319 {
320  EXPECT_TRUE(std::is_trivially_copy_constructible<expect<void>>());
321  EXPECT_TRUE(std::is_trivially_move_constructible<expect<void>>());
322  EXPECT_TRUE(std::is_trivially_destructible<expect<void>>());
323 }