// Register a callout for a particular library.
void
-CalloutManager::registerCallout(int libindex, const std::string& name,
- CalloutPtr callout) {
+CalloutManager::registerCallout(const std::string& name, CalloutPtr callout) {
+ // Sanity check that the current library index is set to a valid value.
+ checkLibraryIndex(current_library_);
+
// Get the index associated with this hook (validating the name in the
// process).
int hook_index = hooks_->getIndex(name);
// the present index.
for (CalloutVector::iterator i = hook_vector_[hook_index].begin();
i != hook_vector_[hook_index].end(); ++i) {
- if (i->first > libindex) {
+ if (i->first > current_library_) {
// Found an element whose library number is greater than ours,
// so insert the new element ahead of this one.
- hook_vector_[hook_index].insert(i,
- std::make_pair(libindex, callout));
+ hook_vector_[hook_index].insert(i, make_pair(current_library_,
+ callout));
return;
}
}
// Reach the end of the vector, so no element in the (possibly empty)
// set of callouts with a library index greater that the one related to
// this callout, insert at the end.
- hook_vector_[hook_index].push_back(std::make_pair(libindex, callout));
+ hook_vector_[hook_index].push_back(make_pair(current_library_, callout));
}
// Check if callouts are present for a given hook index.
// Deregister a callout registered by a library on a particular hook.
bool
-CalloutManager::deregisterCallout(int library_index, const std::string& name,
- CalloutPtr callout) {
+CalloutManager::deregisterCallout(const std::string& name, CalloutPtr callout) {
+ // Sanity check that the current library index is set to a valid value.
+ checkLibraryIndex(current_library_);
// Get the index associated with this hook (validating the name in the
// process).
int hook_index = hooks_->getIndex(name);
- /// Construct a CalloutEntry matching the specified library and the callout
+ /// Construct a CalloutEntry matching the current library and the callout
/// we want to remove.
- CalloutEntry target(library_index, callout);
+ CalloutEntry target(current_library_, callout);
/// To decide if any entries were removed, we'll record the initial size
/// of the callout vector for the hook, and compare it with the size after
// Deregister all callouts on a given hook.
bool
-CalloutManager::deregisterAllCallouts(int library_index,
- const std::string& name) {
+CalloutManager::deregisterAllCallouts(const std::string& name) {
// Get the index associated with this hook (validating the name in the
// process).
int hook_index = hooks_->getIndex(name);
- /// Construct a CalloutEntry matching the specified library we want to
- /// remove (the callout pointer is NULL as we are not checking that).
- CalloutEntry target(library_index, NULL);
+ /// Construct a CalloutEntry matching the current library (the callout
+ /// pointer is NULL as we are not checking that).
+ CalloutEntry target(current_library_, NULL);
/// To decide if any entries were removed, we'll record the initial size
/// of the callout vector for the hook, and compare it with the size after
return (initial_size != hook_vector_[hook_index].size());
}
-// CalloutManager methods.
-
-// Return pointer to the current library handle.
-
-boost::shared_ptr<LibraryHandle>
-CalloutManager::createHandle() {
- // Index is equal to the size of the current collection of handles
- // (guarantees that every handle has a unique index, and that index
- // is a pointer to the handle in the collection of handles.)
- boost::shared_ptr<LibraryHandle> handle(new LibraryHandle(handles_.size(),
- this));
-
- // Add to the current collection of handles.
- handles_.push_back(handle);
-
- return (handle);
-}
-
} // namespace util
} // namespace isc
namespace isc {
namespace util {
+/// @brief No such library
+///
+/// Thrown if an attempt is made to set the current library index to a value
+/// that is invalid for the number of loaded libraries.
+class NoSuchLibrary : public Exception {
+public:
+ NoSuchLibrary(const char* file, size_t line, const char* what) :
+ isc::Exception(file, line, what) {}
+};
+
/// @brief Callout Manager
///
/// This class manages the registration, deregistration and execution of the
/// library callouts.
///
-/// It is constructed using a @ref isc::util::ServerHooks object that holds the
-/// list of hooks registered for the server, which it uses to create the
-/// hook vector. This is a vector represting the callouts for each hook. Each
-/// element is itself a vector of callouts registered by the loaded libraries.
+/// In operation, the class need to know two items of data:
///
-/// The class also holds the collection of library handles, used to allow the
-/// libraries to manipulate their callout list.
+/// - The list of server hooks. This is used in two ways. Firstly, when a
+/// callout registers or deregisters a hook, it does so by name: the
+/// @ref isc::util::ServerHooks object supplies the names of registered
+/// hooks. Secondly, when the callouts associated with a hook are called by
+/// the server, it supplies the index of the relevant hook: this is validated
+/// hook vector (which holds the callouts associated with each hook).
+///
+/// - The number of loaded libraries. Each callout registered by a user
+/// library is associated with that library, the callout manager storing both
+/// a pointer to the callout and the index of the library in the list of
+/// loaded libraries. Callouts are allowed to dynamically register and
+/// deregister callouts (including themselves), but only callouts in the
+/// same library. When calling a callout, the callout manager maintains
+/// the idea of a "current library index": if the callout calls one of the
+/// callout registration functions in the callout manager (it can do this
+/// indirectly via the @ref LibraryHandle object), the registration functions
+/// use the "current library index" in their processing.
+///
+/// These two items of data are supplied when the class is constructed.
class CalloutManager {
private:
// Private typedefs
- /// Vector of library handles.
- typedef std::vector<boost::shared_ptr<LibraryHandle> > HandleVector;
-
/// Element in the vector of callouts. The elements in the pair are the
/// library index and the pointer to the callout.
typedef std::pair<int, CalloutPtr> CalloutEntry;
/// Initializes member variables, in particular sizing the hook vector
/// (the vector of callouts) to the appropriate size.
///
- /// @param hook Collection of known hook names.
- CalloutManager(const boost::shared_ptr<ServerHooks>& hooks) :
- hooks_(hooks), handles_(), hook_vector_(hooks->getCount())
+ /// @param hooks Collection of known hook names.
+ /// @param num_libraries Number of loaded libraries.
+ CalloutManager(const boost::shared_ptr<ServerHooks>& hooks,
+ int num_libraries)
+ : current_library_(-1), hooks_(hooks), hook_vector_(hooks->getCount()),
+ library_handle_(this), num_libraries_(num_libraries)
{}
/// @brief Register a callout on a hook
///
- /// Registers a callout function for a particular library with a given hook.
- /// The callout is added to the end of the callouts for this library that
- /// are associated with that hook.
+ /// Registers a callout function for the current library with a given hook
+ /// (the index of the "current library" being given by the current_library_
+ /// member). The callout is added to the end of the callouts for this
+ /// library that are associated with that hook.
///
- /// @param libindex Index of the library registering the callout
/// @param name Name of the hook to which the callout is added.
/// @param callout Pointer to the callout function to be registered.
///
/// @throw NoSuchHook The hook name is unrecognised.
/// @throw Unexpected The hook name is valid but an internal data structure
/// is of the wrong size.
- void registerCallout(int libindex, const std::string& name,
- CalloutPtr callout);
+ void registerCallout(const std::string& name, CalloutPtr callout);
/// @brief De-Register a callout on a hook
///
- /// Searches through the functions registered by the specified library with
- /// the named hook and removes all entries matching the callout.
+ /// Searches through the functions registered by the the current library
+ /// (the index of the "current library" being given by the current_library_
+ /// member) with the named hook and removes all entries matching the
+ /// callout.
///
- /// @param libindex Index of the library deregistering the callout
/// @param name Name of the hook from which the callout is removed.
/// @param callout Pointer to the callout function to be removed.
///
/// @throw NoSuchHook The hook name is unrecognised.
/// @throw Unexpected The hook name is valid but an internal data structure
/// is of the wrong size.
- bool deregisterCallout(int libindex, const std::string& name,
- CalloutPtr callout);
+ bool deregisterCallout(const std::string& name, CalloutPtr callout);
/// @brief Removes all callouts on a hook
///
/// Removes all callouts associated with a given hook that were registered
- /// by the specified library.
+ /// by the current library (the index of the "current library" being given
+ /// by the current_library_ member).
///
- /// @param libindex Index of the library deregistering the callouts
/// @param name Name of the hook from which the callouts are removed.
///
/// @return true if one or more callouts were deregistered.
///
/// @throw NoSuchHook Thrown if the hook name is unrecognised.
- bool deregisterAllCallouts(int libindex, const std::string& name);
+ bool deregisterAllCallouts(const std::string& name);
/// @brief Checks if callouts are present on a hook
///
/// Checks all loaded libraries and returns true if at least one callout
/// has been registered by any of them for the given hook.
///
- /// @param index Hook index for which callouts are checked.
+ /// @param hook_index Hook index for which callouts are checked.
///
/// @return true if callouts are present, false if not.
///
/// @throw NoSuchHook Given index does not correspond to a valid hook.
- bool calloutsPresent(int index) const;
+ bool calloutsPresent(int hook_index) const;
/// @brief Calls the callouts for a given hook
///
/// Iterates through the libray handles and calls the callouts associated
/// with the given hook index.
///
- /// @param index Index of the hook to call.
+ /// @param hook_index Index of the hook to call.
/// @param callout_handle Reference to the CalloutHandle object for the
/// current object being processed.
///
/// @return Status return.
- int callCallouts(int index, CalloutHandle& callout_handle);
+ int callCallouts(int hook_index, CalloutHandle& callout_handle);
+ /// @brief Get current library index
+ ///
+ /// Returns the index of the "current" library. This the index associated
+ /// with the currently executing callout when callCallouts is executing.
+ /// When callCallouts() is not executing (as is the case when the load()
+ /// function in a user-library is called during the library load process),
+ /// the index is the value set by setLibraryIndex().
+ ///
+ /// @return Current library index.
+ int getLibraryIndex() const {
+ return (current_library_);
+ }
- /// @brief Create library handle
+ /// @brief Set current library index
+ ///
+ /// Sets the current library index. This must be in the range 0 to
+ /// (numlib - 1), where "numlib" is the number of libraries loaded and is
+ /// passed to this object at construction time.
///
- /// Creates a library handle. The handle is used when loading a library in
- /// that the callouts are associated with the given library and when calling
- /// a callout: the handle for the library can be obtained to allow dynamic
- /// registration and de-registration.
- boost::shared_ptr<LibraryHandle> createHandle();
+ /// @param library_index New library index.
+ ///
+ /// @throw NoSuchLibrary if the index is not valid.
+ void setLibraryIndex(int library_index) {
+ checkLibraryIndex(library_index);
+ current_library_ = library_index;
+ }
+
+ /// @brief Return library handle
+ ///
+ /// The library handle is available to the user callout via the callout
+ /// handle object. It provides a cut-down view of the CalloutManager,
+ /// allowing the callout to register and deregister callouts in the
+ /// library of which it is part.
+ ///
+ /// @return reference to callout handle for this manager
+ LibraryHandle& getLibraryHandle() {
+ return (library_handle_);
+ }
private:
/// @brief Check hook index
///
/// @param index Hook index to test
///
- /// @throw NoSuchHook
+ /// @throw NoSuchHook Hooks does not exist.
void checkHookIndex(int hook_index) const {
if ((hook_index < 0) || (hook_index >= hook_vector_.size())) {
isc_throw(NoSuchHook, "hook index " << hook_index <<
}
}
+ /// @brief Check library index
+ ///
+ /// Ensures that the current library index is valid. This is called by
+ /// the hook registration functions.
+ ///
+ /// @param library_index Value to check for validity as a library index.
+ ///
+ /// @throw NoSuchLibrary Library index is not
+ void checkLibraryIndex(int library_index) const {
+ if ((library_index < 0) || (library_index >= num_libraries_)) {
+ isc_throw(NoSuchLibrary, "library index " << library_index <<
+ " is not valid for the number of loaded libraries (" <<
+ num_libraries_ << ")");
+ }
+ }
+
/// @brief Compare two callout entries for library equality
///
- /// This is used in callout removal code. It just checks whether two
- /// entries have the same library element.
+ /// This is used in callout removal code when all callouts on a hook for a
+ /// given library are being removed. It checks whether two callout entries
+ /// have the same library index.
///
/// @param ent1 First callout entry to check
/// @param ent2 Second callout entry to check
}
};
+ /// Current library index. When a call is made to any of the callout
+ /// registration methods, this variable indicates the index of the user
+ /// library that is calling the methods.
+ int current_library_;
+
/// List of server hooks. This is used
boost::shared_ptr<ServerHooks> hooks_;
- /// Vector of pointers to library handles.
- HandleVector handles_;
-
/// Vector of callout vectors. There is one entry in this outer vector for
- /// each hook.
+ /// each hook. Each element is itself a vector, with one entry for each
+ /// callout registered for that hook.
std::vector<CalloutVector> hook_vector_;
+ /// LibraryHandle object user by the callout to access the callout
+ /// registration methods on this CalloutManager object.
+ LibraryHandle library_handle_;
+
+ /// Number of libraries. libindex_ can vary between 0 and numlib_ - 1.
+ int num_libraries_;
+
};
} // namespace util
void
LibraryHandle::registerCallout(const std::string& name, CalloutPtr callout) {
- callout_manager_->registerCallout(library_index_, name, callout);
+ callout_manager_->registerCallout(name, callout);
}
bool
LibraryHandle::deregisterCallout(const std::string& name, CalloutPtr callout) {
- return (callout_manager_->deregisterCallout(library_index_, name, callout));
+ return (callout_manager_->deregisterCallout(name, callout));
}
bool
LibraryHandle::deregisterAllCallouts(const std::string& name) {
- return (callout_manager_->deregisterAllCallouts(library_index_, name));
+ return (callout_manager_->deregisterAllCallouts(name));
}
} // namespace util
/// @brief Constructor
///
- /// @param hooks Library index. A number (starting at 0) that represents
- /// the index of the library in the list of libraries loaded by the
- /// server.
/// @param collection Back pointer to the containing CalloutManager.
/// This pointer is used to access appropriate methods in that
/// object.
- LibraryHandle(int library_index, CalloutManager* collection)
- : library_index_(library_index), callout_manager_(collection)
+ LibraryHandle(CalloutManager* collection) : callout_manager_(collection)
{}
/// @brief Register a callout on a hook
/// @throw NoSuchHook Thrown if the hook name is unrecognised.
bool deregisterAllCallouts(const std::string& name);
- /// @brief Return handle index
- ///
- /// For test purposes only, this returns the index allocated to this
- /// LibraryHandle.
- ///
- /// @return Handle index
- int getIndex() const {
- return (library_index_);
- }
-
private:
- /// Index of this handle in the library handle list
- int library_index_;
-
/// Back pointer to the collection object for the library
CalloutManager* callout_manager_;
};
run_unittests_SOURCES += hex_unittest.cc
# run_unittests_SOURCES += handles_unittest.cc
run_unittests_SOURCES += io_utilities_unittest.cc
-# run_unittests_SOURCES += library_handle_unittest.cc
run_unittests_SOURCES += lru_list_unittest.cc
run_unittests_SOURCES += memory_segment_local_unittest.cc
if USE_SHARED_MEMORY
#include <string>
#include <vector>
+/// @file
+/// @brief CalloutManager and LibraryHandle tests
+///
+/// These set of tests check the CalloutManager and LibraryHandle. They are
+/// together in the same file because the LibraryHandle is little more than a
+/// restricted interface to the CalloutManager, and a lot of the support
+/// structure for the tests is common.
+
using namespace isc;
using namespace isc::util;
using namespace std;
gamma_index_ = hooks_->registerHook("gamma");
delta_index_ = hooks_->registerHook("delta");
- // Set up the callout manager with these hooks
- callout_manager_.reset(new CalloutManager(hooks_));
-
- // Set up four library handles.
- library_handle_.push_back(callout_manager_->createHandle());
- library_handle_.push_back(callout_manager_->createHandle());
- library_handle_.push_back(callout_manager_->createHandle());
- library_handle_.push_back(callout_manager_->createHandle());
+ // Set up the callout manager with these hooks. Assume a maximum of
+ // four libraries.
+ callout_manager_.reset(new CalloutManager(hooks_, 4));
// Set up the callout handle.
callout_handle_.reset(new CalloutHandle(callout_manager_));
/// Server hooks
boost::shared_ptr<ServerHooks> hooks_;
- /// Set up three library handles.
- std::vector<boost::shared_ptr<LibraryHandle> > library_handle_;
-
/// Callout handle used in calls
boost::shared_ptr<CalloutHandle> callout_handle_;
+
};
// Definition of the static variable.
}; // extern "C"
+// Check that we can only set the current library index to the correct values.
+
+TEST_F(CalloutManagerTest, CheckLibraryIndex) {
+ // Check valid indexes
+ for (int i = 0; i < 4; ++i) {
+ EXPECT_NO_THROW(getCalloutManager()->setLibraryIndex(i));
+ }
+
+ // Check invalid ones
+ EXPECT_THROW(getCalloutManager()->setLibraryIndex(-1), NoSuchLibrary);
+ EXPECT_THROW(getCalloutManager()->setLibraryIndex(5), NoSuchLibrary);
+}
+
+// Check that we can only register callouts on valid hook names.
+
+TEST_F(CalloutManagerTest, ValidHookNames) {
+ getCalloutManager()->setLibraryIndex(0);
+ EXPECT_NO_THROW(getCalloutManager()->registerCallout("alpha", manager_one));
+ EXPECT_THROW(getCalloutManager()->registerCallout("unknown", manager_one),
+ NoSuchHook);
+}
+
+
// Check we can register callouts appropriately.
TEST_F(CalloutManagerTest, RegisterCallout) {
EXPECT_FALSE(getCalloutManager()->calloutsPresent(beta_index_));
// Set up so that hooks "alpha" and "beta" have callouts attached from a
- // single library.
- getCalloutManager()->registerCallout(0, "alpha", manager_one);
- getCalloutManager()->registerCallout(1, "beta", manager_two);
+ // different libraries.
+ getCalloutManager()->setLibraryIndex(0);
+ getCalloutManager()->registerCallout("alpha", manager_one);
+ getCalloutManager()->setLibraryIndex(1);
+ getCalloutManager()->registerCallout("beta", manager_two);
// Check all is as expected.
EXPECT_TRUE(getCalloutManager()->calloutsPresent(alpha_index_));
EXPECT_EQ(2, callout_value_);
// Register some more callouts from different libraries on hook "alpha".
- getCalloutManager()->registerCallout(2, "alpha", manager_three);
- getCalloutManager()->registerCallout(2, "alpha", manager_four);
- getCalloutManager()->registerCallout(3, "alpha", manager_five);
+ getCalloutManager()->setLibraryIndex(2);
+ getCalloutManager()->registerCallout("alpha", manager_three);
+ getCalloutManager()->registerCallout("alpha", manager_four);
+ getCalloutManager()->setLibraryIndex(3);
+ getCalloutManager()->registerCallout("alpha", manager_five);
// Check it is as expected.
callout_value_ = 0;
EXPECT_EQ(0, status);
EXPECT_EQ(2, callout_value_);
- // Add another callout to hook "alpha" from library iindex 2 - this should
+ // Add another callout to hook "alpha" from library index 2 - this should
// appear at the end of the callout list for that library.
- getCalloutManager()->registerCallout(2, "alpha", manager_six);
+ getCalloutManager()->setLibraryIndex(2);
+ getCalloutManager()->registerCallout("alpha", manager_six);
callout_value_ = 0;
status = getCalloutManager()->callCallouts(alpha_index_,
getCalloutHandle());
// Add a callout from library index 1 - this should appear between the
// callouts from library index 0 and linrary index 2.
- getCalloutManager()->registerCallout(1, "alpha", manager_seven);
+ getCalloutManager()->setLibraryIndex(1);
+ getCalloutManager()->registerCallout("alpha", manager_seven);
callout_value_ = 0;
status = getCalloutManager()->callCallouts(alpha_index_,
getCalloutHandle());
EXPECT_EQ(0, status);
EXPECT_EQ(173465, callout_value_);
-
-
}
// Check the "calloutsPresent()" method.
// that some callouts are). Chose the libraries for which the callouts
// are registered randomly.
- getCalloutManager()->registerCallout(0, "alpha", manager_one);
+ getCalloutManager()->setLibraryIndex(0);
+ getCalloutManager()->registerCallout("alpha", manager_one);
- getCalloutManager()->registerCallout(1, "alpha", manager_two);
- getCalloutManager()->registerCallout(1, "beta", manager_two);
+ getCalloutManager()->setLibraryIndex(1);
+ getCalloutManager()->registerCallout("alpha", manager_two);
+ getCalloutManager()->registerCallout("beta", manager_two);
- getCalloutManager()->registerCallout(3, "alpha", manager_three);
- getCalloutManager()->registerCallout(3, "delta", manager_four);
+ getCalloutManager()->setLibraryIndex(3);
+ getCalloutManager()->registerCallout("alpha", manager_three);
+ getCalloutManager()->registerCallout("delta", manager_four);
// Check all is as expected.
EXPECT_TRUE(getCalloutManager()->calloutsPresent(alpha_index_));
// Each library contributes one callout on hook "alpha".
callout_value_ = 0;
- getCalloutManager()->registerCallout(0, "alpha", manager_one);
- getCalloutManager()->registerCallout(1, "alpha", manager_two);
- getCalloutManager()->registerCallout(2, "alpha", manager_three);
- getCalloutManager()->registerCallout(3, "alpha", manager_four);
+ getCalloutManager()->setLibraryIndex(1);
+ getCalloutManager()->registerCallout("alpha", manager_one);
+ getCalloutManager()->setLibraryIndex(1);
+ getCalloutManager()->registerCallout("alpha", manager_two);
+ getCalloutManager()->setLibraryIndex(2);
+ getCalloutManager()->registerCallout("alpha", manager_three);
+ getCalloutManager()->setLibraryIndex(3);
+ getCalloutManager()->registerCallout("alpha", manager_four);
status = getCalloutManager()->callCallouts(alpha_index_,
getCalloutHandle());
EXPECT_EQ(0, status);
// Do a random selection of callouts on hook "beta".
callout_value_ = 0;
- getCalloutManager()->registerCallout(0, "beta", manager_one);
- getCalloutManager()->registerCallout(0, "beta", manager_three);
- getCalloutManager()->registerCallout(1, "beta", manager_two);
- getCalloutManager()->registerCallout(3, "beta", manager_four);
+ getCalloutManager()->setLibraryIndex(0);
+ getCalloutManager()->registerCallout("beta", manager_one);
+ getCalloutManager()->registerCallout("beta", manager_three);
+ getCalloutManager()->setLibraryIndex(1);
+ getCalloutManager()->registerCallout("beta", manager_two);
+ getCalloutManager()->setLibraryIndex(3);
+ getCalloutManager()->registerCallout("beta", manager_four);
status = getCalloutManager()->callCallouts(beta_index_,
getCalloutHandle());
EXPECT_EQ(0, status);
// Each library contributing one callout on hook "alpha". The first callout
// returns an error (after adding its value to the result).
callout_value_ = 0;
- getCalloutManager()->registerCallout(0, "alpha", manager_one_error);
- getCalloutManager()->registerCallout(1, "alpha", manager_two);
- getCalloutManager()->registerCallout(2, "alpha", manager_three);
- getCalloutManager()->registerCallout(3, "alpha", manager_four);
+ getCalloutManager()->setLibraryIndex(0);
+ getCalloutManager()->registerCallout("alpha", manager_one_error);
+ getCalloutManager()->setLibraryIndex(1);
+ getCalloutManager()->registerCallout("alpha", manager_two);
+ getCalloutManager()->setLibraryIndex(2);
+ getCalloutManager()->registerCallout("alpha", manager_three);
+ getCalloutManager()->setLibraryIndex(3);
+ getCalloutManager()->registerCallout("alpha", manager_four);
status = getCalloutManager()->callCallouts(alpha_index_,
getCalloutHandle());
EXPECT_EQ(1, status);
// Each library contributing multiple callouts on hook "beta". The last
// callout on the first library returns an error.
callout_value_ = 0;
- getCalloutManager()->registerCallout(0, "beta", manager_one);
- getCalloutManager()->registerCallout(0, "beta", manager_one_error);
- getCalloutManager()->registerCallout(1, "beta", manager_two);
- getCalloutManager()->registerCallout(1, "beta", manager_two);
- getCalloutManager()->registerCallout(1, "beta", manager_three);
- getCalloutManager()->registerCallout(1, "beta", manager_three);
- getCalloutManager()->registerCallout(3, "beta", manager_four);
- getCalloutManager()->registerCallout(3, "beta", manager_four);
+ getCalloutManager()->setLibraryIndex(0);
+ getCalloutManager()->registerCallout("beta", manager_one);
+ getCalloutManager()->registerCallout("beta", manager_one_error);
+ getCalloutManager()->setLibraryIndex(1);
+ getCalloutManager()->registerCallout("beta", manager_two);
+ getCalloutManager()->registerCallout("beta", manager_two);
+ getCalloutManager()->registerCallout("beta", manager_three);
+ getCalloutManager()->registerCallout("beta", manager_three);
+ getCalloutManager()->setLibraryIndex(3);
+ getCalloutManager()->registerCallout("beta", manager_four);
+ getCalloutManager()->registerCallout("beta", manager_four);
status = getCalloutManager()->callCallouts(beta_index_,
getCalloutHandle());
EXPECT_EQ(1, status);
// A callout in a random position in the callout list returns an error.
callout_value_ = 0;
- getCalloutManager()->registerCallout(0, "gamma", manager_one);
- getCalloutManager()->registerCallout(0, "gamma", manager_one);
- getCalloutManager()->registerCallout(1, "gamma", manager_two);
- getCalloutManager()->registerCallout(1, "gamma", manager_two);
- getCalloutManager()->registerCallout(3, "gamma", manager_four_error);
- getCalloutManager()->registerCallout(3, "gamma", manager_four);
+ getCalloutManager()->setLibraryIndex(0);
+ getCalloutManager()->registerCallout("gamma", manager_one);
+ getCalloutManager()->registerCallout("gamma", manager_one);
+ getCalloutManager()->setLibraryIndex(1);
+ getCalloutManager()->registerCallout("gamma", manager_two);
+ getCalloutManager()->registerCallout("gamma", manager_two);
+ getCalloutManager()->setLibraryIndex(3);
+ getCalloutManager()->registerCallout("gamma", manager_four_error);
+ getCalloutManager()->registerCallout("gamma", manager_four);
status = getCalloutManager()->callCallouts(gamma_index_,
getCalloutHandle());
EXPECT_EQ(1, status);
// The last callout on a hook returns an error.
callout_value_ = 0;
- getCalloutManager()->registerCallout(0, "delta", manager_one);
- getCalloutManager()->registerCallout(0, "delta", manager_one);
- getCalloutManager()->registerCallout(1, "delta", manager_two);
- getCalloutManager()->registerCallout(1, "delta", manager_two);
- getCalloutManager()->registerCallout(2, "delta", manager_three);
- getCalloutManager()->registerCallout(2, "delta", manager_three);
- getCalloutManager()->registerCallout(3, "delta", manager_four);
- getCalloutManager()->registerCallout(3, "delta", manager_four_error);
+ getCalloutManager()->setLibraryIndex(0);
+ getCalloutManager()->registerCallout("delta", manager_one);
+ getCalloutManager()->registerCallout("delta", manager_one);
+ getCalloutManager()->setLibraryIndex(1);
+ getCalloutManager()->registerCallout("delta", manager_two);
+ getCalloutManager()->registerCallout("delta", manager_two);
+ getCalloutManager()->setLibraryIndex(2);
+ getCalloutManager()->registerCallout("delta", manager_three);
+ getCalloutManager()->registerCallout("delta", manager_three);
+ getCalloutManager()->setLibraryIndex(3);
+ getCalloutManager()->registerCallout("delta", manager_four);
+ getCalloutManager()->registerCallout("delta", manager_four_error);
status = getCalloutManager()->callCallouts(delta_index_,
getCalloutHandle());
EXPECT_EQ(1, status);
// Add a callout to hook "alpha" and check it is added correctly.
callout_value_ = 0;
- getCalloutManager()->registerCallout(0, "alpha", manager_two);
+ getCalloutManager()->setLibraryIndex(0);
+ getCalloutManager()->registerCallout("alpha", manager_two);
status = getCalloutManager()->callCallouts(alpha_index_,
getCalloutHandle());
EXPECT_EQ(0, status);
// Remove it and check that the no callouts are present.
EXPECT_TRUE(getCalloutManager()->calloutsPresent(alpha_index_));
- EXPECT_TRUE(getCalloutManager()->deregisterCallout(0, "alpha",
- manager_two));
+ EXPECT_TRUE(getCalloutManager()->deregisterCallout("alpha", manager_two));
EXPECT_FALSE(getCalloutManager()->calloutsPresent(alpha_index_));
}
// Add multiple callouts to hook "alpha".
callout_value_ = 0;
- getCalloutManager()->registerCallout(0, "alpha", manager_one);
- getCalloutManager()->registerCallout(0, "alpha", manager_two);
- getCalloutManager()->registerCallout(0, "alpha", manager_three);
- getCalloutManager()->registerCallout(0, "alpha", manager_four);
+ getCalloutManager()->setLibraryIndex(0);
+ getCalloutManager()->registerCallout("alpha", manager_one);
+ getCalloutManager()->registerCallout("alpha", manager_two);
+ getCalloutManager()->registerCallout("alpha", manager_three);
+ getCalloutManager()->registerCallout("alpha", manager_four);
status = getCalloutManager()->callCallouts(alpha_index_,
getCalloutHandle());
EXPECT_EQ(0, status);
EXPECT_EQ(1234, callout_value_);
// Remove the manager_two callout.
- EXPECT_TRUE(getCalloutManager()->deregisterCallout(0, "alpha",
- manager_two));
+ EXPECT_TRUE(getCalloutManager()->deregisterCallout("alpha", manager_two));
callout_value_ = 0;
status = getCalloutManager()->callCallouts(alpha_index_,
getCalloutHandle());
EXPECT_EQ(134, callout_value_);
// Try removing it again.
- EXPECT_FALSE(getCalloutManager()->deregisterCallout(0, "alpha",
- manager_two));
+ EXPECT_FALSE(getCalloutManager()->deregisterCallout("alpha", manager_two));
callout_value_ = 0;
status = getCalloutManager()->callCallouts(alpha_index_,
getCalloutHandle());
// Each library contributes one callout on hook "alpha".
callout_value_ = 0;
- getCalloutManager()->registerCallout(0, "alpha", manager_one);
- getCalloutManager()->registerCallout(0, "alpha", manager_two);
- getCalloutManager()->registerCallout(0, "alpha", manager_one);
- getCalloutManager()->registerCallout(0, "alpha", manager_two);
- getCalloutManager()->registerCallout(0, "alpha", manager_three);
- getCalloutManager()->registerCallout(0, "alpha", manager_four);
- getCalloutManager()->registerCallout(0, "alpha", manager_three);
- getCalloutManager()->registerCallout(0, "alpha", manager_four);
+ getCalloutManager()->setLibraryIndex(0);
+ getCalloutManager()->registerCallout("alpha", manager_one);
+ getCalloutManager()->registerCallout("alpha", manager_two);
+ getCalloutManager()->registerCallout("alpha", manager_one);
+ getCalloutManager()->registerCallout("alpha", manager_two);
+ getCalloutManager()->registerCallout("alpha", manager_three);
+ getCalloutManager()->registerCallout("alpha", manager_four);
+ getCalloutManager()->registerCallout("alpha", manager_three);
+ getCalloutManager()->registerCallout("alpha", manager_four);
status = getCalloutManager()->callCallouts(alpha_index_,
getCalloutHandle());
EXPECT_EQ(0, status);
EXPECT_EQ(12123434, callout_value_);
// Remove the manager_two callouts.
- EXPECT_TRUE(getCalloutManager()->deregisterCallout(0, "alpha",
- manager_two));
+ EXPECT_TRUE(getCalloutManager()->deregisterCallout("alpha", manager_two));
callout_value_ = 0;
status = getCalloutManager()->callCallouts(alpha_index_,
getCalloutHandle());
// Try removing multiple callouts that includes one at the end of the
// list of callouts.
- EXPECT_TRUE(getCalloutManager()->deregisterCallout(0, "alpha",
- manager_four));
+ EXPECT_TRUE(getCalloutManager()->deregisterCallout("alpha", manager_four));
callout_value_ = 0;
status = getCalloutManager()->callCallouts(alpha_index_,
getCalloutHandle());
EXPECT_EQ(1133, callout_value_);
// ... and from the start.
- EXPECT_TRUE(getCalloutManager()->deregisterCallout(0, "alpha",
- manager_one));
+ EXPECT_TRUE(getCalloutManager()->deregisterCallout("alpha", manager_one));
callout_value_ = 0;
status = getCalloutManager()->callCallouts(alpha_index_,
getCalloutHandle());
EXPECT_EQ(33, callout_value_);
// ... and the remaining callouts.
- EXPECT_TRUE(getCalloutManager()->deregisterCallout(0, "alpha",
- manager_three));
+ EXPECT_TRUE(getCalloutManager()->deregisterCallout("alpha", manager_three));
callout_value_ = 0;
status = getCalloutManager()->callCallouts(alpha_index_,
getCalloutHandle());
// Each library contributes two callouts to hook "alpha".
callout_value_ = 0;
- getCalloutManager()->registerCallout(0, "alpha", manager_one);
- getCalloutManager()->registerCallout(0, "alpha", manager_two);
- getCalloutManager()->registerCallout(1, "alpha", manager_three);
- getCalloutManager()->registerCallout(1, "alpha", manager_four);
- getCalloutManager()->registerCallout(2, "alpha", manager_five);
- getCalloutManager()->registerCallout(2, "alpha", manager_two);
+ getCalloutManager()->setLibraryIndex(0);
+ getCalloutManager()->registerCallout("alpha", manager_one);
+ getCalloutManager()->registerCallout("alpha", manager_two);
+ getCalloutManager()->setLibraryIndex(1);
+ getCalloutManager()->registerCallout("alpha", manager_three);
+ getCalloutManager()->registerCallout("alpha", manager_four);
+ getCalloutManager()->setLibraryIndex(2);
+ getCalloutManager()->registerCallout("alpha", manager_five);
+ getCalloutManager()->registerCallout("alpha", manager_two);
status = getCalloutManager()->callCallouts(alpha_index_,
getCalloutHandle());
EXPECT_EQ(0, status);
// Remove the manager_two callout from library 0. It should not affect
// the second manager_two callout registered by library 2.
- EXPECT_TRUE(getCalloutManager()->deregisterCallout(0, "alpha",
- manager_two));
+ getCalloutManager()->setLibraryIndex(0);
+ EXPECT_TRUE(getCalloutManager()->deregisterCallout("alpha", manager_two));
callout_value_ = 0;
status = getCalloutManager()->callCallouts(alpha_index_,
getCalloutHandle());
// Each library contributes two callouts to hook "alpha".
callout_value_ = 0;
- getCalloutManager()->registerCallout(0, "alpha", manager_one);
- getCalloutManager()->registerCallout(0, "alpha", manager_two);
- getCalloutManager()->registerCallout(1, "alpha", manager_three);
- getCalloutManager()->registerCallout(1, "alpha", manager_four);
- getCalloutManager()->registerCallout(2, "alpha", manager_five);
- getCalloutManager()->registerCallout(2, "alpha", manager_six);
+ getCalloutManager()->setLibraryIndex(0);
+ getCalloutManager()->registerCallout("alpha", manager_one);
+ getCalloutManager()->registerCallout("alpha", manager_two);
+ getCalloutManager()->setLibraryIndex(1);
+ getCalloutManager()->registerCallout("alpha", manager_three);
+ getCalloutManager()->registerCallout("alpha", manager_four);
+ getCalloutManager()->setLibraryIndex(2);
+ getCalloutManager()->registerCallout("alpha", manager_five);
+ getCalloutManager()->registerCallout("alpha", manager_six);
status = getCalloutManager()->callCallouts(alpha_index_,
getCalloutHandle());
EXPECT_EQ(0, status);
EXPECT_EQ(123456, callout_value_);
// Remove all callouts from library index 1.
- EXPECT_TRUE(getCalloutManager()->deregisterAllCallouts(1, "alpha"));
+ getCalloutManager()->setLibraryIndex(1);
+ EXPECT_TRUE(getCalloutManager()->deregisterAllCallouts("alpha"));
callout_value_ = 0;
status = getCalloutManager()->callCallouts(alpha_index_,
getCalloutHandle());
EXPECT_EQ(1256, callout_value_);
// Remove all callouts from library index 2.
- EXPECT_TRUE(getCalloutManager()->deregisterAllCallouts(2, "alpha"));
+ getCalloutManager()->setLibraryIndex(2);
+ EXPECT_TRUE(getCalloutManager()->deregisterAllCallouts("alpha"));
callout_value_ = 0;
status = getCalloutManager()->callCallouts(alpha_index_,
getCalloutHandle());
EXPECT_EQ(12, callout_value_);
}
+// Library handle tests. As by inspection the LibraryHandle can be seen to be
+// little more than shell around CalloutManager, only a basic set of tests
+// is done concerning registration and deregistration of functions.
+//
+// More extensive tests (i.e. checking that when a callout is called it can
+// only register and deregister callouts within its library) require that
+// the CalloutHandle object pass the appropriate LibraryHandle to the
+// callout. These tests are done in the CalloutHandle tests.
+
+TEST_F(CalloutManagerTest, LibraryHandleRegistration) {
+ // Ensure that no callouts are attached to any of the hooks.
+ EXPECT_FALSE(getCalloutManager()->calloutsPresent(alpha_index_));
+
+ // Set up so that hooks "alpha" and "beta" have callouts attached from a
+ // different libraries.
+ getCalloutManager()->setLibraryIndex(0);
+ getCalloutManager()->getLibraryHandle().registerCallout("alpha",
+ manager_one);
+ getCalloutManager()->getLibraryHandle().registerCallout("alpha",
+ manager_two);
+ getCalloutManager()->setLibraryIndex(1);
+ getCalloutManager()->getLibraryHandle().registerCallout("alpha",
+ manager_three);
+ getCalloutManager()->getLibraryHandle().registerCallout("alpha",
+ manager_four);
+
+ // Check all is as expected.
+ EXPECT_TRUE(getCalloutManager()->calloutsPresent(alpha_index_));
+ EXPECT_FALSE(getCalloutManager()->calloutsPresent(beta_index_));
+ EXPECT_FALSE(getCalloutManager()->calloutsPresent(gamma_index_));
+ EXPECT_FALSE(getCalloutManager()->calloutsPresent(delta_index_));
+
+ int status = 0;
+
+ // Check that calling the callouts returns as expected. (This is also a
+ // test of the callCallouts method.)
+ callout_value_ = 0;
+ status = getCalloutManager()->callCallouts(alpha_index_,
+ getCalloutHandle());
+ EXPECT_EQ(0, status);
+ EXPECT_EQ(1234, callout_value_);
+
+ // Deregister a callout on library index 0 (after we check we can't
+ // deregister it through library index 1).
+ getCalloutManager()->setLibraryIndex(1);
+ EXPECT_FALSE(getCalloutManager()->deregisterCallout("alpha", manager_two));
+ callout_value_ = 0;
+ status = getCalloutManager()->callCallouts(alpha_index_,
+ getCalloutHandle());
+ EXPECT_EQ(0, status);
+ EXPECT_EQ(1234, callout_value_);
+
+ getCalloutManager()->setLibraryIndex(0);
+ EXPECT_TRUE(getCalloutManager()->deregisterCallout("alpha", manager_two));
+ callout_value_ = 0;
+ status = getCalloutManager()->callCallouts(alpha_index_,
+ getCalloutHandle());
+ EXPECT_EQ(0, status);
+ EXPECT_EQ(134, callout_value_);
+
+ // Deregister all callouts on library index 1.
+ getCalloutManager()->setLibraryIndex(1);
+ EXPECT_TRUE(getCalloutManager()->deregisterAllCallouts("alpha"));
+ callout_value_ = 0;
+ status = getCalloutManager()->callCallouts(alpha_index_,
+ getCalloutHandle());
+ EXPECT_EQ(0, status);
+ EXPECT_EQ(1, callout_value_);
+}
+
+
} // Anonymous namespace
+++ /dev/null
-// Copyright (C) 2013 Internet Systems Consortium, Inc. ("ISC")
-//
-// Permission to use, copy, modify, and/or distribute this software for any
-// purpose with or without fee is hereby granted, provided that the above
-// copyright notice and this permission notice appear in all copies.
-//
-// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
-// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
-// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
-// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-// PERFORMANCE OF THIS SOFTWARE.
-
-#include <util/hooks/callout_handle.h>
-#include <util/hooks/library_handle.h>
-#include <util/hooks/server_hooks.h>
-
-#include <gtest/gtest.h>
-
-#include <algorithm>
-#include <string>
-#include <vector>
-
-using namespace isc::util;
-using namespace std;
-
-namespace {
-
-class LibraryHandleTest : public ::testing::Test {
-public:
- /// @brief Constructor
- ///
- /// Sets up an appropriate number of server hooks to pass to the
- /// constructed callout handle objects.
- LibraryHandleTest() : hooks_(new ServerHooks()) {
- hooks_->registerHook("alpha");
- hooks_->registerHook("beta");
- hooks_->registerHook("gamma");
- collection_.reset(new LibraryHandleCollection(hooks_));
-
- // Also initialize the variable used to pass information back from the
- // callouts to the tests.
- callout_value = 0;
- }
-
- /// Obtain constructed server hooks.
- boost::shared_ptr<ServerHooks>& getServerHooks() {
- return (hooks_);
- }
-
- /// Obtain constructed hook manager.
- boost::shared_ptr<LibraryHandleCollection>& getLibraryHandleCollection() {
- return (collection_);
- }
-
- /// Variable for callouts test. This is public and static to allow non-
- /// member functions to access it. It is initialized every time a new
- /// test starts.
- static int callout_value;
-
-private:
- boost::shared_ptr<ServerHooks> hooks_;
- boost::shared_ptr<LibraryHandleCollection> collection_;
- boost::shared_ptr<LibraryHandle> handle_0_;
- boost::shared_ptr<LibraryHandle> handle_1_;
-};
-
-// Definition of the static variable.
-int LibraryHandleTest::callout_value = 0;
-
-// The next set of tests check that callouts can be registered.
-
-// The callouts defined here are structured in such a way that it is possible
-// to determine the order in which they are called and whether they are called
-// at all. The method used is simple - after a sequence of callouts, the digits
-// in the value, reading left to right, determines the order of the callouts
-// called. For example, callout one followed by two followed by three followed
-// by two followed by one results in a value of 12321.
-//
-// Functions return a zero to indicate success.
-
-extern "C" {
-int one(CalloutHandle&) {
- LibraryHandleTest::callout_value =
- 10 * LibraryHandleTest::callout_value + 1;
- return (0);
-}
-
-int two(CalloutHandle&) {
- LibraryHandleTest::callout_value =
- 10 * LibraryHandleTest::callout_value + 2;
- return (0);
-}
-
-int three(CalloutHandle&) {
- LibraryHandleTest::callout_value =
- 10 * LibraryHandleTest::callout_value + 3;
- return (0);
-}
-
-// The next function is a duplicate of "one", but returns an error status.
-
-int one_error(CalloutHandle& handle) {
- static_cast<void>(one(handle));
- return (1);
-}
-
-// The next function is a duplicate of "one", but sets the skip flag.
-
-int one_skip(CalloutHandle& handle) {
- handle.setSkip(true);
- return (one(handle));
-}
-
-}; // extern "C"
-
-// Check that we can register callouts on a particular hook.
-
-TEST_F(LibraryHandleTest, RegisterSingleCallout) {
- LibraryHandle handle(getServerHooks());
-
- // Register callouts for hooks alpha and see that it is registered.
- EXPECT_FALSE(handle.calloutsPresent(getServerHooks()->getIndex("alpha")));
- handle.registerCallout("alpha", one);
- EXPECT_TRUE(handle.calloutsPresent(getServerHooks()->getIndex("alpha")));
-
- // Do the same for beta (which checks that the hooks are independent).
- EXPECT_FALSE(handle.calloutsPresent(getServerHooks()->getIndex("beta")));
- handle.registerCallout("beta", one);
- EXPECT_TRUE(handle.calloutsPresent(getServerHooks()->getIndex("beta")));
-}
-
-// Check that we can call a single callout on a particular hook. Refer to the
-// above definition of the callouts "one" and "two" to understand the expected
-// return values.
-
-TEST_F(LibraryHandleTest, CallSingleCallout) {
- LibraryHandle handle(getServerHooks());
-
- // Register callout for hook alpha...
- EXPECT_FALSE(handle.calloutsPresent(getServerHooks()->getIndex("alpha")));
- handle.registerCallout("alpha", one);
- EXPECT_TRUE(handle.calloutsPresent(getServerHooks()->getIndex("alpha")));
-
- // Call it.
- EXPECT_EQ(0, LibraryHandleTest::callout_value);
-
- int index = getServerHooks()->getIndex("alpha");
- CalloutHandle callout_handle(getLibraryHandleCollection());
- int status = handle.callCallouts(index, callout_handle);
-
- EXPECT_EQ(0, status);
- EXPECT_EQ(1, LibraryHandleTest::callout_value);
-
-}
-
-// Check that we can register two callouts for a hook and that they are called
-// in order.
-
-TEST_F(LibraryHandleTest, TwoCallouts) {
- LibraryHandle handle(getServerHooks());
-
- // Register two callouts for hook alpha.
- handle.registerCallout("alpha", one);
- handle.registerCallout("alpha", two);
-
- // Call them.
- EXPECT_EQ(0, LibraryHandleTest::callout_value);
-
- int index = getServerHooks()->getIndex("alpha");
- CalloutHandle callout_handle(getLibraryHandleCollection());
- int status = handle.callCallouts(index, callout_handle);
-
- EXPECT_EQ(0, status);
- EXPECT_EQ(12, LibraryHandleTest::callout_value);
-}
-
-// Check that we can register two callouts for a hook and that the second is not
-// called if the first returns a non-zero status.
-
-TEST_F(LibraryHandleTest, TwoCalloutsWithError) {
- LibraryHandle handle(getServerHooks());
-
- // Register callout for hook alpha...
- handle.registerCallout("alpha", one_error);
- handle.registerCallout("alpha", two);
-
- // Call them.
- EXPECT_EQ(0, LibraryHandleTest::callout_value);
-
- int index = getServerHooks()->getIndex("alpha");
- CalloutHandle callout_handle(getLibraryHandleCollection());
- int status = handle.callCallouts(index, callout_handle);
-
- EXPECT_EQ(1, status);
- EXPECT_EQ(1, LibraryHandleTest::callout_value);
-}
-
-// Check that we can register two callouts for a hook and that the second is not
-// called if the first szets the callout "skip" flag.
-
-TEST_F(LibraryHandleTest, TwoCalloutsWithSkip) {
- LibraryHandle handle(getServerHooks());
-
- // Register callout for hook alpha.
- handle.registerCallout("alpha", one_skip);
- handle.registerCallout("alpha", two);
-
- // Call them.
- EXPECT_EQ(0, LibraryHandleTest::callout_value);
-
- int index = getServerHooks()->getIndex("alpha");
- CalloutHandle callout_handle(getLibraryHandleCollection());
- int status = handle.callCallouts(index, callout_handle);
-
- EXPECT_EQ(0, status);
- EXPECT_EQ(1, LibraryHandleTest::callout_value);
-}
-
-// Check that a callout can be registered more than once.
-
-TEST_F(LibraryHandleTest, MultipleRegistration) {
- LibraryHandle handle(getServerHooks());
-
- // Register callouts for hook alpha.
- handle.registerCallout("alpha", one);
- handle.registerCallout("alpha", two);
- handle.registerCallout("alpha", one);
-
- // Call them.
- EXPECT_EQ(0, LibraryHandleTest::callout_value);
-
- int index = getServerHooks()->getIndex("alpha");
- CalloutHandle callout_handle(getLibraryHandleCollection());
- int status = handle.callCallouts(index, callout_handle);
-
- EXPECT_EQ(0, status);
- EXPECT_EQ(121, LibraryHandleTest::callout_value);
-}
-
-// Check that a callout can be deregistered.
-
-TEST_F(LibraryHandleTest, Deregister) {
- LibraryHandle handle(getServerHooks());
-
- // Register callouts for hook alpha...
- handle.registerCallout("alpha", one);
- handle.registerCallout("alpha", two);
- handle.registerCallout("alpha", one);
-
- // Get rid of all the "one" callbacks.
- handle.deregisterCallout("alpha", one);
-
- // Call it.
- EXPECT_EQ(0, LibraryHandleTest::callout_value);
-
- int index = getServerHooks()->getIndex("alpha");
- CalloutHandle callout_handle(getLibraryHandleCollection());
- int status = handle.callCallouts(index, callout_handle);
-
- EXPECT_EQ(0, status);
- EXPECT_EQ(2, LibraryHandleTest::callout_value);
-}
-
-// Check that all callouts can be deregistered.
-
-TEST_F(LibraryHandleTest, DeregisterAll) {
- LibraryHandle handle(getServerHooks());
-
- // Register callouts for hook alpha...
- EXPECT_FALSE(handle.calloutsPresent(getServerHooks()->getIndex("alpha")));
- handle.registerCallout("alpha", one);
- handle.registerCallout("alpha", two);
- EXPECT_TRUE(handle.calloutsPresent(getServerHooks()->getIndex("alpha")));
-
- // ... and remove them.
- handle.deregisterAll("alpha");
- EXPECT_FALSE(handle.calloutsPresent(getServerHooks()->getIndex("alpha")));
-}
-
-// Add checks that invalid names etc. all throw. With the base hooks added
-// by the constructor, there are five valid hooks, with valid indexes 0 to 4.
-
-TEST_F(LibraryHandleTest, InvalidNameAndIndex) {
- LibraryHandle handle(getServerHooks());
-
- EXPECT_THROW(handle.registerCallout("omega", one), NoSuchHook);
- EXPECT_THROW(handle.deregisterCallout("omega", one), NoSuchHook);
- EXPECT_THROW(handle.deregisterAll("omega"), NoSuchHook);
-
- EXPECT_THROW(static_cast<void>(handle.calloutsPresent(-1)), NoSuchHook);
- EXPECT_THROW(static_cast<void>(handle.calloutsPresent(5)), NoSuchHook);
-
- CalloutHandle callout_handle(getLibraryHandleCollection());
- EXPECT_THROW(static_cast<void>(handle.callCallouts(-1, callout_handle)),
- NoSuchHook);
- EXPECT_THROW(static_cast<void>(handle.callCallouts(10, callout_handle)),
- NoSuchHook);
-}
-
-
-} // Anonymous namespace
projects / thirdparty / kea.git / commitdiff
