ScopeGuards.cc

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#include <framework/utilities/ScopeGuard.h>
#include <framework/utilities/Utils.h>
#include <gtest/gtest.h>
#include <filesystem>
 
namespace {
  struct IntSetterGetterFunctor {
    explicit IntSetterGetterFunctor(int& reference): ref(reference) {}
    void operator()(const int& v) { ref = v; }
    int operator()() const { return ref; }
    int& ref;
  };
 
  TEST(ScopeGuards, IntRef)
  {
    int old{5};
    {
      auto guard = Belle2::ScopeGuard::guardValue(old); // cppcheck-suppress unreadVariable
      ASSERT_EQ(old, 5);
      old = 17;
    }
    ASSERT_EQ(old, 5);
    {
      auto guard = Belle2::ScopeGuard::guardValue(old, 17); // cppcheck-suppress unreadVariable
      ASSERT_EQ(old, 17);
    }
    ASSERT_EQ(old, 5);
    {
      auto guard = Belle2::ScopeGuard::guardValue(old, 17);
      ASSERT_EQ(old, 17);
      guard.release();
    }
    ASSERT_EQ(old, 17);
  }
 
  TEST(ScopeGuards, IntSetterGetter)
  {
    int old{5};
    auto setter = [&old](int v) {old = v;};
    auto getter = [&old]() {return old;};
    {
      auto guard = Belle2::ScopeGuard::guardGetterSetter(getter, setter);
      ASSERT_EQ(old, 5);
      old = 17;
    }
    ASSERT_EQ(old, 5);
    {
      auto guard = Belle2::ScopeGuard::guardGetterSetter(getter, setter, 17);
      ASSERT_EQ(old, 17);
    }
    ASSERT_EQ(old, 5);
    {
      auto guard = Belle2::ScopeGuard::guardGetterSetter(getter, setter, 17);
      ASSERT_EQ(old, 17);
      guard.release();
    }
    ASSERT_EQ(old, 17);
  }
 
  TEST(ScopeGuards, IntSetterGetterFunctor)
  {
    int old{5};
    IntSetterGetterFunctor functor(old);
    {
      auto guard = Belle2::ScopeGuard::guardFunctor(functor); // cppcheck-suppress unreadVariable
      ASSERT_EQ(old, 5);
      old = 17;
    }
    ASSERT_EQ(old, 5);
    {
      auto guard = Belle2::ScopeGuard::guardFunctor(functor, 17); // cppcheck-suppress unreadVariable
      ASSERT_EQ(old, 17);
    }
    ASSERT_EQ(old, 5);
    {
      auto guard = Belle2::ScopeGuard::guardFunctor(functor, 17);
      ASSERT_EQ(old, 17);
      guard.release();
    }
    ASSERT_EQ(old, 17);
    {
      // cppcheck-suppress unreadVariable
      auto guard = Belle2::ScopeGuard::guardFunctor(Belle2::Utils::VisitOverload{
        [&old](int v) { old = v; },
        [&old]() { return old; }
      }, 21);
      ASSERT_EQ(old, 21);
    }
    ASSERT_EQ(old, 17);
  }
 
  TEST(ScopeGuards, StringReference)
  {
    std::string value{"before"};
    {
      auto guard = Belle2::ScopeGuard::guardValue(value, "after"); // cppcheck-suppress unreadVariable
      ASSERT_EQ(value, "after");
    }
    ASSERT_EQ(value, "before");
    {
      // cppcheck-suppress unreadVariable
      auto guard = Belle2::ScopeGuard::guardFunctor(Belle2::Utils::VisitOverload{
        [&value](const std::string & v) { value = v; },
        [&value]() { return value; }
      }, "after");
      ASSERT_EQ(value, "after");
    };
    ASSERT_EQ(value, "before");
  }
 
  TEST(ScopeGuards, StreamState)
  {
    std::stringstream buf;
    buf << "a:" << std::setprecision(4) << 1.2;
    {
      auto guard1 = Belle2::ScopeGuard::guardStreamState(buf); // cppcheck-suppress unreadVariable
      buf << ":b:" << std::fixed << std::setprecision(4) << 2.3;
      {
        // cppcheck-suppress unreadVariable
        auto guard3 = Belle2::ScopeGuard::guardStreamState(buf);
        buf << ":c:" << std::setprecision(5) << std::setw(10) << std::setfill('-') << 3.4;
      }
 
      buf << ":d:" << std::scientific << 4.5;
    }
    buf << ":e:" << 5.4;
    ASSERT_EQ(buf.str(), "a:1.2:b:2.3000:c:---3.40000:d:4.5000e+00:e:5.4");
  }
 
  TEST(ScopeGuards, WorkingDirectory)
  {
    std::string start{std::filesystem::current_path().c_str()};
    std::string tmpdir(std::filesystem::temp_directory_path().c_str());
    std::string root("/");
    {
      auto guard1 = Belle2::ScopeGuard::guardWorkingDirectory( // cppcheck-suppress unreadVariable
                      std::filesystem::temp_directory_path().c_str());
      ASSERT_EQ(tmpdir, std::filesystem::current_path().c_str());
      {
        auto guard2 = Belle2::ScopeGuard::guardWorkingDirectory("/");
        ASSERT_EQ(root, std::filesystem::current_path().c_str());
        guard2.release();
      }
      ASSERT_EQ(root, std::filesystem::current_path().c_str());
    }
    ASSERT_EQ(start, std::filesystem::current_path().c_str());
  }
 
 
  TEST(ScopeGuards, Batch)
  {
    const bool start = gROOT->IsBatch();
    {
      auto guard1 = Belle2::ScopeGuard::guardBatchMode(); // cppcheck-suppress unreadVariable
      ASSERT_EQ(true, gROOT->IsBatch());
      {
        auto guard2 = Belle2::ScopeGuard::guardBatchMode(false); // cppcheck-suppress unreadVariable
        ASSERT_EQ(false, gROOT->IsBatch());
      }
      ASSERT_EQ(true, gROOT->IsBatch());
    }
    ASSERT_EQ(start, gROOT->IsBatch());
  }
}