plugin_search_path_t.cc File Reference

#include "catch2/catch.hpp"
#include "cetlib/detail/plugin_search_path.h"
#include "cetlib/getenv.h"
#include "cetlib/os_libpath.h"
#include "cetlib/plugin_libpath.h"
#include "cetlib/search_path.h"
#include "cetlib/split_path.h"
#include <cstdlib>
#include <set>
#include <string>

Go to the source code of this file.

Macros
#define	_POSIX_C_SOURCE   200112L

Functions
	TEST_CASE ("Tests")

Macro Definition Documentation

#define _POSIX_C_SOURCE   200112L

Definition at line 3 of file plugin_search_path_t.cc.

Function Documentation

TEST_CASE

(

"Tests"

)

Definition at line 57 of file plugin_search_path_t.cc.

{
  // Setup.
  unsetenv(plugin_libpath());
  string const default_libpath{cet::getenv(os_libpath(), std::nothrow)};
  if (default_libpath.empty()) {
    // Need *something*.
    setenv(os_libpath(), "/dev/null/libpath", 1);
  }
  auto const libpath_before = cet::getenv(os_libpath());

  ////////////////////////////////////
  // Tests.
  ////////////////////////////////////

  // Test using non-empty plugin_libpath().
  SECTION("Standard")
  {
    setenv(plugin_libpath(), test_path.c_str(), 1);
    string const expected{remove_dups_from_path(cet::getenv(plugin_libpath()) +
                                                ":" + libpath_before)};
    auto const sp{plugin_search_path(search_path{plugin_libpath()})};
    CHECK(tp_sz == sp.size());
    auto const libpath = cet::getenv(os_libpath());
    CHECK(expected == libpath);
    CHECK(tp_sz < path_entries(libpath));
  }

  // Test fallback for null plugin_libpath().
  SECTION("Standard Null")
  {
    auto const sp{
      plugin_search_path(search_path{plugin_libpath(), std::nothrow})};
    auto const libpath = cet::getenv(os_libpath());
    CHECK(path_entries(libpath) == sp.size());
    CHECK(remove_dups_from_path(libpath_before) == libpath);
  }

  // Test lack of fallback for empty plugin_libpath().
  SECTION("Standard Empty")
  {
    setenv(plugin_libpath(), "", 1);
    auto const sp{plugin_search_path(search_path{plugin_libpath()})};
    CHECK(1ull == sp.size()); // "."
    CHECK(remove_dups_from_path(libpath_before) == cet::getenv(os_libpath()));
  }

  // Test non-empty arbitrary environment variable.
  SECTION("Custom")
  {
    setenv("SIMPLE_VAR", test_path.c_str(), 1);
    auto const sp{plugin_search_path(search_path{"SIMPLE_VAR"})};
    auto const libpath = cet::getenv(os_libpath());
    CHECK(tp_sz == sp.size());
    string const expected{cet::getenv("SIMPLE_VAR") + ":" + libpath_before};
    CHECK(remove_dups_from_path(expected) == libpath);
    CHECK(tp_sz < path_entries(libpath));
  }

  // Test null arbitrary environment variable.
  SECTION("Custom Null")
  {
    auto const sp{plugin_search_path(search_path{"MISSING_VAR", std::nothrow})};
    CHECK(1ull == sp.size()); // "."
    CHECK(remove_dups_from_path(libpath_before) == cet::getenv(os_libpath()));
  }

  // Test empty arbitrary environment variable.
  SECTION("Custom Empty")
  {
    setenv("EMPTY_VAR", "", 1);
    auto const sp{plugin_search_path(search_path{"EMPTY_VAR"})};
    CHECK(1ull == sp.size()); // "."
    CHECK(remove_dups_from_path(libpath_before) == cet::getenv(os_libpath()));
  }

  // Teardown.
  setenv(os_libpath(), default_libpath.c_str(), 1);
}