ScopeGuardTest.cpp File Reference

#include <folly/ScopeGuard.h>
#include <glog/logging.h>
#include <functional>
#include <stdexcept>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Classes
class	MyFunctor
class	Foo

Enumerations
enum	ErrorBehavior { ErrorBehavior::SUCCESS, ErrorBehavior::HANDLED_ERROR, ErrorBehavior::UNHANDLED_ERROR }

Functions
double	returnsDouble ()
	TEST (ScopeGuard, DifferentWaysToBind)
	TEST (ScopeGuard, GuardException)
void	testUndoAction (bool failure)
	TEST (ScopeGuard, UndoAction)
void	testFinally (ErrorBehavior error)
	TEST (ScopeGuard, TryCatchFinally)
	TEST (ScopeGuard, TEST_SCOPE_EXIT)
	TEST (ScopeGuard, TEST_SCOPE_FAILURE2)
void	testScopeFailAndScopeSuccess (ErrorBehavior error, bool expectFail)
	TEST (ScopeGuard, TEST_SCOPE_FAIL_AND_SCOPE_SUCCESS)
	TEST (ScopeGuard, TEST_SCOPE_SUCCESS_THROW)
	TEST (ScopeGuard, TEST_THROWING_CLEANUP_ACTION)

Enumeration Type Documentation

enum ErrorBehavior

strong

Sometimes in a try catch block we want to execute a piece of code regardless if an exception happened or not. For example, you want to close a db connection regardless if an exception was thrown during insertion. In Java and other languages there is a finally clause that helps accomplish this:

try { dbConn.doInsert(sql); } catch (const DbException& dbe) { dbConn.recordFailure(dbe); } catch (const CriticalException& e) { throw e; // re-throw the exception } finally { dbConn.closeConnection(); // executes no matter what! }

We can approximate this behavior in C++ with ScopeGuard.

Enumerator
SUCCESS
HANDLED_ERROR
UNHANDLED_ERROR

Definition at line 195 of file ScopeGuardTest.cpp.

                         {
  SUCCESS,
  HANDLED_ERROR,
  UNHANDLED_ERROR,
};

Function Documentation

double returnsDouble

(

)

Definition at line 29 of file ScopeGuardTest.cpp.

Referenced by TEST().

                       {
  return 0.0;
}

TEST	(	ScopeGuard	,
		DifferentWaysToBind
	)

Definition at line 45 of file ScopeGuardTest.cpp.

References folly::netops::bind(), EXPECT_EQ, f, g(), folly::makeGuard(), MyFunctor::MyFunctor(), push_back(), returnsDouble(), and v.

                                      {
  {
    // There is implicit conversion from func pointer
    // double (*)() to function<void()>.
    auto g = makeGuard(returnsDouble);
    (void)g;
  }

  vector<int> v;
  void (vector<int>::*push_back)(int const&) = &vector<int>::push_back;

  v.push_back(1);
  {
    // binding to member function.
    auto g = makeGuard(std::bind(&vector<int>::pop_back, &v));
    (void)g;
  }
  EXPECT_EQ(0, v.size());

  {
    // bind member function with args. v is passed-by-value!
    auto g = makeGuard(std::bind(push_back, v, 2));
    (void)g;
  }
  EXPECT_EQ(0, v.size()); // push_back happened on a copy of v... fail!

  // pass in an argument by pointer so to avoid copy.
  {
    auto g = makeGuard(std::bind(push_back, &v, 4));
    (void)g;
  }
  EXPECT_EQ(1, v.size());

  {
    // pass in an argument by reference so to avoid copy.
    auto g = makeGuard(std::bind(push_back, std::ref(v), 4));
    (void)g;
  }
  EXPECT_EQ(2, v.size());

  // lambda with a reference to v
  {
    auto g = makeGuard([&] { v.push_back(5); });
    (void)g;
  }
  EXPECT_EQ(3, v.size());

  // lambda with a copy of v
  {
    auto g = makeGuard([v]() mutable { v.push_back(6); });
    (void)g;
  }
  EXPECT_EQ(3, v.size());

  // functor object
  int n = 0;
  {
    MyFunctor f(&n);
    auto g = makeGuard(f);
    (void)g;
  }
  EXPECT_EQ(1, n);

  // temporary functor object
  n = 0;
  {
    auto g = makeGuard(MyFunctor(&n));
    (void)g;
  }
  EXPECT_EQ(1, n);

  // Use auto instead of ScopeGuard
  n = 2;
  {
    auto g = makeGuard(MyFunctor(&n));
    (void)g;
  }
  EXPECT_EQ(3, n);

  // Use const auto& instead of ScopeGuard
  n = 10;
  {
    const auto& g = makeGuard(MyFunctor(&n));
    (void)g;
  }
  EXPECT_EQ(11, n);
}

TEST	(	ScopeGuard	,
		GuardException
	)

Definition at line 133 of file ScopeGuardTest.cpp.

References folly::makeGuard().

                                 {
  EXPECT_DEATH(
      (void)makeGuard(
          [] { throw std::runtime_error("dtors should never throw!"); }),
      "dtors should never throw!");
}

TEST	(	ScopeGuard	,
		UndoAction
	)

Definition at line 171 of file ScopeGuardTest.cpp.

References testUndoAction().

                             {
  testUndoAction(true);
  testUndoAction(false);
}

TEST	(	ScopeGuard	,
		TryCatchFinally
	)

Definition at line 223 of file ScopeGuardTest.cpp.

References HANDLED_ERROR, SUCCESS, testFinally(), and UNHANDLED_ERROR.

                                  {
  testFinally(ErrorBehavior::SUCCESS);
  testFinally(ErrorBehavior::HANDLED_ERROR);
  testFinally(ErrorBehavior::UNHANDLED_ERROR);
}

TEST	(	ScopeGuard	,
		TEST_SCOPE_EXIT
	)

Definition at line 229 of file ScopeGuardTest.cpp.

References EXPECT_EQ, SCOPE_EXIT, and x.

                                  {
  int x = 0;
  {
    SCOPE_EXIT {
      ++x;
    };
    EXPECT_EQ(0, x);
  }
  EXPECT_EQ(1, x);
}

TEST	(	ScopeGuard	,
		TEST_SCOPE_FAILURE2
	)

Definition at line 260 of file ScopeGuardTest.cpp.

References f.

                                      {
  try {
    Foo f;
    throw std::runtime_error("test");
  } catch (...) {
  }
}

TEST	(	ScopeGuard	,
		TEST_SCOPE_FAIL_AND_SCOPE_SUCCESS
	)

Definition at line 296 of file ScopeGuardTest.cpp.

References HANDLED_ERROR, SUCCESS, testScopeFailAndScopeSuccess(), and UNHANDLED_ERROR.

                                                    {
  testScopeFailAndScopeSuccess(ErrorBehavior::SUCCESS, false);
  testScopeFailAndScopeSuccess(ErrorBehavior::HANDLED_ERROR, false);
  testScopeFailAndScopeSuccess(ErrorBehavior::UNHANDLED_ERROR, true);
}

TEST	(	ScopeGuard	,
		TEST_SCOPE_SUCCESS_THROW
	)

Definition at line 302 of file ScopeGuardTest.cpp.

References EXPECT_THROW.

                                           {
  auto lambda = []() {
    SCOPE_SUCCESS {
      throw std::runtime_error("ehm");
    };
  };
  EXPECT_THROW(lambda(), std::runtime_error);
}

TEST	(	ScopeGuard	,
		TEST_THROWING_CLEANUP_ACTION
	)

Definition at line 311 of file ScopeGuardTest.cpp.

References EXPECT_EQ, EXPECT_THROW, folly::makeGuard(), and MyFunctor::operator()().

                                               {
  struct ThrowingCleanupAction {
    // clang-format off
    explicit ThrowingCleanupAction(int& scopeExitExecuted)
        : scopeExitExecuted_(scopeExitExecuted) {}
    [[noreturn]] ThrowingCleanupAction(const ThrowingCleanupAction& other)
        : scopeExitExecuted_(other.scopeExitExecuted_) {
      throw std::runtime_error("whoa");
    }
    // clang-format on
    void operator()() {
      ++scopeExitExecuted_;
    }

   private:
    int& scopeExitExecuted_;
  };
  int scopeExitExecuted = 0;
  ThrowingCleanupAction onExit(scopeExitExecuted);
  EXPECT_THROW((void)makeGuard(onExit), std::runtime_error);
  EXPECT_EQ(scopeExitExecuted, 1);
}

void testFinally

(

ErrorBehavior

error

)

Definition at line 201 of file ScopeGuardTest.cpp.

References EXPECT_TRUE, folly::gen::guard(), HANDLED_ERROR, folly::makeGuard(), and UNHANDLED_ERROR.

Referenced by TEST().

                                      {
  bool cleanupOccurred = false;

  try {
    auto guard = makeGuard([&] { cleanupOccurred = true; });
    (void)guard;

    try {
      if (error == ErrorBehavior::HANDLED_ERROR) {
        throw std::runtime_error("throwing an expected error");
      } else if (error == ErrorBehavior::UNHANDLED_ERROR) {
        throw "never throw raw strings";
      }
    } catch (const std::runtime_error&) {
    }
  } catch (...) {
    // Outer catch to swallow the error for the UNHANDLED_ERROR behavior
  }

  EXPECT_TRUE(cleanupOccurred);
}

void testScopeFailAndScopeSuccess	(	ErrorBehavior	error,
		bool	expectFail
	)

Definition at line 268 of file ScopeGuardTest.cpp.

References EXPECT_EQ, HANDLED_ERROR, and UNHANDLED_ERROR.

Referenced by TEST().

                                                                        {
  bool scopeFailExecuted = false;
  bool scopeSuccessExecuted = false;

  try {
    SCOPE_FAIL {
      scopeFailExecuted = true;
    };
    SCOPE_SUCCESS {
      scopeSuccessExecuted = true;
    };

    try {
      if (error == ErrorBehavior::HANDLED_ERROR) {
        throw std::runtime_error("throwing an expected error");
      } else if (error == ErrorBehavior::UNHANDLED_ERROR) {
        throw "never throw raw strings";
      }
    } catch (const std::runtime_error&) {
    }
  } catch (...) {
    // Outer catch to swallow the error for the UNHANDLED_ERROR behavior
  }

  EXPECT_EQ(expectFail, scopeFailExecuted);
  EXPECT_EQ(!expectFail, scopeSuccessExecuted);
}

void testUndoAction

(

bool

failure

)

Add an integer to a vector iff it was inserted into the db successfuly. Here is a schematic of how you would accomplish this with scope guard.

Definition at line 145 of file ScopeGuardTest.cpp.

References EXPECT_EQ, folly::gen::guard(), folly::makeGuard(), and v.

Referenced by TEST().

                                  {
  vector<int64_t> v;
  { // defines a "mini" scope

    // be optimistic and insert this into memory
    v.push_back(1);

    // The guard is triggered to undo the insertion unless dismiss() is called.
    auto guard = makeGuard([&] { v.pop_back(); });

    // Do some action; Use the failure argument to pretend
    // if it failed or succeeded.

    // if there was no failure, dismiss the undo guard action.
    if (!failure) {
      guard.dismiss();
    }
  } // all stack allocated in the mini-scope will be destroyed here.

  if (failure) {
    EXPECT_EQ(0, v.size()); // the action failed => undo insertion
  } else {
    EXPECT_EQ(1, v.size()); // the action succeeded => keep insertion
  }
}