Add base class unit test to enhance coverage (#1828)

Jürgen Knödlseder
1 parent d7f7af88
Showing 12 changed files with 668 additions and 225 deletions
pyext/ctlikelihood.i
pyext/ctobservation.i
pyext/ctool.i
src/ctulimit/ctulimit.par
src/support/ctlikelihood.hpp
src/support/ctobservation.hpp
src/support/ctool.cpp
test/test_cscript.py
test/test_ctskymap.py
test/test_ctulimit.py
test/test_python_cscripts.py
test/test_python_ctools.py
@@ -26,9 +26,44 @@
  
 %{
 /* Put headers and other declarations here that are needed for compilation */
+#define SWIG
 #include "ctlikelihood.hpp"
+
+
+/***********************************************************************//**
+ * @class cslikelihood
+ *
+ * @brief cslikelihood base class
+ *
+ * This class is a non-abstract C++ implementation of the ctlikelihood base
+ * class. It serves as Python base class since Python does not know about
+ * abstract classes.
+ ***************************************************************************/
+class cslikelihood : public ctlikelihood  {
+public:
+    // Constructors and destructors
+    cslikelihood(const std::string& name, const std::string& version) :
+                 ctlikelihood(name, version) {}
+    cslikelihood(const std::string& name, const std::string& version,
+                 const GObservations& obs) :
+                 ctlikelihood(name, version, obs) {}
+    cslikelihood(const std::string& name, const std::string& version,
+                 int argc, char* argv[]) :
+                 ctlikelihood(name, version, argc, argv){}
+    cslikelihood(const cslikelihood& app) : ctlikelihood(app) {}
+    virtual ~cslikelihood(void) {}
+
+    // Dummy methods (implementation makes this class non-abstract)
+    virtual void clear(void) {}
+    virtual void run(void) {}
+    virtual void save(void) {}
+};
 %}
  
+// Include (int ARGC, char **ARGV) typemap to allow passing command line
+// arguments to GApplication constructor
+%include "argcargv.i"
+
  
 /***********************************************************************//**
  * @class ctlikelihood
@@ -54,11 +89,65 @@ public:
  
     // Methods
     const GOptimizer* opt(void) const;
+
+    // Make methods private in Python by prepending an underscore
+    %rename(_evaluate) evaluate;
+
+    // Protected methods
+    double evaluate(GModelPar& par, const double& value);
+};
+
+
+/***********************************************************************//**
+ * @class cslikelihood
+ *
+ * @brief Base class for likelihood scripts
+ *
+ * This is the base class from which likelihood scripts should derive.
+ ***************************************************************************/
+class cslikelihood : public ctlikelihood  {
+public:        
+    // Constructors and destructors
+    cslikelihood(const std::string& name, const std::string& version);
+    cslikelihood(const std::string& name, const std::string& version,
+                 const GObservations& obs);
+    cslikelihood(const std::string& name, const std::string& version,
+                 int ARGC, char **ARGV);
+    cslikelihood(const cslikelihood& app);
+    virtual ~cslikelihood(void);
+
+    // Methods
+    virtual void clear(void);
+    virtual void run(void);
+    virtual void save(void);
 };
  
  
 /***********************************************************************//**
- * @brief Likelihood tool Python extensions
+ * @brief Likelihood tool base class C++ extensions
  ***************************************************************************/
 %extend ctlikelihood {
 }
+
+
+/***********************************************************************//**
+ * @brief Likelihood tool base class Python extensions
+ ***************************************************************************/
+%pythoncode %{
+
+# Initialise application by calling the appropriate base class constructor.
+# The function supports either an observation container, or an argument
+# list or no argument as "argv" parameter. The function also writes the
+# header in the log file and switches the date on for logging.
+def _init_cslikelihood(self, argv):
+    if len(argv) > 0 and isinstance(argv[0],gammalib.GObservations):
+        cslikelihood.__init__(self, self._name, self._version, argv[0])
+    elif len(argv) > 0:
+        cslikelihood.__init__(self, self._name, self._version, *argv)
+    else:
+        cslikelihood.__init__(self, self._name, self._version)
+    # Set logger properties
+    self._log_header()
+    self._log.date(True)
+cslikelihood._init_cslikelihood = _init_cslikelihood
+%}
@@ -26,14 +26,49 @@
  
 %{
 /* Put headers and other declarations here that are needed for compilation */
+#define SWIG
 #include "ctobservation.hpp"
+
+
+/***********************************************************************//**
+ * @class csobservation
+ *
+ * @brief csobservation base class
+ *
+ * This class is a non-abstract C++ implementation of the ctobservation base
+ * class. It serves as Python base class since Python does not know about
+ * abstract classes.
+ ***************************************************************************/
+class csobservation : public ctobservation  {
+public:
+    // Constructors and destructors
+    csobservation(const std::string& name, const std::string& version) :
+                  ctobservation(name, version) {}
+    csobservation(const std::string& name, const std::string& version,
+                  const GObservations& obs) :
+                  ctobservation(name, version, obs) {}
+    csobservation(const std::string& name, const std::string& version,
+                  int argc, char* argv[]) :
+                  ctobservation(name, version, argc, argv){}
+    csobservation(const csobservation& app) : ctobservation(app) {}
+    virtual ~csobservation(void) {}
+
+    // Dummy methods (implementation makes this class non-abstract)
+    virtual void clear(void) {}
+    virtual void run(void) {}
+    virtual void save(void) {}
+};
 %}
  
+// Include (int ARGC, char **ARGV) typemap to allow passing command line
+// arguments to GApplication constructor
+%include "argcargv.i"
+
  
 /***********************************************************************//**
  * @class ctobservation
  *
- * @brief Base class for likelihood tools
+ * @brief Base class for observation tools
  ***************************************************************************/
 class ctobservation : public ctool {
  
@@ -43,7 +78,7 @@ public:
     ctobservation(const std::string& name, const std::string& version,
                   const GObservations& obs);
     ctobservation(const std::string& name, const std::string& version,
-                  int argc, char* argv[]);
+                  int ARGC, char **ARGV);
     ctobservation(const ctobservation& app);
     virtual ~ctobservation(void);
  
@@ -66,6 +101,31 @@ public:
  
  
 /***********************************************************************//**
+ * @class csobservation
+ *
+ * @brief Base class for observation scripts
+ *
+ * This is the base class from which observation scripts should derive.
+ ***************************************************************************/
+class csobservation : public ctobservation  {
+public:        
+    // Constructors and destructors
+    csobservation(const std::string& name, const std::string& version);
+    csobservation(const std::string& name, const std::string& version,
+                  const GObservations& obs);
+    csobservation(const std::string& name, const std::string& version,
+                  int ARGC, char **ARGV);
+    csobservation(const csobservation& app);
+    virtual ~csobservation(void);
+
+    // Methods
+    virtual void clear(void);
+    virtual void run(void);
+    virtual void save(void);
+};
+
+
+/***********************************************************************//**
  * @brief Observation tool base class C++ extensions
  ***************************************************************************/
 %extend ctobservation {
@@ -76,6 +136,24 @@ public:
  * @brief Observation tool base class Python extensions
  ***************************************************************************/
 %pythoncode %{
+
+# Initialise application by calling the appropriate base class constructor.
+# The function supports either an observation container, or an argument
+# list or no argument as "argv" parameter. The function also writes the
+# header in the log file and switches the date on for logging.
+def _init_csobservation(self, argv):
+    if len(argv) > 0 and isinstance(argv[0],gammalib.GObservations):
+        csobservation.__init__(self, self._name, self._version, argv[0])
+    elif len(argv) > 0:
+        csobservation.__init__(self, self._name, self._version, *argv)
+    else:
+        csobservation.__init__(self, self._name, self._version)
+    # Set logger properties
+    self._log_header()
+    self._log.date(True)
+csobservation._init_csobservation = _init_csobservation
+
+# Define an iterator over all observations
 def _unbinned_observations(self):
     obs = self._first_unbinned_observation()
     while obs != None:
@@ -86,12 +86,12 @@ public:
     %rename(_time_reference)           time_reference;
     %rename(_get_observations)         get_observations;
     %rename(_setup_observations)       setup_observations;
+    %rename(_setup_models)             setup_models;
     %rename(_create_ebounds)           create_ebounds;
     %rename(_create_map)               create_map;
     %rename(_create_cube)              create_cube;
     %rename(_create_cta_obs)           create_cta_obs;
     %rename(_require_inobs)            require_inobs;
-    %rename(_require_inobs_nolist)     require_inobs_nolist;
     %rename(_require_inobs_nocube)     require_inobs_nocube;
     %rename(_log_observations)         log_observations;
     %rename(_log_models)               log_models;
@@ -128,9 +128,11 @@ public:
  
     // Protected methods that check user parameters
     void            require_inobs(const std::string& method);
-    void            require_inobs_nolist(const std::string& method);
     void            require_inobs_nocube(const std::string& method);
  
+    // Protected methods that extract user parameters
+    GCTARoi         get_roi(void);
+
     // Protected methods for logging
     void            log_observations(const GChatter&      chatter,
                                      const GObservations& obs,
@@ -139,9 +141,6 @@ public:
                                const GModels&     models,
                                const std::string& what = "Model");
  
-    // Protected methods that extract user parameters
-    GCTARoi           get_roi(void);
-
     // Protected support methods
     void              set_response(GObservations& obs);
     std::vector<bool> set_edisp(GObservations& obs, const bool& edisp) const;
@@ -38,7 +38,7 @@ eref,       r, h, 1.0,,, &quot;Reference energy for differential limit (TeV)&quot;
 emin,       r, h, 1.0,,, "Minimum energy for integral flux limit (TeV)"
 emax,       r, h, 100.0,,, "Maximum energy for integral flux limit (TeV)"
 tol,        r, h, 1e-5,,, "Computation tolerance"
-max_iter,   i, h, 50,,, "Maximum number of iterations"
+max_iter,   i, h, 50,1,1000, "Maximum number of iterations"
  
 #
 # Standard parameters
@@ -61,15 +61,20 @@ public:
     // Methods
     const GOptimizer* opt(void) const;
  
+#ifndef SWIG
+protected:
+#endif
+    // Protected methods in C++, public in SWIG interface
+    double evaluate(GModelPar& par, const double& value);
+
 protected:
     // Protected methods
     void   init_members(void);
     void   copy_members(const ctlikelihood& app);
     void   free_members(void);
-    double evaluate(GModelPar& par, const double& value);
  
     // Protected members
-    GOptimizerLM m_opt; //!< Optimizer
+    GOptimizerLM m_opt;   //!< Optimizer
 };
  
  
@@ -64,9 +64,7 @@ public:
     // Methods
     const GObservations& obs(void) const;
  
-#ifdef SWIG
-public:
-#else
+#ifndef SWIG
 protected:
 #endif
     // Iterator methods and members
@@ -549,10 +549,10 @@ GEbounds ctool::create_ebounds(void)
                 file.close();
                 std::string msg = "No extension with name \"EBOUNDS\" or"
                                   " \"ENERGYBINS\" found in FITS file"
-                                  " \""+ebinfile+"\".\n"
-                                  "An \"EBOUNDS\" or \"ENERGYBINS\" extension"
-                                  " is required if the parameter \"ebinalg\""
-                                  " is set to \"FILE\".";
+                                  " \""+ebinfile+"\". An \"EBOUNDS\" or "
+                                  "\"ENERGYBINS\" extension is required if "
+                                  "the parameter \"ebinalg\" is set to "
+                                  "\"FILE\".";
                 throw GException::invalid_value(G_CREATE_EBOUNDS, msg);
             }
         }
@@ -788,6 +788,9 @@ GCTAObservation ctool::create_cta_obs(void)
  *
  * Throw an exception if the "inobs" parameter is either "NONE" or an empty
  * string.
+ *
+ * @todo This method is only used by csobsinfo, csresmap and csspec. We
+ * should try to get rid of it
  ***************************************************************************/
 void ctool::require_inobs(const std::string& method)
 {
@@ -810,63 +813,13 @@ void ctool::require_inobs(const std::string&amp; method)
  
  
 /***********************************************************************//**
- * @brief Throws exception if inobs parameter is an event list
- *
- * @param[in] method Method name.
- *
- * Throw an exception if the inobs parameter is an event list.
- ***************************************************************************/
-void ctool::require_inobs_nolist(const std::string& method)
-{
-    // Get inobs filename
-    GFilename filename = (*this)["inobs"].filename();
-
-    // Continue only if we have a FITS file
-    if (filename.is_fits()) {
-
-        // Signal no list
-        bool is_list = false;
-    
-        // Try loading file as counts cube. If this is successful then
-        // throw an exception
-        try {
-
-            // Load list from file
-            GCTAEventList list(filename);
-
-            // If we're still alive then signal that we have a list
-            is_list = true;
-
-        }
-
-        // Catch any exceptions
-        catch (...) {
-            ;
-        }
-
-        // If we have an event list then throw an exception
-        if (is_list) {
-            std::string msg = "An event list has been specified for the "
-                              "\"inobs\" parameter, yet no event list "
-                              "can be specified as input observation."
-                              " Instead, specify a counts cube or an "
-                              "observation definition file.";
-            throw GException::invalid_value(method, msg);
-        }
-    
-    } // endif: we had a FITS file
-    
-    // Return
-    return;
-}
-
-
-/***********************************************************************//**
  * @brief Throws exception if inobs parameter is a counts cube
  *
  * @param[in] method Method name.
  *
  * Throw an exception if the inobs parameter is a counts cube.
+ *
+ * @todo This method is only used by ctobssim. We should try to get rid of it
  ***************************************************************************/
 void ctool::require_inobs_nocube(const std::string& method)
 {
@@ -1542,6 +1495,9 @@ GSkyDir ctool::get_mean_pointing(const GObservations&amp; obs)
  * @brief Get current resident set size (physical memory use) in Bytes
  *
  * @return Physical memory use in Bytes.
+ *
+ * @todo This method is currently not used and can be removed if we do not
+ *       use it
  ***************************************************************************/
 size_t ctool::get_current_rss(void)
 {
+#! /usr/bin/env python
+# ==========================================================================
+# This scripts performs unit tests for the cspull script.
+#
+# Copyright (C) 2016 Juergen Knoedlseder
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# ==========================================================================
+import gammalib
+import ctools
+from testing import test
+
+
+# ================== #
+# cscript_test class #
+# ================== #
+class cscript_test(ctools.cscript):
+    """
+    Test class for the cscript base class
+    """
+    # Constructor
+    def __init__(self, *argv):
+        """
+        Constructor
+        """
+        # Set name
+        self._name    = 'cscript_test'
+        self._version = '1.2.0'
+
+        # Initialise observation container from constructor arguments
+        self._obs, argv = self._set_input_obs(argv)
+
+        # Initialise application by calling the appropriate class constructor
+        self._init_cscript(argv)
+
+        # Return
+        return
+
+    # Check is_valid_filename() method
+    def _check_is_valid_filename(self, filename):
+        return self._is_valid_filename(gammalib.GFilename(filename))
+
+    # Check setup_observations() method
+    def _check_setup_observations(self, filename, list=True, cube=True):
+        self.pars()['inobs'].value(filename)
+        obs = gammalib.GObservations()
+        self._setup_observations(obs, True, list, cube)
+        return
+
+    # Check setup_models() method
+    def _check_setup_models(self):
+        obs = gammalib.GObservations()
+        self._setup_models(obs)
+        return
+
+    # Check create_ebounds() method
+    def _check_create_ebounds(self, filename):
+        self.pars()['ebinfile'].value(filename)
+        return self._create_ebounds()
+
+    # Check require_inobs() method
+    def _check_require_inobs(self, filename):
+        self.pars()['inobs'].value(filename)
+        self._require_inobs('_check_require_inobs')
+        return
+
+    # Check get_roi() method
+    def _check_get_roi(self):
+        return self._get_roi()
+
+    # Check restore_edisp() method
+    def _check_restore_edisp(self):
+        obs   = gammalib.GObservations()
+        edisp = [True, True]
+        self._restore_edisp(obs, edisp)
+        return
+
+    # Check set_obs_bounds() method
+    def _check_set_obs_bounds(self):
+        obs  = gammalib.GObservations()
+        list = gammalib.GCTAEventList()
+        cta  = gammalib.GCTAObservation()
+        cta.events(list)
+        obs.append(cta)
+        self._set_obs_bounds(obs)
+        return obs.copy()
+
+    # Check get_mean_pointing() method
+    def _check_get_mean_pointing(self):
+        obs = gammalib.GObservations()
+        return self._get_mean_pointing(obs)
+
+
+# ======================== #
+# ctobservation_test class #
+# ======================== #
+class ctobservation_test(ctools.csobservation):
+    """
+    Test class for the ctobservation base class
+    """
+    # Constructor
+    def __init__(self, *argv):
+        """
+        Constructor
+        """
+        # Set name
+        self._name    = 'ctobservation_test'
+        self._version = '1.2.0'
+
+        # Initialise application by calling the appropriate class constructor
+        self._init_csobservation(argv)
+
+        # Return
+        return
+
+
+# ======================= #
+# ctlikelihood_test class #
+# ======================= #
+class ctlikelihood_test(ctools.cslikelihood):
+    """
+    Test class for the ctlikelihood base class
+    """
+    # Constructor
+    def __init__(self, *argv):
+        """
+        Constructor
+        """
+        # Set name
+        self._name    = 'ctlikelihood_test'
+        self._version = '1.2.0'
+
+        # Initialise application by calling the appropriate class constructor
+        self._init_cslikelihood(argv)
+
+        # Return
+        return
+
+    # Check evaluate() method
+    def _check_evaluate(self, value):
+        par = gammalib.GModelPar()
+        par.value(2.0)
+        par.range(1.0, 3.0)
+        return self._evaluate(par, value)
+
+
+# ============================ #
+# Test class for base classes  #
+# ============================ #
+class Test(test):
+    """
+    Test class for base classes
+    """
+    # Constructor
+    def __init__(self):
+        """
+        Constructor
+        """
+        # Call base class constructor
+        test.__init__(self)
+
+        # Create parameter file for cscript_test application
+        pars = gammalib.GApplicationPars()
+        pars.append(gammalib.GApplicationPar('inobs','f','h','NONE','','',''))
+        pars.append(gammalib.GApplicationPar('inmodel','f','h','NONE','','',''))
+        pars.append(gammalib.GApplicationPar('ebinalg','s','h','FILE','','',''))
+        pars.append(gammalib.GApplicationPar('ebinfile','f','h','NONE','','',''))
+        pars.append(gammalib.GApplicationPar('ra','r','h','NONE','','',''))
+        pars.append(gammalib.GApplicationPar('dec','r','h','NONE','','',''))
+        pars.append(gammalib.GApplicationPar('rad','r','h','1.0','','',''))
+        pars.append(gammalib.GApplicationPar('emin','r','h','1.0','','',''))
+        pars.append(gammalib.GApplicationPar('emax','r','h','10.0','','',''))
+        pars.append_standard()
+        pars.save('cscript_test.par')
+
+        # Create parameter file for ctobservation_test.par application
+        pars = gammalib.GApplicationPars()
+        pars.append_standard()
+        pars.save('ctobservation_test.par')
+
+        # Create parameter file for ctlikelihood_test application
+        pars = gammalib.GApplicationPars()
+        pars.append_standard()
+        pars.save('ctlikelihood_test.par')
+
+        # Create energy boundaries file
+        ebounds = gammalib.GEbounds(1, gammalib.GEnergy(1.0,'TeV'),
+                                       gammalib.GEnergy(10.0,'TeV'))
+        ebounds.save('test_ebinfile_ebounds.fits[EBOUNDS]', True)
+        ebounds.save('test_ebinfile_energybins.fits[ENERGYBINS]', True)
+        ebounds.save('test_ebinfile_energies.fits[ENERGIES]', True)
+
+        # Return
+        return
+
+    # Set test functions
+    def set(self):
+        """
+        Set all test functions
+        """
+        # Set test name
+        self.name('cscript')
+
+        # Append tests
+        self.append(self._test_cscript, 'Test cscript base class')
+        self.append(self._test_ctobservation, 'Test ctobservation base class')
+        self.append(self._test_ctlikelihood, 'Test ctlikelihood base class')
+
+        # Return
+        return
+
+    # Test cscript base class
+    def _test_cscript(self):
+        """
+        Test cscript base class
+        """
+        # Allocate empty
+        empty = cscript_test()
+
+        # Test is_valid_filename() method
+        self.test_assert(empty._check_is_valid_filename(self._model),
+                         'Check model definiton XML file')
+        self.test_assert(not empty._check_is_valid_filename(''),
+                         'Check empty filename')
+        self.test_assert(not empty._check_is_valid_filename('NONE'),
+                         'Check "NONE" filename')
+
+        # Test setup_observations() for invalid file name
+        self.test_try('Check setup_observations() for "NONE"')
+        try:
+            empty._check_setup_observations('NONE')
+            self.test_try_failure('Exception not thrown')
+        except ValueError:
+            self.test_try_success()
+
+        # Test setup_observations() for unacceptable event list
+        self.test_try('Check setup_observations() for unacceptable event list')
+        try:
+            empty._check_setup_observations(self._events, list=False)
+            self.test_try_failure('Exception not thrown')
+        except ValueError:
+            self.test_try_success()
+
+        # Test setup_observations() for unacceptable counts cube
+        self.test_try('Check setup_observations() for unacceptable counts cube')
+        try:
+            empty._check_setup_observations(self._cntcube, cube=False)
+            self.test_try_failure('Exception not thrown')
+        except ValueError:
+            self.test_try_success()
+
+        # Test setup_models() for invalid model definition file name
+        self.test_try('Check setup_models() for invalid model definition file name')
+        try:
+            empty._check_setup_models()
+            self.test_try_failure('Exception not thrown')
+        except ValueError:
+            self.test_try_success()
+
+        # Test create_ebounds() method for "EBOUNDS" extension
+        ebounds = empty._check_create_ebounds('test_ebinfile_ebounds.fits')
+        self.test_value(ebounds.size(), 1, 'Check number of energy boundaries')
+        self.test_value(ebounds.emin().TeV(), 1.0, 'Check minimum energy')
+        self.test_value(ebounds.emax().TeV(), 10.0, 'Check maximum energy')
+
+        # Test create_ebounds() method for "ENERGYBINS" extension
+        ebounds = empty._check_create_ebounds('test_ebinfile_energybins.fits')
+        self.test_value(ebounds.size(), 1, 'Check number of energy boundaries')
+        self.test_value(ebounds.emin().TeV(), 1.0, 'Check minimum energy')
+        self.test_value(ebounds.emax().TeV(), 10.0, 'Check maximum energy')
+
+        # Test create_ebounds() method for invalid extension
+        self.test_try('Check create_ebounds() method for invalid extension')
+        try:
+            empty._check_create_ebounds('test_ebinfile_energies.fits')
+            self.test_try_failure('Exception not thrown')
+        except ValueError:
+            self.test_try_success()
+
+        # Test require_inobs() method for invalid file name
+        self.test_try('Check require_inobs() method for invalid file name')
+        try:
+            empty._check_require_inobs('NONE')
+            self.test_try_failure('Exception not thrown')
+        except ValueError:
+            self.test_try_success()
+
+        # Test get_roi() method
+        roi = empty._check_get_roi()
+        self.test_assert(not roi.is_valid(), 'Check get_roi() method')
+
+        # Test restore_edisp() method for invalid vector size
+        #self.test_try('Check restore_edisp() method for invalid vector size')
+        #try:
+        #    empty._check_restore_edisp()
+        #    self.test_try_failure('Exception not thrown')
+        #except ValueError:
+        #    self.test_try_success()
+        #
+        # NOTE: This code does not work because of a missing list to
+        #       integer vector conversion.
+
+        # Test set_obs_bounds() method
+        obs = empty._check_set_obs_bounds()
+        self.test_value(obs.size(), 1, 'Check number of observations')
+        self.test_value(obs[0].events().ebounds().size(), 1,
+                        'Check number of energy boundaries')
+        self.test_value(obs[0].events().ebounds().emin().TeV(), 1.0,
+                        'Check minimum energy')
+        self.test_value(obs[0].events().ebounds().emax().TeV(), 10.0,
+                        'Check maximum energy')
+        self.test_value(obs[0].events().roi().radius(), 1.0,
+                        'Check RoI radius')
+
+        # Test get_mean_pointing() method for empty observation container
+        self.test_try('Check get_mean_pointing() method for empty observation '
+                      'container')
+        try:
+            empty._check_get_mean_pointing()
+            self.test_try_failure('Exception not thrown')
+        except ValueError:
+            self.test_try_success()
+
+        # Return
+        return
+
+    # Test ctobservation base class
+    def _test_ctobservation(self):
+        """
+        Test ctobservation base class
+        """
+        # Allocate empty
+        empty = ctobservation_test()
+
+        # Test first_unbinned_observation() method
+        self.test_assert(empty._first_unbinned_observation() is None,
+                         'Check first_unbinned_observation() method')
+
+        # Test next_unbinned_observation() method
+        self.test_assert(empty._next_unbinned_observation() is None,
+                         'Check next_unbinned_observation() method')
+
+        # Return
+        return
+
+    # Test ctlikelihood base class
+    def _test_ctlikelihood(self):
+        """
+        Test ctlikelihood base class
+        """
+        # Allocate empty
+        empty = ctlikelihood_test()
+
+        # Test evaluate() method for minimum value violation
+        self.test_try('Check evaluate() for minimum value violation')
+        try:
+            empty._check_evaluate(0.0)
+            self.test_try_failure('Exception not thrown')
+        except ValueError:
+            self.test_try_success()
+
+        # Test evaluate() method for maximum value violation
+        self.test_try('Check evaluate() for maximum value violation')
+        try:
+            empty._check_evaluate(4.0)
+            self.test_try_failure('Exception not thrown')
+        except ValueError:
+            self.test_try_success()
+
+        # Return
+        return
@@ -181,10 +181,10 @@ class Test(test):
         skymap['nxpix']    = 200
         skymap['nypix']    = 200
         skymap['binsz']    = 0.02
-        skymap['coordsys'] = 'CEL'
+        skymap['coordsys'] = 'GAL'
         skymap['proj']     = 'CAR'
-        skymap['xref']     = 83.63
-        skymap['yref']     = 22.01
+        skymap['xref']     = 184.5575
+        skymap['yref']     =  -5.7844
         skymap['outmap']   = 'ctskymap_py3.fits'
         skymap['logfile']  = 'ctskymap_py3.log'
         skymap['chatter']  = 4
@@ -111,6 +111,7 @@ class Test(test):
                         'Check upper limit on energy flux')
  
         # Check that saving does not nothing
+        ulimit['logfile'] = 'ctulimit_py0.log'
         ulimit.logFileOpen()
         ulimit.save()
  
@@ -157,13 +158,6 @@ class Test(test):
         self.test_value(cpy_ulimit.eflux_ulimit(), 2.75669e-11, 1.0e-16,
                         'Check upper limit on energy flux')
  
-        # Execute copy of ctulimit tool again, now with a higher chatter
-        # level than before
-        cpy_ulimit['logfile'] = 'ctulimit_py2.log'
-        cpy_ulimit['chatter'] = 3
-        cpy_ulimit.logFileOpen()  # Needed to get a new log file
-        cpy_ulimit.execute()
-
         # Check results
         self.test_value(cpy_ulimit.diff_ulimit(), 8.86803e-18, 1.0e-21,
                         'Check differential upper limit')
@@ -172,9 +166,6 @@ class Test(test):
         self.test_value(cpy_ulimit.eflux_ulimit(), 2.75669e-11, 1.0e-16,
                         'Check upper limit on energy flux')
  
-        # Save copy of observation container for later
-        obs = cpy_ulimit.obs().copy()
-
         # Now clear copy of ctulimit tool
         cpy_ulimit.clear()
  
@@ -186,13 +177,21 @@ class Test(test):
         self.test_value(cpy_ulimit.eflux_ulimit(), 0.0, 1.0e-16,
                         'Check upper limit on energy flux')
  
-        # Now set ctulimit tool using the observation container from last
-        # time. This should avoid the necessity to recompute the maximum
-        # likelihood
-        ulimit = ctools.ctulimit(obs)
+        # Run ctlike to get an initial log-likelihood solution
+        like = ctools.ctlike()
+        like['inobs']    = self._events
+        like['inmodel']  = self._model
+        like['caldb']    = self._caldb
+        like['irf']      = self._irf
+        like.run()
+
+        # Now set ctulimit tool using the observation container from the
+        # previous run. This should avoid the necessity to recompute the
+        # maximum likelihood
+        ulimit = ctools.ctulimit(like.obs())
         ulimit['srcname'] = 'Crab'
-        ulimit['logfile'] = 'ctulimit_py3.log'
-        ulimit['chatter'] = 4
+        ulimit['logfile'] = 'ctulimit_py2.log'
+        ulimit['chatter'] = 3
  
         # Execute ctulimit tool
         ulimit.logFileOpen()  # Needed to get a new log file
@@ -207,11 +206,11 @@ class Test(test):
                         'Check upper limit on energy flux')
  
         # Test invalid model name
+        ulimit['srcname'] = 'Weihnachtsstern'
+        ulimit['logfile'] = 'ctulimit_py3.log'
+        ulimit.logFileOpen()
         self.test_try('Test invalid model name')
         try:
-            ulimit['srcname'] = 'Weihnachtsstern'
-            ulimit['logfile'] = 'ctulimit_py4.log'
-            ulimit.logFileOpen()
             ulimit.execute()
             self.test_try_failure('Exception not thrown')
         except ValueError:
@@ -219,7 +218,7 @@ class Test(test):
  
         # Test specification of background model
         ulimit['srcname'] = 'Background'
-        ulimit['logfile'] = 'ctulimit_py5.log'
+        ulimit['logfile'] = 'ctulimit_py4.log'
         ulimit.logFileOpen()
         self.test_try('Test invalid model name')
         try:
@@ -228,6 +227,18 @@ class Test(test):
         except ValueError:
             self.test_try_success()
  
+        # Test run with too few iterations
+        ulimit['srcname']  = 'Crab'
+        ulimit['max_iter'] = 1
+        ulimit['logfile']  = 'ctulimit_py5.log'
+        ulimit.logFileOpen()
+        self.test_try('Test ctulimit with too few iterations')
+        try:
+            ulimit.execute()
+            self.test_try_failure('Exception not thrown')
+        except ValueError:
+            self.test_try_success()
+
         # Return
         return
  
@@ -23,6 +23,7 @@ import sys
 import gammalib
 import cscripts
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+import test_cscript
 import test_cscaldb
 import test_csfindobs
 import test_csinfo
@@ -105,65 +106,25 @@ def test(installed=False, debug=False):
         os.system('cp -r %s/syspfiles/*.par pfiles/' % (os.environ['CTOOLS']))
         os.system('chmod u+w pfiles/*')
  
-    # Allocate test suite container
-    suites = gammalib.GTestSuites('cscripts unit testing')
-
-    # Allocate test suites
-    suite_cscaldb      = test_cscaldb.Test()
-    suite_csinfo       = test_csinfo.Test()
-    suite_cslightcrv   = test_cslightcrv.Test()
-    suite_csmodelinfo  = test_csmodelinfo.Test()
-    suite_csmodelmerge = test_csmodelmerge.Test()
-    suite_csobs2caldb  = test_csobs2caldb.Test()
-    suite_csobsdef     = test_csobsdef.Test()
-    suite_csobsinfo    = test_csobsinfo.Test()
-    suite_cspull       = test_cspull.Test()
-    suite_csresmap     = test_csresmap.Test()
-    suite_csroot2caldb = test_csroot2caldb.Test()
-    suite_cssens       = test_cssens.Test()
-    suite_csspec       = test_csspec.Test()
-    suite_cstsdist     = test_cstsdist.Test()
-    suite_cstsmapmerge = test_cstsmapmerge.Test()
-    suite_cstsmapsplit = test_cstsmapsplit.Test()
-    suite_csworkflow   = test_csworkflow.Test()
-
-    # Setup unit tests
-    suite_cscaldb.set()
-    suite_csinfo.set()
-    suite_cslightcrv.set()
-    suite_csmodelinfo.set()
-    suite_csmodelmerge.set()
-    suite_csobs2caldb.set()
-    suite_csobsdef.set()
-    suite_csobsinfo.set()
-    suite_cspull.set()
-    suite_csresmap.set()
-    suite_csroot2caldb.set()
-    suite_cssens.set()
-    suite_csspec.set()
-    suite_cstsdist.set()
-    suite_cstsmapmerge.set()
-    suite_cstsmapsplit.set()
-    suite_csworkflow.set()
-
-    # Append tests to container
-    suites.append(suite_cscaldb)
-    suites.append(suite_csinfo)
-    suites.append(suite_cslightcrv)
-    suites.append(suite_csmodelinfo)
-    suites.append(suite_csmodelmerge)
-    suites.append(suite_csobs2caldb)
-    suites.append(suite_csobsdef)
-    suites.append(suite_csobsinfo)
-    suites.append(suite_cspull)
-    suites.append(suite_csresmap)
-    suites.append(suite_csroot2caldb)
-    suites.append(suite_cssens)
-    suites.append(suite_csspec)
-    suites.append(suite_cstsdist)
-    suites.append(suite_cstsmapmerge)
-    suites.append(suite_cstsmapsplit)
-    suites.append(suite_csworkflow)
+    # Define list of test suites
+    tests = [test_cscript.Test(),
+             test_cscaldb.Test(),
+             test_csinfo.Test(),
+             test_cslightcrv.Test(),
+             test_csmodelinfo.Test(),
+             test_csmodelmerge.Test(),
+             test_csobs2caldb.Test(),
+             test_csobsdef.Test(),
+             test_csobsinfo.Test(),
+             test_cspull.Test(),
+             test_csresmap.Test(),
+             test_csroot2caldb.Test(),
+             test_cssens.Test(),
+             test_csspec.Test(),
+             test_cstsdist.Test(),
+             test_cstsmapmerge.Test(),
+             test_cstsmapsplit.Test(),
+             test_csworkflow.Test()]
  
     # Append tests for Python 2.6+ (the IACT cscripts depend on the json
     # module which is only available since Python 2.6+)
@@ -178,23 +139,19 @@ def test(installed=False, debug=False):
             # impact the environment variable in the parent shell.
             del os.environ['VHEFITS']
  
-        # Allocate test suites
-        suite_csfindobs  = test_csfindobs.Test()
-        suite_csiactcopy = test_csiactcopy.Test()
-        suite_csiactdata = test_csiactdata.Test()
-        suite_csiactobs  = test_csiactobs.Test()
-
-        # Setup unit tests
-        suite_csfindobs.set()
-        suite_csiactcopy.set()
-        suite_csiactdata.set()
-        suite_csiactobs.set()
-
-        # Append tests to container
-        suites.append(suite_csfindobs)
-        suites.append(suite_csiactcopy)
-        suites.append(suite_csiactdata)
-        suites.append(suite_csiactobs)
+        # Append IACT script tests to list of test suites
+        tests.extend([test_csfindobs.Test(),
+                      test_csiactcopy.Test(),
+                      test_csiactdata.Test(),
+                      test_csiactobs.Test()])
+
+    # Allocate test suite container
+    suites = gammalib.GTestSuites('cscripts unit testing')
+
+    # Set test suites and append them to suite container
+    for suite in tests:
+        suite.set()
+        suites.append(suite)
  
     # Run test suite
     success = suites.run()
@@ -99,65 +99,32 @@ def test(installed=False):
         os.system('cp -r %s/syspfiles/*.par pfiles/' % (os.environ['CTOOLS']))
         os.system('chmod u+w pfiles/*')
  
+    # Define list of test suites
+    tests = [test_ctobssim.Test(),
+             test_ctselect.Test(),
+             test_ctbin.Test(),
+             test_ctlike.Test(),
+             test_cttsmap.Test(),
+             test_ctmodel.Test(),
+             test_ctskymap.Test(),
+             test_ctexpcube.Test(),
+             test_ctpsfcube.Test(),
+             test_ctedispcube.Test(),
+             test_ctbkgcube.Test(),
+             test_ctmapcube.Test(),
+             test_ctcubemask.Test(),
+             test_ctbutterfly.Test(),
+             test_ctulimit.Test(),
+             test_cterror.Test(),
+             test_pipelines.Test()]
+
     # Allocate test suite container
     suites = gammalib.GTestSuites('ctools unit testing')
  
-    # Allocate test suites and append them to the container
-    suite_ctobssim    = test_ctobssim.Test()
-    suite_ctselect    = test_ctselect.Test()
-    suite_ctbin       = test_ctbin.Test()
-    suite_ctlike      = test_ctlike.Test()
-    suite_cttsmap     = test_cttsmap.Test()
-    suite_ctmodel     = test_ctmodel.Test()
-    suite_ctskymap    = test_ctskymap.Test()
-    suite_ctexpcube   = test_ctexpcube.Test()
-    suite_ctpsfcube   = test_ctpsfcube.Test()
-    suite_ctedispcube = test_ctedispcube.Test()
-    suite_ctbkgcube   = test_ctbkgcube.Test()
-    suite_ctmapcube   = test_ctmapcube.Test()
-    suite_ctcubemask  = test_ctcubemask.Test()
-    suite_ctbutterfly = test_ctbutterfly.Test()
-    suite_ctulimit    = test_ctulimit.Test()
-    suite_cterror     = test_cterror.Test()
-    suite_pipelines   = test_pipelines.Test()
-
-    # Setup unit tests
-    suite_ctobssim.set()
-    suite_ctselect.set()
-    suite_ctbin.set()
-    suite_ctlike.set()
-    suite_cttsmap.set()
-    suite_ctmodel.set()
-    suite_ctskymap.set()
-    suite_ctexpcube.set()
-    suite_ctpsfcube.set()
-    suite_ctedispcube.set()
-    suite_ctbkgcube.set()
-    suite_ctmapcube.set()
-    suite_ctcubemask.set()
-    suite_ctbutterfly.set()
-    suite_ctulimit.set()
-    suite_cterror.set()
-    suite_pipelines.set()
-
-    # Append tests to container
-    suites.append(suite_ctobssim)
-    suites.append(suite_ctselect)
-    suites.append(suite_ctbin)
-    suites.append(suite_ctlike)
-    suites.append(suite_cttsmap)
-    suites.append(suite_ctmodel)
-    suites.append(suite_ctskymap)
-    suites.append(suite_ctexpcube)
-    suites.append(suite_ctpsfcube)
-    suites.append(suite_ctedispcube)
-    suites.append(suite_ctbkgcube)
-    suites.append(suite_ctmapcube)
-    suites.append(suite_ctcubemask)
-    suites.append(suite_ctbutterfly)
-    suites.append(suite_ctulimit)
-    suites.append(suite_cterror)
-    suites.append(suite_pipelines)
+    # Set test suites and append them to suite container
+    for suite in tests:
+        suite.set()
+        suites.append(suite)
  
     # Run test suite
     success = suites.run()