diff --git a/easybuild/framework/easyblock.py b/easybuild/framework/easyblock.py
index 89140e1903..fc639432e9 100644
--- a/easybuild/framework/easyblock.py
+++ b/easybuild/framework/easyblock.py
@@ -2409,37 +2409,71 @@ def _sanity_check_step_common(self, custom_paths, custom_commands):
             SANITY_CHECK_PATHS_DIRS: ("(non-empty) directory", lambda dp: os.path.isdir(dp) and os.listdir(dp)),
         }
 
-        # prepare sanity check paths
-        paths = self.cfg['sanity_check_paths']
-        if not paths:
+        enhance_sanity_check = self.cfg['enhance_sanity_check']
+        ec_commands = self.cfg['sanity_check_commands']
+        ec_paths = self.cfg['sanity_check_paths']
+
+        # if enhance_sanity_check is not enabled, only sanity_check_paths specified in the easyconfig file are used,
+        # the ones provided by the easyblock (via custom_paths) are ignored
+        if ec_paths and not enhance_sanity_check:
+            paths = ec_paths
+            self.log.info("Using (only) sanity check paths specified by easyconfig file: %s", paths)
+        else:
+            # if no sanity_check_paths are specified in easyconfig,
+            # we fall back to the ones provided by the easyblock via custom_paths
             if custom_paths:
                 paths = custom_paths
-                self.log.info("Using customized sanity check paths: %s" % paths)
+                self.log.info("Using customized sanity check paths: %s", paths)
+            # if custom_paths is empty, we fall back to a generic set of paths:
+            # non-empty bin/ + /lib or /lib64 directories
             else:
                 paths = {}
                 for key in path_keys_and_check:
                     paths.setdefault(key, [])
                 paths.update({SANITY_CHECK_PATHS_DIRS: ['bin', ('lib', 'lib64')]})
-                self.log.info("Using default sanity check paths: %s" % paths)
+                self.log.info("Using default sanity check paths: %s", paths)
+
+            # if enhance_sanity_check is enabled *and* sanity_check_paths are specified in the easyconfig,
+            # those paths are used to enhance the paths provided by the easyblock
+            if enhance_sanity_check and ec_paths:
+                for key in ec_paths:
+                    val = ec_paths[key]
+                    if isinstance(val, list):
+                        paths[key] = paths.get(key, []) + val
+                    else:
+                        error_pattern = "Incorrect value type in sanity_check_paths, should be a list: "
+                        error_pattern += "%s (type: %s)" % (val, type(val))
+                        raise EasyBuildError(error_pattern)
+                self.log.info("Enhanced sanity check paths after taking into account easyconfig file: %s", paths)
+
+        sorted_keys = sorted(paths.keys())
+        known_keys = sorted(path_keys_and_check.keys())
+
+        # verify sanity_check_paths value: only known keys, correct value types, at least one non-empty value
+        only_list_values = all(isinstance(x, list) for x in paths.values())
+        only_empty_lists = all(not x for x in paths.values())
+        if sorted_keys != known_keys or not only_list_values or only_empty_lists:
+            error_msg = "Incorrect format for sanity_check_paths: should (only) have %s keys, "
+            error_msg += "values should be lists (at least one non-empty)."
+            raise EasyBuildError(error_msg % ', '.join("'%s'" % k for k in known_keys))
+
+        # if enhance_sanity_check is not enabled, only sanity_check_commands specified in the easyconfig file are used,
+        # the ones provided by the easyblock (via custom_commands) are ignored
+        if ec_commands and not enhance_sanity_check:
+            commands = ec_commands
+            self.log.info("Using (only) sanity check commands specified by easyconfig file: %s", commands)
         else:
-            self.log.info("Using specified sanity check paths: %s" % paths)
-
-        ks = sorted(paths.keys())
-        valnottypes = [not isinstance(x, list) for x in paths.values()]
-        lenvals = [len(x) for x in paths.values()]
-        req_keys = sorted(path_keys_and_check.keys())
-        if not ks == req_keys or sum(valnottypes) > 0 or sum(lenvals) == 0:
-            raise EasyBuildError("Incorrect format for sanity_check_paths (should (only) have %s keys, "
-                                 "values should be lists (at least one non-empty)).", ','.join(req_keys))
-
-        commands = self.cfg['sanity_check_commands']
-        if not commands:
             if custom_commands:
                 commands = custom_commands
-                self.log.info("Using customised sanity check commands: %s" % commands)
+                self.log.info("Using customised sanity check commands: %s", commands)
             else:
                 commands = []
-                self.log.info("Using specified sanity check commands: %s" % commands)
+
+            # if enhance_sanity_check is enabled, the sanity_check_commands specified in the easyconfig file
+            # are combined with those provided by the easyblock via custom_commands
+            if enhance_sanity_check and ec_commands:
+                commands = commands + ec_commands
+                self.log.info("Enhanced sanity check commands after taking into account easyconfig file: %s", commands)
 
         for i, command in enumerate(commands):
             # set command to default. This allows for config files with
@@ -2475,9 +2509,17 @@ def _sanity_check_step_dry_run(self, custom_paths=None, custom_commands=None, **
         """
         paths, path_keys_and_check, commands = self._sanity_check_step_common(custom_paths, custom_commands)
 
-        for key, (typ, _) in path_keys_and_check.items():
+        for key in [SANITY_CHECK_PATHS_FILES, SANITY_CHECK_PATHS_DIRS]:
+            (typ, _) = path_keys_and_check[key]
             self.dry_run_msg("Sanity check paths - %s ['%s']", typ, key)
-            if paths[key]:
+            entries = paths[key]
+            if entries:
+                # some entries may be tuple values,
+                # we need to convert them to strings first so we can print them sorted
+                for idx, entry in enumerate(entries):
+                    if isinstance(entry, tuple):
+                        entries[idx] = ' or '.join(entry)
+
                 for path in sorted(paths[key]):
                     self.dry_run_msg("  * %s", str(path))
             else:
@@ -2608,6 +2650,9 @@ def xs2str(xs):
 
         # run sanity check commands
         for command in commands:
+
+            trace_msg("running command '%s' ..." % command)
+
             out, ec = run_cmd(command, simple=False, log_ok=False, log_all=False, trace=False)
             if ec != 0:
                 fail_msg = "sanity check command %s exited with code %s (output: %s)" % (command, ec, out)
@@ -2616,7 +2661,7 @@ def xs2str(xs):
             else:
                 self.log.info("sanity check command %s ran successfully! (output: %s)" % (command, out))
 
-            trace_msg("running command '%s': %s" % (command, ('FAILED', 'OK')[ec == 0]))
+            trace_msg("result for command '%s': %s" % (command, ('FAILED', 'OK')[ec == 0]))
 
         # also run sanity check for extensions (unless we are an extension ourselves)
         if not extension:
diff --git a/easybuild/framework/easyconfig/default.py b/easybuild/framework/easyconfig/default.py
index 920e27d1bd..1fe7c705b6 100644
--- a/easybuild/framework/easyconfig/default.py
+++ b/easybuild/framework/easyconfig/default.py
@@ -90,6 +90,8 @@
     'easyblock': [None, "EasyBlock to use for building; if set to None, an easyblock is selected "
                         "based on the software name", BUILD],
     'easybuild_version': [None, "EasyBuild-version this spec-file was written for", BUILD],
+    'enhance_sanity_check': [False, "Indicate that additional sanity check commands & paths should enhance "
+                             "the existin sanity check, not replace it", BUILD],
     'fix_perl_shebang_for': [None, "List of files for which Perl shebang should be fixed "
                                    "to '#!/usr/bin/env perl' (glob patterns supported)", BUILD],
     'fix_python_shebang_for': [None, "List of files for which Python shebang should be fixed "
diff --git a/easybuild/framework/easyconfig/format/one.py b/easybuild/framework/easyconfig/format/one.py
index 88d043bc61..350afdbb6c 100644
--- a/easybuild/framework/easyconfig/format/one.py
+++ b/easybuild/framework/easyconfig/format/one.py
@@ -97,6 +97,13 @@ class FormatOneZero(EasyConfigFormatConfigObj):
     PYHEADER_MANDATORY = ['version', 'name', 'toolchain', 'homepage', 'description']
     PYHEADER_BLACKLIST = []
 
+    def __init__(self, *args, **kwargs):
+        """FormatOneZero constructor."""
+        super(FormatOneZero, self).__init__(*args, **kwargs)
+
+        self.log = fancylogger.getLogger(self.__class__.__name__, fname=False)
+        self.strict_sanity_check_paths_keys = True
+
     def validate(self):
         """Format validation"""
         # minimal checks
@@ -168,11 +175,14 @@ def _reformat_line(self, param_name, param_val, outer=False, addlen=0):
                     for item_key in ordered_item_keys:
                         if item_key in param_val:
                             item_val = param_val[item_key]
+                            item_comments = self._get_item_comments(param_name, item_val)
+                        elif param_name == 'sanity_check_paths' and not self.strict_sanity_check_paths_keys:
+                            item_val = []
+                            item_comments = {}
+                            self.log.info("Using default value for '%s' in sanity_check_paths: %s", item_key, item_val)
                         else:
                             raise EasyBuildError("Missing mandatory key '%s' in %s.", item_key, param_name)
 
-                        item_comments = self._get_item_comments(param_name, item_val)
-
                         inline_comment = item_comments.get('inline', '')
                         item_tmpl_dict = {'inline_comment': inline_comment}
 
@@ -317,6 +327,10 @@ def dump(self, ecfg, default_values, templ_const, templ_val, toolchain_hierarchy
         :param templ_val: known template values
         :param toolchain_hierarchy: hierarchy of toolchains for easyconfig
         """
+        # figoure out whether we should be strict about the format of sanity_check_paths;
+        # if enhance_sanity_check is set, then both files/dirs keys are not strictly required...
+        self.strict_sanity_check_paths_keys = not ecfg['enhance_sanity_check']
+
         # include header comments first
         dump = self.comments['header'][:]
 
diff --git a/easybuild/tools/filetools.py b/easybuild/tools/filetools.py
index d1f23d1ebe..ab33933e8e 100644
--- a/easybuild/tools/filetools.py
+++ b/easybuild/tools/filetools.py
@@ -40,7 +40,6 @@
 """
 import datetime
 import difflib
-import distutils.dir_util
 import fileinput
 import glob
 import hashlib
@@ -499,7 +498,13 @@ def pypi_source_urls(pkg_name):
         _log.debug("Failed to download %s to determine available PyPI URLs for %s", simple_url, pkg_name)
         res = []
     else:
-        parsed_html = ElementTree.parse(urls_html)
+        urls_txt = read_file(urls_html)
+
+        # ignore yanked releases (see https://pypi.org/help/#yanked)
+        # see https://github.com/easybuilders/easybuild-framework/issues/3301
+        urls_txt = re.sub(r'<a.*?data-yanked.*?</a>', '', urls_txt)
+
+        parsed_html = ElementTree.ElementTree(ElementTree.fromstring(urls_txt))
         if hasattr(parsed_html, 'iter'):
             res = [a.attrib['href'] for a in parsed_html.iter('a')]
         else:
@@ -762,6 +767,18 @@ def find_easyconfigs(path, ignore_dirs=None):
     return files
 
 
+def find_glob_pattern(glob_pattern, fail_on_no_match=True):
+    """Find unique file/dir matching glob_pattern (raises error if more than one match is found)"""
+    if build_option('extended_dry_run'):
+        return glob_pattern
+    res = glob.glob(glob_pattern)
+    if len(res) == 0 and not fail_on_no_match:
+        return None
+    if len(res) != 1:
+        raise EasyBuildError("Was expecting exactly one match for '%s', found %d: %s", glob_pattern, len(res), res)
+    return res[0]
+
+
 def search_file(paths, query, short=False, ignore_dirs=None, silent=False, filename_only=False, terse=False,
                 case_sensitive=False):
     """
@@ -2008,7 +2025,12 @@ def copy_file(path, target_path, force_in_dry_run=False):
                 _log.info("Copied contents of file %s to %s", path, target_path)
             else:
                 mkdir(os.path.dirname(target_path), parents=True)
-                shutil.copy2(path, target_path)
+                if os.path.exists(path):
+                    shutil.copy2(path, target_path)
+                elif os.path.islink(path):
+                    # special care for copying broken symlinks
+                    link_target = os.readlink(path)
+                    symlink(link_target, target_path)
                 _log.info("%s copied to %s", path, target_path)
         except (IOError, OSError, shutil.Error) as err:
             raise EasyBuildError("Failed to copy file %s to %s: %s", path, target_path, err)
@@ -2043,16 +2065,13 @@ def copy_dir(path, target_path, force_in_dry_run=False, dirs_exist_ok=False, **k
     :param path: the original directory path
     :param target_path: path to copy the directory to
     :param force_in_dry_run: force running the command during dry run
-    :param dirs_exist_ok: wrapper around shutil.copytree option, which was added in Python 3.8
+    :param dirs_exist_ok: boolean indicating whether it's OK if the target directory already exists
 
-    On Python >= 3.8 shutil.copytree is always used
-    On Python < 3.8 if 'dirs_exist_ok' is False - shutil.copytree is used
-    On Python < 3.8 if 'dirs_exist_ok' is True - distutils.dir_util.copy_tree is used
+    shutil.copytree is used if the target path does not exist yet;
+    if the target path already exists, the 'copy' function will be used to copy the contents of
+    the source path to the target path
 
-    Additional specified named arguments are passed down to shutil.copytree if used.
-
-    Because distutils.dir_util.copy_tree supports only 'symlinks' named argument,
-    using any other will raise EasyBuildError.
+    Additional specified named arguments are passed down to shutil.copytree/copy if used.
     """
     if not force_in_dry_run and build_option('extended_dry_run'):
         dry_run_msg("copied directory %s to %s" % (path, target_path))
@@ -2061,38 +2080,49 @@ def copy_dir(path, target_path, force_in_dry_run=False, dirs_exist_ok=False, **k
             if not dirs_exist_ok and os.path.exists(target_path):
                 raise EasyBuildError("Target location %s to copy %s to already exists", target_path, path)
 
-            if sys.version_info >= (3, 8):
-                # on Python >= 3.8, shutil.copytree works fine, thanks to availability of dirs_exist_ok named argument
-                shutil.copytree(path, target_path, dirs_exist_ok=dirs_exist_ok, **kwargs)
+            # note: in Python >= 3.8 shutil.copytree works just fine thanks to the 'dirs_exist_ok' argument,
+            # but since we need to be more careful in earlier Python versions we use our own implementation
+            # in case the target directory exists and 'dirs_exist_ok' is enabled
+            if dirs_exist_ok and os.path.exists(target_path):
+                # if target directory already exists (and that's allowed via dirs_exist_ok),
+                # we need to be more careful, since shutil.copytree will fail (in Python < 3.8)
+                # if target directory already exists;
+                # so, recurse via 'copy' function to copy files/dirs in source path to target path
+                # (NOTE: don't use distutils.dir_util.copy_tree here, see
+                # https://github.com/easybuilders/easybuild-framework/issues/3306)
+
+                entries = os.listdir(path)
 
-            elif dirs_exist_ok:
-                # use distutils.dir_util.copy_tree with Python < 3.8 if dirs_exist_ok is enabled
+                # take into account 'ignore' function that is supported by shutil.copytree
+                # (but not by 'copy_file' function used by 'copy')
+                ignore = kwargs.get('ignore')
+                if ignore:
+                    ignored_entries = ignore(path, entries)
+                    entries = [x for x in entries if x not in ignored_entries]
 
-                # first get value for symlinks named argument (if any)
-                preserve_symlinks = kwargs.pop('symlinks', False)
+                # determine list of paths to copy
+                paths_to_copy = [os.path.join(path, x) for x in entries]
 
-                # check if there are other named arguments (there shouldn't be, only 'symlinks' is supported)
-                if kwargs:
-                    raise EasyBuildError("Unknown named arguments passed to copy_dir with dirs_exist_ok=True: %s",
-                                         ', '.join(sorted(kwargs.keys())))
-                distutils.dir_util.copy_tree(path, target_path, preserve_symlinks=preserve_symlinks)
+                copy(paths_to_copy, target_path,
+                     force_in_dry_run=force_in_dry_run, dirs_exist_ok=dirs_exist_ok, **kwargs)
 
             else:
-                # if dirs_exist_ok is not enabled, just use shutil.copytree
+                # if dirs_exist_ok is not enabled or target directory doesn't exist, just use shutil.copytree
                 shutil.copytree(path, target_path, **kwargs)
 
             _log.info("%s copied to %s", path, target_path)
-        except (IOError, OSError) as err:
+        except (IOError, OSError, shutil.Error) as err:
             raise EasyBuildError("Failed to copy directory %s to %s: %s", path, target_path, err)
 
 
-def copy(paths, target_path, force_in_dry_run=False):
+def copy(paths, target_path, force_in_dry_run=False, **kwargs):
     """
     Copy single file/directory or list of files and directories to specified location
 
     :param paths: path(s) to copy
     :param target_path: target location
     :param force_in_dry_run: force running the command during dry run
+    :param kwargs: additional named arguments to pass down to copy_dir
     """
     if isinstance(paths, string_type):
         paths = [paths]
@@ -2103,10 +2133,11 @@ def copy(paths, target_path, force_in_dry_run=False):
         full_target_path = os.path.join(target_path, os.path.basename(path))
         mkdir(os.path.dirname(full_target_path), parents=True)
 
-        if os.path.isfile(path):
+        # copy broken symlinks only if 'symlinks=True' is used
+        if os.path.isfile(path) or (os.path.islink(path) and kwargs.get('symlinks')):
             copy_file(path, full_target_path, force_in_dry_run=force_in_dry_run)
         elif os.path.isdir(path):
-            copy_dir(path, full_target_path, force_in_dry_run=force_in_dry_run)
+            copy_dir(path, full_target_path, force_in_dry_run=force_in_dry_run, **kwargs)
         else:
             raise EasyBuildError("Specified path to copy is not an existing file or directory: %s", path)
 
diff --git a/easybuild/tools/modules.py b/easybuild/tools/modules.py
index 8a5323434d..9d5f8ce952 100644
--- a/easybuild/tools/modules.py
+++ b/easybuild/tools/modules.py
@@ -487,7 +487,11 @@ def module_wrapper_exists(self, mod_name, modulerc_fn='.modulerc', mod_wrapper_r
         """
         Determine whether a module wrapper with specified name exists.
         Only .modulerc file in Tcl syntax is considered here.
+        DEPRECATED. Use exists()
         """
+        self.log.deprecated('module_wrapper_exists is unreliable and should no longer be used. ' +
+                            'Use exists instead to check for an existing module or alias.', '5.0')
+
         if mod_wrapper_regex_template is None:
             mod_wrapper_regex_template = "^[ ]*module-version (?P<wrapped_mod>[^ ]*) %s$"
 
@@ -528,24 +532,40 @@ def module_wrapper_exists(self, mod_name, modulerc_fn='.modulerc', mod_wrapper_r
 
         return wrapped_mod
 
-    def exist(self, mod_names, mod_exists_regex_template=r'^\s*\S*/%s.*:\s*$', skip_avail=False, maybe_partial=True):
+    def exist(self, mod_names, mod_exists_regex_template=None, skip_avail=False, maybe_partial=True):
         """
         Check if modules with specified names exists.
 
         :param mod_names: list of module names
-        :param mod_exists_regex_template: template regular expression to search 'module show' output with
+        :param mod_exists_regex_template: DEPRECATED and unused
         :param skip_avail: skip checking through 'module avail', only check via 'module show'
         :param maybe_partial: indicates if the module name may be a partial module name
         """
+        if mod_exists_regex_template is not None:
+            self.log.deprecated('mod_exists_regex_template is no longer used', '5.0')
+
         def mod_exists_via_show(mod_name):
             """
             Helper function to check whether specified module name exists through 'module show'.
 
             :param mod_name: module name
             """
-            mod_exists_regex = mod_exists_regex_template % re.escape(mod_name)
-            txt = self.show(mod_name)
-            return bool(re.search(mod_exists_regex, txt, re.M))
+            stderr = self.show(mod_name)
+            res = False
+            # Parse the output:
+            # - Skip whitespace
+            # - Any error -> Module does not exist
+            # - Check first non-whitespace line for something that looks like an absolute path terminated by a colon
+            mod_exists_regex = r'\s*/.+:\s*'
+            for line in stderr.split('\n'):
+                if OUTPUT_MATCHES['whitespace'].search(line):
+                    continue
+                if OUTPUT_MATCHES['error'].search(line):
+                    break
+                if re.match(mod_exists_regex, line):
+                    res = True
+                break
+            return res
 
         if skip_avail:
             avail_mod_names = []
@@ -570,15 +590,6 @@ def mod_exists_via_show(mod_name):
                 self.log.debug("checking whether hidden module %s exists via 'show'..." % mod_name)
                 mod_exists = mod_exists_via_show(mod_name)
 
-            # if no module file was found, check whether specified module name can be a 'wrapper' module...
-            if not mod_exists:
-                self.log.debug("Module %s not found via module avail/show, checking whether it is a wrapper", mod_name)
-                wrapped_mod = self.module_wrapper_exists(mod_name)
-                if wrapped_mod is not None:
-                    # module wrapper only really exists if the wrapped module file is also available
-                    mod_exists = wrapped_mod in avail_mod_names or mod_exists_via_show(wrapped_mod)
-                    self.log.debug("Result for existence check of wrapped module %s: %s", wrapped_mod, mod_exists)
-
             self.log.debug("Result for existence check of %s module: %s", mod_name, mod_exists)
 
             mods_exist.append(mod_exists)
@@ -643,7 +654,7 @@ def show(self, mod_name):
             ans = MODULE_SHOW_CACHE[key]
             self.log.debug("Found cached result for 'module show %s' with key '%s': %s", mod_name, key, ans)
         else:
-            ans = self.run_module('show', mod_name, check_output=False, return_output=True)
+            ans = self.run_module('show', mod_name, check_output=False, return_stderr=True)
             MODULE_SHOW_CACHE[key] = ans
             self.log.debug("Cached result for 'module show %s' with key '%s': %s", mod_name, key, ans)
 
@@ -759,13 +770,15 @@ def run_module(self, *args, **kwargs):
         # also catch and check exit code
         exit_code = proc.returncode
         if kwargs.get('check_exit_code', True) and exit_code != 0:
-            raise EasyBuildError("Module command 'module %s' failed with exit code %s; stderr: %s; stdout: %s",
-                                 ' '.join(cmd_list[2:]), exit_code, stderr, stdout)
+            raise EasyBuildError("Module command '%s' failed with exit code %s; stderr: %s; stdout: %s",
+                                 ' '.join(cmd_list), exit_code, stderr, stdout)
 
         if kwargs.get('check_output', True):
             self.check_module_output(full_cmd, stdout, stderr)
 
-        if kwargs.get('return_output', False):
+        if kwargs.get('return_stderr', False):
+            return stderr
+        elif kwargs.get('return_output', False):
             return stdout + stderr
         else:
             # the module command was run with an outdated selected environment variables (see LD_ENV_VAR_KEYS list)
@@ -1394,7 +1407,7 @@ def prepend_module_path(self, path, set_mod_paths=True, priority=None):
     def module_wrapper_exists(self, mod_name):
         """
         Determine whether a module wrapper with specified name exists.
-        First check for wrapper defined in .modulerc.lua, fall back to also checking .modulerc (Tcl syntax).
+        DEPRECATED. Use exists()
         """
         res = None
 
@@ -1410,19 +1423,6 @@ def module_wrapper_exists(self, mod_name):
 
         return res
 
-    def exist(self, mod_names, skip_avail=False, maybe_partial=True):
-        """
-        Check if modules with specified names exists.
-
-        :param mod_names: list of module names
-        :param skip_avail: skip checking through 'module avail', only check via 'module show'
-        """
-        # module file may be either in Tcl syntax (no file extension) or Lua sytax (.lua extension);
-        # the current configuration for matters little, since the module may have been installed with a different cfg;
-        # Lmod may pick up both Tcl and Lua module files, regardless of the EasyBuild configuration
-        return super(Lmod, self).exist(mod_names, mod_exists_regex_template=r'^\s*\S*/%s.*(\.lua)?:\s*$',
-                                       skip_avail=skip_avail, maybe_partial=maybe_partial)
-
     def get_setenv_value_from_modulefile(self, mod_name, var_name):
         """
         Get value for specific 'setenv' statement from module file for the specified module.
diff --git a/easybuild/tools/toolchain/mpi.py b/easybuild/tools/toolchain/mpi.py
index 052c3e061d..93f833b07a 100644
--- a/easybuild/tools/toolchain/mpi.py
+++ b/easybuild/tools/toolchain/mpi.py
@@ -28,10 +28,12 @@
 :author: Stijn De Weirdt (Ghent University)
 :author: Kenneth Hoste (Ghent University)
 """
+import copy
 import os
 import tempfile
 from distutils.version import LooseVersion
 
+from easybuild.base import fancylogger
 import easybuild.tools.environment as env
 import easybuild.tools.toolchain as toolchain
 from easybuild.tools.build_log import EasyBuildError
@@ -41,6 +43,95 @@
 from easybuild.tools.toolchain.toolchain import Toolchain
 
 
+_log = fancylogger.getLogger('tools.toolchain.mpi', fname=False)
+
+
+def get_mpi_cmd_template(mpi_family, params, mpi_version=None):
+    """
+    Return template for MPI command, for specified MPI family.
+
+    :param mpi_family: MPI family to use to determine MPI command template
+    """
+
+    params = copy.deepcopy(params)
+
+    mpi_cmd_template = build_option('mpi_cmd_template')
+    if mpi_cmd_template:
+        _log.info("Using specified template for MPI commands: %s", mpi_cmd_template)
+    else:
+        # different known mpirun commands
+        mpirun_n_cmd = "mpirun -n %(nr_ranks)s %(cmd)s"
+        mpi_cmds = {
+            toolchain.OPENMPI: mpirun_n_cmd,
+            toolchain.QLOGICMPI: "mpirun -H localhost -np %(nr_ranks)s %(cmd)s",
+            toolchain.INTELMPI: mpirun_n_cmd,
+            toolchain.MVAPICH2: mpirun_n_cmd,
+            toolchain.MPICH: mpirun_n_cmd,
+            toolchain.MPICH2: mpirun_n_cmd,
+        }
+
+    # Intel MPI mpirun needs more work
+    if mpi_cmd_template is None:
+
+        if mpi_family == toolchain.INTELMPI:
+
+            if mpi_version is None:
+                raise EasyBuildError("Intel MPI version unknown, can't determine MPI command template!")
+
+            # for old versions of Intel MPI, we need to use MPD
+            if LooseVersion(mpi_version) <= LooseVersion('4.1'):
+
+                mpi_cmds[toolchain.INTELMPI] = "mpirun %(mpdbf)s %(nodesfile)s -np %(nr_ranks)s %(cmd)s"
+
+                # set temporary dir for MPD
+                # note: this needs to be kept *short*,
+                # to avoid mpirun failing with "socket.error: AF_UNIX path too long"
+                # exact limit is unknown, but ~20 characters seems to be OK
+                env.setvar('I_MPI_MPD_TMPDIR', tempfile.gettempdir())
+                mpd_tmpdir = os.environ['I_MPI_MPD_TMPDIR']
+                if len(mpd_tmpdir) > 20:
+                    _log.warning("$I_MPI_MPD_TMPDIR should be (very) short to avoid problems: %s", mpd_tmpdir)
+
+                # temporary location for mpdboot and nodes files
+                tmpdir = tempfile.mkdtemp(prefix='mpi_cmd_for-')
+
+                # set PBS_ENVIRONMENT, so that --file option for mpdboot isn't stripped away
+                env.setvar('PBS_ENVIRONMENT', "PBS_BATCH_MPI")
+
+                # make sure we're always using mpd as process manager
+                # only required for/picked up by Intel MPI v4.1 or higher, no harm done for others
+                env.setvar('I_MPI_PROCESS_MANAGER', 'mpd')
+
+                # create mpdboot file
+                mpdboot = os.path.join(tmpdir, 'mpdboot')
+                write_file(mpdboot, "localhost ifhn=localhost")
+
+                params.update({'mpdbf': "--file=%s" % mpdboot})
+
+                # create nodes file
+                nodes = os.path.join(tmpdir, 'nodes')
+                write_file(nodes, "localhost\n" * int(params['nr_ranks']))
+
+                params.update({'nodesfile': "-machinefile %s" % nodes})
+
+        if mpi_family in mpi_cmds:
+            mpi_cmd_template = mpi_cmds[mpi_family]
+            _log.info("Using template MPI command '%s' for MPI family '%s'", mpi_cmd_template, mpi_family)
+        else:
+            raise EasyBuildError("Don't know which template MPI command to use for MPI family '%s'", mpi_family)
+
+    missing = []
+    for key in sorted(params.keys()):
+        tmpl = '%(' + key + ')s'
+        if tmpl not in mpi_cmd_template:
+            missing.append(tmpl)
+    if missing:
+        raise EasyBuildError("Missing templates in mpi-cmd-template value '%s': %s",
+                             mpi_cmd_template, ', '.join(missing))
+
+    return mpi_cmd_template, params
+
+
 class Mpi(Toolchain):
     """General MPI-like class
         can't be used without creating new class M(Mpi)
@@ -191,79 +282,15 @@ def mpi_cmd_for(self, cmd, nr_ranks):
             'cmd': cmd,
         }
 
-        mpi_cmd_template = build_option('mpi_cmd_template')
-        if mpi_cmd_template:
-            self.log.info("Using specified template for MPI commands: %s", mpi_cmd_template)
-        else:
-            # different known mpirun commands
-            mpirun_n_cmd = "mpirun -n %(nr_ranks)s %(cmd)s"
-            mpi_cmds = {
-                toolchain.OPENMPI: mpirun_n_cmd,
-                toolchain.QLOGICMPI: "mpirun -H localhost -np %(nr_ranks)s %(cmd)s",
-                toolchain.INTELMPI: mpirun_n_cmd,
-                toolchain.MVAPICH2: mpirun_n_cmd,
-                toolchain.MPICH: mpirun_n_cmd,
-                toolchain.MPICH2: mpirun_n_cmd,
-            }
-
         mpi_family = self.mpi_family()
 
-        # Intel MPI mpirun needs more work
-        if mpi_cmd_template is None:
-
-            if mpi_family == toolchain.INTELMPI:
-
-                # for old versions of Intel MPI, we need to use MPD
-                impi_ver = self.get_software_version(self.MPI_MODULE_NAME)[0]
-                if LooseVersion(impi_ver) <= LooseVersion('4.1'):
-
-                    mpi_cmds[toolchain.INTELMPI] = "mpirun %(mpdbf)s %(nodesfile)s -np %(nr_ranks)s %(cmd)s"
-
-                    # set temporary dir for MPD
-                    # note: this needs to be kept *short*,
-                    # to avoid mpirun failing with "socket.error: AF_UNIX path too long"
-                    # exact limit is unknown, but ~20 characters seems to be OK
-                    env.setvar('I_MPI_MPD_TMPDIR', tempfile.gettempdir())
-                    mpd_tmpdir = os.environ['I_MPI_MPD_TMPDIR']
-                    if len(mpd_tmpdir) > 20:
-                        self.log.warning("$I_MPI_MPD_TMPDIR should be (very) short to avoid problems: %s", mpd_tmpdir)
-
-                    # temporary location for mpdboot and nodes files
-                    tmpdir = tempfile.mkdtemp(prefix='mpi_cmd_for-')
-
-                    # set PBS_ENVIRONMENT, so that --file option for mpdboot isn't stripped away
-                    env.setvar('PBS_ENVIRONMENT', "PBS_BATCH_MPI")
-
-                    # make sure we're always using mpd as process manager
-                    # only required for/picked up by Intel MPI v4.1 or higher, no harm done for others
-                    env.setvar('I_MPI_PROCESS_MANAGER', 'mpd')
-
-                    # create mpdboot file
-                    mpdboot = os.path.join(tmpdir, 'mpdboot')
-                    write_file(mpdboot, "localhost ifhn=localhost")
-
-                    params.update({'mpdbf': "--file=%s" % mpdboot})
-
-                    # create nodes file
-                    nodes = os.path.join(tmpdir, 'nodes')
-                    write_file(nodes, "localhost\n" * int(nr_ranks))
-
-                    params.update({'nodesfile': "-machinefile %s" % nodes})
-
-            if mpi_family in mpi_cmds.keys():
-                mpi_cmd_template = mpi_cmds[mpi_family]
-                self.log.info("Using template MPI command '%s' for MPI family '%s'", mpi_cmd_template, mpi_family)
-            else:
-                raise EasyBuildError("Don't know which template MPI command to use for MPI family '%s'", mpi_family)
+        if mpi_family == toolchain.INTELMPI:
+            mpi_version = self.get_software_version(self.MPI_MODULE_NAME)[0]
+        else:
+            mpi_version = None
 
-        missing = []
-        for key in sorted(params.keys()):
-            tmpl = '%(' + key + ')s'
-            if tmpl not in mpi_cmd_template:
-                missing.append(tmpl)
-        if missing:
-            raise EasyBuildError("Missing templates in mpi-cmd-template value '%s': %s",
-                                 mpi_cmd_template, ', '.join(missing))
+        mpi_cmd_template, params = get_mpi_cmd_template(mpi_family, params, mpi_version=mpi_version)
+        self.log.info("Using MPI command template '%s' (params: %s)", mpi_cmd_template, params)
 
         try:
             res = mpi_cmd_template % params
diff --git a/test/framework/easyblock.py b/test/framework/easyblock.py
index 25e9789d14..1e015f9b85 100644
--- a/test/framework/easyblock.py
+++ b/test/framework/easyblock.py
@@ -53,6 +53,7 @@
 from easybuild.tools.version import get_git_revision, this_is_easybuild
 from easybuild.tools.py2vs3 import string_type
 
+
 class EasyBlockTest(EnhancedTestCase):
     """ Baseclass for easyblock testcases """
 
@@ -1928,6 +1929,73 @@ def test_time2str(self):
         error_pattern = "Incorrect value type provided to time2str, should be datetime.timedelta: <.* 'int'>"
         self.assertErrorRegex(EasyBuildError, error_pattern, time2str, 123)
 
+    def test_sanity_check_paths_verification(self):
+        """Test verification of sanity_check_paths w.r.t. keys & values."""
+
+        testdir = os.path.abspath(os.path.dirname(__file__))
+        toy_ec = os.path.join(testdir, 'easyconfigs', 'test_ecs', 't', 'toy', 'toy-0.0.eb')
+        eb = EasyBlock(EasyConfig(toy_ec))
+        eb.dry_run = True
+
+        error_pattern = r"Incorrect format for sanity_check_paths: "
+        error_pattern += r"should \(only\) have 'dirs', 'files' keys, "
+        error_pattern += r"values should be lists \(at least one non-empty\)."
+
+        def run_sanity_check_step(sanity_check_paths, enhance_sanity_check):
+            """Helper function to run sanity check step, and do trivial check on generated output."""
+            self.mock_stderr(True)
+            self.mock_stdout(True)
+            eb.cfg['sanity_check_paths'] = sanity_check_paths
+            eb.cfg['enhance_sanity_check'] = enhance_sanity_check
+            eb.sanity_check_step()
+            stderr, stdout = self.get_stderr(), self.get_stdout()
+            self.mock_stderr(False)
+            self.mock_stdout(False)
+            self.assertFalse(stderr)
+            self.assertTrue(stdout.startswith("Sanity check paths"))
+
+        # partial sanity_check_paths, only allowed when using enhance_sanity_check
+        test_cases = [
+            {'dirs': ['foo']},
+            {'files': ['bar']},
+            {'dirs': []},
+            {'files': []},
+            {'files': [], 'dirs': []},
+        ]
+        for test_case in test_cases:
+            # without enhanced sanity check, these are all invalid sanity_check_paths values
+            self.assertErrorRegex(EasyBuildError, error_pattern, run_sanity_check_step, test_case, False)
+
+            # if enhance_sanity_check is enabled, these are acceptable sanity_check_step values
+            run_sanity_check_step(test_case, True)
+
+        # some inputs are always invalid, regardless of enhance_sanity_check, due to wrong keys/values
+        test_cases = [
+            {'foo': ['bar']},
+            {'files': ['foo'], 'dirs': [], 'libs': ['libfoo.a']},
+            {'files': ['foo'], 'libs': ['libfoo.a']},
+            {'dirs': [], 'libs': ['libfoo.a']},
+        ]
+        for test_case in test_cases:
+            self.assertErrorRegex(EasyBuildError, error_pattern, run_sanity_check_step, test_case, False)
+            self.assertErrorRegex(EasyBuildError, error_pattern, run_sanity_check_step, test_case, True)
+
+        # non-list values yield different errors with/without enhance_sanity_check
+        error_pattern_bis = r"Incorrect value type in sanity_check_paths, should be a list: .*"
+        test_cases = [
+            {'files': 123, 'dirs': []},
+            {'files': [], 'dirs': 123},
+            {'files': 'foo', 'dirs': []},
+            {'files': [], 'dirs': 'foo'},
+        ]
+        for test_case in test_cases:
+            self.assertErrorRegex(EasyBuildError, error_pattern, run_sanity_check_step, test_case, False)
+            self.assertErrorRegex(EasyBuildError, error_pattern_bis, run_sanity_check_step, test_case, True)
+
+        # empty sanity_check_paths is always OK, since then the fallback to default bin + lib/lib64 kicks in
+        run_sanity_check_step({}, False)
+        run_sanity_check_step({}, True)
+
 
 def suite():
     """ return all the tests in this file """
diff --git a/test/framework/filetools.py b/test/framework/filetools.py
index 777b0d3ebb..54e0fad84f 100644
--- a/test/framework/filetools.py
+++ b/test/framework/filetools.py
@@ -29,6 +29,7 @@
 @author: Kenneth Hoste (Ghent University)
 @author: Stijn De Weirdt (Ghent University)
 @author: Ward Poelmans (Ghent University)
+@author: Maxime Boissonneault (Compute Canada, Universite Laval)
 """
 import datetime
 import glob
@@ -148,6 +149,29 @@ def test_find_base_dir(self):
         os.chdir(tmpdir)
         self.assertTrue(os.path.samefile(foodir, ft.find_base_dir()))
 
+    def test_find_glob_pattern(self):
+        """test find_glob_pattern function"""
+        tmpdir = tempfile.mkdtemp()
+        os.mkdir(os.path.join(tmpdir, 'python2.7'))
+        os.mkdir(os.path.join(tmpdir, 'python2.7', 'include'))
+        os.mkdir(os.path.join(tmpdir, 'python3.5m'))
+        os.mkdir(os.path.join(tmpdir, 'python3.5m', 'include'))
+
+        self.assertEqual(ft.find_glob_pattern(os.path.join(tmpdir, 'python2.7*')),
+                         os.path.join(tmpdir, 'python2.7'))
+        self.assertEqual(ft.find_glob_pattern(os.path.join(tmpdir, 'python2.7*', 'include')),
+                         os.path.join(tmpdir, 'python2.7', 'include'))
+        self.assertEqual(ft.find_glob_pattern(os.path.join(tmpdir, 'python3.5*')),
+                         os.path.join(tmpdir, 'python3.5m'))
+        self.assertEqual(ft.find_glob_pattern(os.path.join(tmpdir, 'python3.5*', 'include')),
+                         os.path.join(tmpdir, 'python3.5m', 'include'))
+        self.assertEqual(ft.find_glob_pattern(os.path.join(tmpdir, 'python3.6*'), False), None)
+        self.assertErrorRegex(EasyBuildError, "Was expecting exactly", ft.find_glob_pattern,
+                              os.path.join(tmpdir, 'python3.6*'))
+        self.assertErrorRegex(EasyBuildError, "Was expecting exactly", ft.find_glob_pattern,
+                              os.path.join(tmpdir, 'python*'))
+
+
     def test_encode_class_name(self):
         """Test encoding of class names."""
         for (class_name, encoded_class_name) in self.class_names:
@@ -1303,6 +1327,15 @@ def test_pypi_source_urls(self):
         # more than 50 releases at time of writing test, which always stay there
         self.assertTrue(len(res) > 50)
 
+        # check for Python package that has yanked releases,
+        # see https://github.com/easybuilders/easybuild-framework/issues/3301
+        res = ft.pypi_source_urls('ipython')
+        self.assertTrue(isinstance(res, list) and res)
+        prefix = 'https://pypi.python.org/packages'
+        for entry in res:
+            self.assertTrue(entry.startswith(prefix), "'%s' should start with '%s'" % (entry, prefix))
+            self.assertTrue('ipython' in entry, "Pattern 'ipython' should be found in '%s'" % entry)
+
     def test_derive_alt_pypi_url(self):
         """Test derive_alt_pypi_url() function."""
         url = 'https://pypi.python.org/packages/source/e/easybuild/easybuild-2.7.0.tar.gz'
@@ -1475,22 +1508,45 @@ def test_copy_dir(self):
         ft.copy_dir(to_copy, testdir, dirs_exist_ok=True)
         self.assertTrue(sorted(os.listdir(to_copy)) == sorted(os.listdir(testdir)))
 
-        # if the directory already exists and 'dirs_exist_ok' is True and there is another named argument (ignore)
-        # we expect clean error on Python < 3.8 and pass the test on Python >= 3.8
-        # NOTE: reused ignore from previous test
+        # check whether use of 'ignore' works if target path already exists and 'dirs_exist_ok' is enabled
         def ignore_func(_, names):
             return [x for x in names if '6.4.0-2.28' in x]
 
         shutil.rmtree(testdir)
         ft.mkdir(testdir)
-        if sys.version_info >= (3, 8):
-            ft.copy_dir(to_copy, testdir, dirs_exist_ok=True, ignore=ignore_func)
-            self.assertEqual(sorted(os.listdir(testdir)), expected)
-            self.assertFalse(os.path.exists(os.path.join(testdir, 'GCC-6.4.0-2.28.eb')))
-        else:
-            error_pattern = "Unknown named arguments passed to copy_dir with dirs_exist_ok=True: ignore"
-            self.assertErrorRegex(EasyBuildError, error_pattern, ft.copy_dir, to_copy, testdir,
-                                  dirs_exist_ok=True, ignore=ignore_func)
+        ft.copy_dir(to_copy, testdir, dirs_exist_ok=True, ignore=ignore_func)
+        self.assertEqual(sorted(os.listdir(testdir)), expected)
+        self.assertFalse(os.path.exists(os.path.join(testdir, 'GCC-6.4.0-2.28.eb')))
+
+        # test copy_dir when broken symlinks are involved
+        srcdir = os.path.join(self.test_prefix, 'topdir_to_copy')
+        ft.mkdir(srcdir)
+        ft.write_file(os.path.join(srcdir, 'test.txt'), '123')
+        subdir = os.path.join(srcdir, 'subdir')
+        # introduce broken file symlink
+        foo_txt = os.path.join(subdir, 'foo.txt')
+        ft.write_file(foo_txt, 'bar')
+        ft.symlink(foo_txt, os.path.join(subdir, 'bar.txt'))
+        ft.remove_file(foo_txt)
+        # introduce broken dir symlink
+        subdir_tmp = os.path.join(srcdir, 'subdir_tmp')
+        ft.mkdir(subdir_tmp)
+        ft.symlink(subdir_tmp, os.path.join(srcdir, 'subdir_link'))
+        ft.remove_dir(subdir_tmp)
+
+        target_dir = os.path.join(self.test_prefix, 'target_to_copy_to')
+
+        # trying this without symlinks=True ends in tears, because bar.txt points to a non-existing file
+        self.assertErrorRegex(EasyBuildError, "Failed to copy directory", ft.copy_dir, srcdir, target_dir)
+        ft.remove_dir(target_dir)
+
+        ft.copy_dir(srcdir, target_dir, symlinks=True)
+
+        # copying directory with broken symlinks should also work if target directory already exists
+        ft.remove_dir(target_dir)
+        ft.mkdir(target_dir)
+        ft.mkdir(subdir)
+        ft.copy_dir(srcdir, target_dir, symlinks=True, dirs_exist_ok=True)
 
         # also test behaviour of copy_file under --dry-run
         build_options = {
@@ -1509,7 +1565,7 @@ def ignore_func(_, names):
         self.mock_stdout(False)
 
         self.assertFalse(os.path.exists(target_dir))
-        self.assertTrue(re.search("^copied directory .*/GCC to .*/GCC", txt))
+        self.assertTrue(re.search("^copied directory .*/GCC to .*/%s" % os.path.basename(target_dir), txt))
 
         # forced copy, even in dry run mode
         self.mock_stdout(True)
diff --git a/test/framework/modules.py b/test/framework/modules.py
index 93015b4a07..808eb0df76 100644
--- a/test/framework/modules.py
+++ b/test/framework/modules.py
@@ -44,6 +44,7 @@
 from easybuild.framework.easyblock import EasyBlock
 from easybuild.framework.easyconfig.easyconfig import EasyConfig
 from easybuild.tools.build_log import EasyBuildError
+from easybuild.tools.environment import modify_env
 from easybuild.tools.filetools import adjust_permissions, copy_file, copy_dir, mkdir
 from easybuild.tools.filetools import read_file, remove_dir, remove_file, symlink, write_file
 from easybuild.tools.modules import EnvironmentModules, EnvironmentModulesC, EnvironmentModulesTcl, Lmod, NoModulesTool
@@ -92,6 +93,104 @@ def test_long_module_path(self):
 
         shutil.rmtree(tmpdir)
 
+    def test_run_module(self):
+        """Test for ModulesTool.run_module method."""
+
+        testdir = os.path.dirname(os.path.abspath(__file__))
+
+        for key in ['EBROOTGCC', 'EBROOTOPENMPI', 'EBROOTOPENBLAS']:
+            if key in os.environ:
+                del os.environ[key]
+
+        # arguments can be passed in two ways: multiple arguments, or just 1 list argument
+        self.modtool.run_module('load', 'GCC/6.4.0-2.28')
+        self.assertEqual(os.environ['EBROOTGCC'], '/prefix/software/GCC/6.4.0-2.28')
+
+        # restore original environment
+        modify_env(os.environ, self.orig_environ, verbose=False)
+        self.reset_modulepath([os.path.join(testdir, 'modules')])
+
+        self.assertFalse('EBROOTGCC' in os.environ)
+        self.modtool.run_module(['load', 'GCC/6.4.0-2.28'])
+        self.assertEqual(os.environ['EBROOTGCC'], '/prefix/software/GCC/6.4.0-2.28')
+
+        # skip tests that rely on exit codes when using EnvironmentModulesTcl modules tool,
+        # because it doesn't use proper exit codes
+        if not isinstance(self.modtool, EnvironmentModulesTcl):
+
+            # by default, exit code is checked and an error is raised if we run something that fails
+            error_pattern = "Module command '.*thisdoesnotmakesense' failed with exit code [1-9]"
+            self.assertErrorRegex(EasyBuildError, error_pattern, self.modtool.run_module, 'thisdoesnotmakesense')
+
+            # we need to use a different error pattern here with EnvironmentModulesC,
+            # because a load of a non-existing module doesnt' trigger a non-zero exit code...
+            # it will still fail though, just differently
+            if isinstance(self.modtool, EnvironmentModulesC):
+                error_pattern = "Unable to locate a modulefile for 'nosuchmodule/1.2.3'"
+            else:
+                error_pattern = "Module command '.*load nosuchmodule/1.2.3' failed with exit code [1-9]"
+            self.assertErrorRegex(EasyBuildError, error_pattern, self.modtool.run_module, 'load', 'nosuchmodule/1.2.3')
+
+        # we can choose to blatently ignore the exit code,
+        # and also disable the output check that serves as a fallback;
+        # we also enable return_output here, because trying to apply the environment changes produced
+        # by a faulty command is bound to cause trouble...
+        kwargs = {
+            'check_exit_code': False,
+            'check_output': False,
+            'return_output': True,
+        }
+        self.modtool.run_module('thisdoesnotmakesense', **kwargs)
+        self.modtool.run_module('load', 'nosuchmodule/1.2.3', **kwargs)
+
+        # by default, the output (stdout+stderr) produced by the command is processed;
+        # result is a list of useful info (module names in case of list/avail)
+        res = self.modtool.run_module('list')
+        self.assertEqual(res, [{'mod_name': 'GCC/6.4.0-2.28', 'default': None}])
+
+        res = self.modtool.run_module('avail', 'GCC/4.6.3')
+        self.assertTrue(isinstance(res, list))
+        self.assertEqual(sorted([x['mod_name'] for x in res]), ['GCC/4.6.3'])
+
+        # loading a module produces no output, so we get an empty list
+        res = self.modtool.run_module('load', 'OpenMPI/2.1.2-GCC-6.4.0-2.28')
+        self.assertEqual(res, [])
+        self.assertEqual(os.environ['EBROOTOPENMPI'], '/prefix/software/OpenMPI/2.1.2-GCC-6.4.0-2.28')
+
+        # we can opt into getting back the raw output (stdout + stderr);
+        # in that cases, the output includes Python statements to change the environment;
+        # the changes that would be made by the module command are *not* applied to the environment
+        out = self.modtool.run_module('load', 'OpenBLAS/0.2.20-GCC-6.4.0-2.28', return_output=True)
+        patterns = [
+            r"^os.environ\[.EBROOTOPENBLAS.\]\s*=\s*./prefix/software/OpenBLAS/0.2.20-GCC-6.4.0-2.28.",
+            r"^os.environ\[.LOADEDMODULES.\]\s*=.*OpenBLAS/0.2.20-GCC-6.4.0-2.28",
+        ]
+        for pattern in patterns:
+            regex = re.compile(pattern, re.M)
+            self.assertTrue(regex.search(out), "Pattern '%s' should be found in: %s" % (regex.pattern, out))
+
+        # OpenBLAS module did *not* get loaded
+        self.assertFalse('EBROOTOPENBLAS' in os.environ)
+        res = self.modtool.list()
+        expected = ['GCC/6.4.0-2.28', 'OpenMPI/2.1.2-GCC-6.4.0-2.28', 'hwloc/1.11.8-GCC-6.4.0-2.28']
+        self.assertEqual(sorted([x['mod_name'] for x in res]), expected)
+
+        # we can also only obtain the stderr output (which contains the user-facing output),
+        # and just drop the stdout output (which contains the statements to change the environment)
+        out = self.modtool.run_module('show', 'OpenBLAS/0.2.20-GCC-6.4.0-2.28', return_stderr=True)
+        patterns = [
+            r"test/framework/modules/OpenBLAS/0.2.20-GCC-6.4.0-2.28:\s*$",
+            r"setenv\W+EBROOTOPENBLAS.+/prefix/software/OpenBLAS/0.2.20-GCC-6.4.0-2.28",
+            r"prepend[_-]path\W+LD_LIBRARY_PATH.+/prefix/software/OpenBLAS/0.2.20-GCC-6.4.0-2.28/lib",
+        ]
+        for pattern in patterns:
+            regex = re.compile(pattern, re.M)
+            self.assertTrue(regex.search(out), "Pattern '%s' should be found in: %s" % (regex.pattern, out))
+
+        # show method only returns user-facing output (obtained via stderr), not changes to the environment
+        regex = re.compile(r'^os\.environ\[', re.M)
+        self.assertFalse(regex.search(out), "Pattern '%s' should not be found in: %s" % (regex.pattern, out))
+
     def test_avail(self):
         """Test if getting a (restricted) list of available modules works."""
         self.init_testmods()
@@ -168,6 +267,7 @@ def test_exist(self):
 
         java_mod_dir = os.path.join(self.test_prefix, 'Java')
         write_file(os.path.join(java_mod_dir, '1.8.0_181'), '#%Module')
+        write_file(os.path.join(self.test_prefix, 'toy', '42.1337'), '#%Module')
 
         if self.modtool.__class__ == EnvironmentModulesC:
             modulerc_tcl_txt = '\n'.join([
@@ -175,11 +275,18 @@ def test_exist(self):
                 'if {"Java/1.8" eq [module-info version Java/1.8]} {',
                 '    module-version Java/1.8.0_181 1.8',
                 '}',
+                'if {"Java/site_default" eq [module-info version Java/site_default]} {',
+                '    module-version Java/1.8.0_181 site_default',
+                '}',
             ])
         else:
             modulerc_tcl_txt = '\n'.join([
                 '#%Module',
                 'module-version Java/1.8.0_181 1.8',
+                'module-version Java/1.8.0_181 site_default',
+                'module-alias Java/Alias toy/42.1337',
+                # 'module-alias Java/NonExist non_existant/1',  # (only) LMod has this in module avail, disable for now
+                'module-alias JavaAlias Java/1.8.0_181',  # LMod 7+ only
             ])
 
         write_file(os.path.join(java_mod_dir, '.modulerc'), modulerc_tcl_txt)
@@ -188,8 +295,20 @@ def test_exist(self):
         self.assertTrue('Java/1.8.0_181' in avail_mods)
         if isinstance(self.modtool, Lmod) and StrictVersion(self.modtool.version) >= StrictVersion('7.0'):
             self.assertTrue('Java/1.8' in avail_mods)
+            self.assertTrue('Java/site_default' in avail_mods)
+            self.assertTrue('JavaAlias' in avail_mods)
+            self.assertEqual(self.modtool.exist(['JavaAlias']), [True])
+
         self.assertEqual(self.modtool.exist(['Java/1.8', 'Java/1.8.0_181']), [True, True])
-        self.assertEqual(self.modtool.module_wrapper_exists('Java/1.8'), 'Java/1.8.0_181')
+
+        # module-version with different version suffix than the base module
+        self.assertEqual(self.modtool.exist(['Java/site_default']), [True])
+        # Check for aliases:
+        # - completely different nameTrue, True,
+        # - alias to non existant module
+        # Skipped for EnvironmentModulesC as module-alias not working correctly there
+        if self.modtool.__class__ != EnvironmentModulesC:
+            self.assertEqual(self.modtool.exist(['Java/Alias', 'Java/NonExist']), [True, False])
 
         reset_module_caches()
 
@@ -199,8 +318,12 @@ def test_exist(self):
 
         self.assertTrue('Core/Java/1.8.0_181' in self.modtool.available())
         self.assertEqual(self.modtool.exist(['Core/Java/1.8.0_181']), [True])
-        self.assertEqual(self.modtool.exist(['Core/Java/1.8']), [True])
-        self.assertEqual(self.modtool.module_wrapper_exists('Core/Java/1.8'), 'Core/Java/1.8.0_181')
+        # module-version only works for EnvironmentModules(C) as LMod and EnvironmentModulesTcl would need updating
+        # to full path, see https://github.com/TACC/Lmod/issues/446
+        if isinstance(self.modtool, Lmod) or self.modtool.__class__ == EnvironmentModulesTcl:
+            self.assertEqual(self.modtool.exist(['Core/Java/1.8', 'Core/Java/site_default']), [False, False])
+        else:
+            self.assertEqual(self.modtool.exist(['Core/Java/1.8', 'Core/Java/site_default']), [True, True])
 
         # also check with .modulerc.lua for Lmod 7.8 or newer
         if isinstance(self.modtool, Lmod) and StrictVersion(self.modtool.version) >= StrictVersion('7.8'):
@@ -208,13 +331,22 @@ def test_exist(self):
             reset_module_caches()
 
             remove_file(os.path.join(java_mod_dir, '.modulerc'))
-            write_file(os.path.join(java_mod_dir, '.modulerc.lua'), 'module_version("Java/1.8.0_181", "1.8")')
+            write_file(os.path.join(java_mod_dir, '.modulerc.lua'),
+                       '\n'.join([
+                            'module_version("Java/1.8.0_181", "1.8")',
+                            'module_version("Java/1.8.0_181", "site_default")',
+                            'module_alias("JavaAlias", "Java/1.8")',
+                        ]))
 
             avail_mods = self.modtool.available()
             self.assertTrue('Java/1.8.0_181' in avail_mods)
             self.assertTrue('Java/1.8' in avail_mods)
             self.assertEqual(self.modtool.exist(['Java/1.8', 'Java/1.8.0_181']), [True, True])
-            self.assertEqual(self.modtool.module_wrapper_exists('Java/1.8'), 'Java/1.8.0_181')
+
+            # check for an alias with a different version suffix than the base module
+            self.assertEqual(self.modtool.exist(['Java/site_default']), [True])
+            # And completely different name
+            self.assertEqual(self.modtool.exist(['JavaAlias']), [True])
 
             reset_module_caches()
 
@@ -222,8 +354,24 @@ def test_exist(self):
             shutil.move(java_mod_dir, os.path.join(self.test_prefix, 'Core', 'Java'))
             self.assertTrue('Core/Java/1.8.0_181' in self.modtool.available())
             self.assertEqual(self.modtool.exist(['Core/Java/1.8.0_181']), [True])
-            self.assertEqual(self.modtool.exist(['Core/Java/1.8']), [True])
-            self.assertEqual(self.modtool.module_wrapper_exists('Core/Java/1.8'), 'Core/Java/1.8.0_181')
+            self.assertEqual(self.modtool.exist(['Core/Java/1.8']), [False])
+            self.assertEqual(self.modtool.exist(['Core/Java/site_default']), [False])
+
+        # Test alias in home directory .modulerc
+        if isinstance(self.modtool, Lmod) and StrictVersion(self.modtool.version) >= StrictVersion('7.0'):
+            # Required or temporary HOME would be in MODULEPATH already
+            self.init_testmods()
+            # Sanity check: Module aliases don't exist yet
+            self.assertEqual(self.modtool.exist(['OpenMPI/99', 'OpenMPIAlias']), [False, False])
+            # Use a temporary dir, not the users HOME
+            os.environ['HOME'] = tempfile.mkdtemp()
+            reset_module_caches()
+            write_file(os.path.join(os.environ['HOME'], '.modulerc'), '\n'.join([
+                '#%Module',
+                'module-version OpenMPI/2.1.2-GCC-6.4.0-2.28 99',
+                'module-alias OpenMPIAlias OpenMPI/2.1.2-GCC-6.4.0-2.28',
+            ]))
+            self.assertEqual(self.modtool.exist(['OpenMPI/99', 'OpenMPIAlias']), [True, True])
 
     def test_load(self):
         """ test if we load one module it is in the loaded_modules """
@@ -284,6 +432,25 @@ def test_load(self):
         self.assertEqual(os.environ.get('EBROOTGCC'), None)
         self.assertFalse(loaded_modules[-1] == 'GCC/6.4.0-2.28')
 
+    def test_show(self):
+        """Test for ModulesTool.show method."""
+
+        out = self.modtool.show('GCC/7.3.0-2.30')
+
+        patterns = [
+            # full path to module is included in output of 'show'
+            r"test/framework/modules/GCC/7.3.0-2.30:\s*$",
+            r"setenv\W+EBROOTGCC.+prefix/software/GCC/7.3.0-2.30",
+            r"^prepend[_-]path\W+PATH.+/prefix/software/GCC/7.3.0-2.30/bin",
+        ]
+        for pattern in patterns:
+            regex = re.compile(pattern, re.M)
+            self.assertTrue(regex.search(out), "Pattern '%s' should be found in: %s" % (regex.pattern, out))
+
+        # show method only returns user-facing output (obtained via stderr), not changes to the environment
+        regex = re.compile(r'^os\.environ\[', re.M)
+        self.assertFalse(regex.search(out), "Pattern '%s' should not be found in: %s" % (regex.pattern, out))
+
     def test_curr_module_paths(self):
         """Test for curr_module_paths function."""
 
@@ -544,24 +711,6 @@ def test_modulefile_path(self):
             res = modtool.modulefile_path('bzip2/.1.0.6', strip_ext=True)
             self.assertTrue(res.endswith('test/framework/modules/bzip2/.1.0.6'))
 
-        # hack into 'module show GCC/6.4.0-2.28' cache and inject alternate output that modulecmd.tcl sometimes produces
-        # make sure we only extract the module file path, nothing else...
-        # cfr. https://github.com/easybuilders/easybuild/issues/368
-        modulepath = os.environ['MODULEPATH'].split(':')
-        mod_show_cache_key = modtool.mk_module_cache_key('GCC/6.4.0-2.28')
-        mod.MODULE_SHOW_CACHE[mod_show_cache_key] = '\n'.join([
-            "import os",
-            "os.environ['MODULEPATH_modshare'] = '%s'" % ':'.join(m + ':1' for m in modulepath),
-            "os.environ['MODULEPATH'] = '%s'" % ':'.join(modulepath),
-            "------------------------------------------------------------------------------",
-            "%s:" % gcc_mod_file,
-            "------------------------------------------------------------------------------",
-            # remainder of output doesn't really matter in this context
-            "setenv		EBROOTGCC /prefix/GCC/6.4.0-2.28"
-        ])
-        res = modtool.modulefile_path('GCC/6.4.0-2.28')
-        self.assertTrue(os.path.samefile(res, os.path.join(test_dir, 'modules', 'GCC', '6.4.0-2.28')))
-
         reset_module_caches()
 
     def test_path_to_top_of_module_tree(self):
@@ -891,7 +1040,7 @@ def test_modules_tool_stateless(self):
             # exact error message depends on Lmod version
             load_err_msg = '|'.join([
                 r'These[\s\sn]*module\(s\)[\s\sn]*exist[\s\sn]*but[\s\sn]*cannot[\s\sn]*be',
-                'The[\s\sn]*following[\s\sn]*module\(s\)[\s\sn]*are[\s\sn]*unknown',
+                r'The[\s\sn]*following[\s\sn]*module\(s\)[\s\sn]*are[\s\sn]*unknown',
             ])
         else:
             load_err_msg = "Unable to locate a modulefile"
@@ -1060,7 +1209,7 @@ def test_load_in_hierarchy(self):
     def test_exit_code_check(self):
         """Verify that EasyBuild checks exit code of executed module commands"""
         if isinstance(self.modtool, Lmod):
-            error_pattern = "Module command 'module load nosuchmoduleavailableanywhere' failed with exit code"
+            error_pattern = "Module command '.*load nosuchmoduleavailableanywhere' failed with exit code"
         else:
             # Tcl implementations exit with 0 even when a non-existing module is loaded...
             error_pattern = "Unable to locate a modulefile for 'nosuchmoduleavailableanywhere'"
@@ -1101,7 +1250,7 @@ def check_loaded_modules():
             r"^\* GCC/6.4.0-2.28",
             r"^\* hwloc/1.11.8-GCC-6.4.0-2.28",
             r"^\* OpenMPI/2.1.2-GCC-6.4.0-2.28",
-            "This is not recommended since it may affect the installation procedure\(s\) performed by EasyBuild.",
+            r"This is not recommended since it may affect the installation procedure\(s\) performed by EasyBuild.",
             "To make EasyBuild allow particular loaded modules, use the --allow-loaded-modules configuration option.",
             "To specify action to take when loaded modules are detected, use "
             "--detect-loaded-modules={error,ignore,purge,unload,warn}",
@@ -1119,7 +1268,7 @@ def check_loaded_modules():
 
         # error mentioning 1 non-allowed module (OpenMPI), both GCC and hwloc loaded modules are allowed
         error_pattern = r"Found one or more non-allowed loaded .* module.*\n"
-        error_pattern += "\* OpenMPI/2.1.2-GCC-6.4.0-2.28\n\nThis is not"
+        error_pattern += r"\* OpenMPI/2.1.2-GCC-6.4.0-2.28\n\nThis is not"
         self.assertErrorRegex(EasyBuildError, error_pattern, self.modtool.check_loaded_modules)
 
         # check for warning message when purge is being run on loaded modules
diff --git a/test/framework/options.py b/test/framework/options.py
index a755b7d7c4..354cdfad16 100644
--- a/test/framework/options.py
+++ b/test/framework/options.py
@@ -2750,7 +2750,7 @@ def test_xxx_include_easyblocks_from_pr(self):
         write_file(self.logfile, '')
 
         args = [
-            '--from-pr=9979',  # PR for CMake easyconfig
+            '--from-pr=10487',  # PR for CMake easyconfig
             '--include-easyblocks-from-pr=1936',  # PR for EB_CMake easyblock
             '--unittest-file=%s' % self.logfile,
             '--github-user=%s' % GITHUB_TEST_ACCOUNT,
@@ -2760,8 +2760,8 @@ def test_xxx_include_easyblocks_from_pr(self):
         logtxt = read_file(self.logfile)
 
         # easyconfig from pr is found
-        ec_pattern = os.path.join(self.test_prefix, '.*', 'files_pr9979', 'c', 'CMake',
-                                  'CMake-3.16.4-GCCcore-9.2.0.eb')
+        ec_pattern = os.path.join(self.test_prefix, '.*', 'files_pr10487', 'c', 'CMake',
+                                  'CMake-3.16.4-GCCcore-9.3.0.eb')
         ec_regex = re.compile(r"Parsing easyconfig file %s" % ec_pattern, re.M)
         self.assertTrue(ec_regex.search(logtxt), "Pattern '%s' found in: %s" % (ec_regex.pattern, logtxt))
 
diff --git a/test/framework/sandbox/easybuild/easyblocks/t/toy.py b/test/framework/sandbox/easybuild/easyblocks/t/toy.py
index 79f3d3d8fc..11b2dff542 100644
--- a/test/framework/sandbox/easybuild/easyblocks/t/toy.py
+++ b/test/framework/sandbox/easybuild/easyblocks/t/toy.py
@@ -46,7 +46,7 @@ class EB_toy(ExtensionEasyBlock):
 
     @staticmethod
     def extra_options(extra_vars=None):
-        """Custom easyconfig parameters for toytoy."""
+        """Custom easyconfig parameters for toy."""
         if extra_vars is None:
             extra_vars = {}
 
diff --git a/test/framework/toolchain.py b/test/framework/toolchain.py
index 2b0fc84634..4ed54ead66 100644
--- a/test/framework/toolchain.py
+++ b/test/framework/toolchain.py
@@ -40,6 +40,7 @@
 from test.framework.utilities import EnhancedTestCase, TestLoaderFiltered, find_full_path, init_config
 
 import easybuild.tools.modules as modules
+import easybuild.tools.toolchain as toolchain
 import easybuild.tools.toolchain.compiler
 from easybuild.framework.easyconfig.easyconfig import EasyConfig, ActiveMNS
 from easybuild.toolchains.system import SystemToolchain
@@ -49,6 +50,7 @@
 from easybuild.tools.filetools import adjust_permissions, copy_dir, find_eb_script, mkdir, read_file, write_file, which
 from easybuild.tools.py2vs3 import string_type
 from easybuild.tools.run import run_cmd
+from easybuild.tools.toolchain.mpi import get_mpi_cmd_template
 from easybuild.tools.toolchain.toolchain import env_vars_external_module
 from easybuild.tools.toolchain.utilities import get_toolchain, search_toolchain
 
@@ -1027,6 +1029,40 @@ def test_mpi_cmd_for(self):
         error_pattern = "Failed to complete MPI cmd template .* with .*: KeyError 'foo'"
         self.assertErrorRegex(EasyBuildError, error_pattern, tc.mpi_cmd_for, 'test', 1)
 
+    def test_get_mpi_cmd_template(self):
+        """Test get_mpi_cmd_template function."""
+
+        # search_toolchain needs to be called once to make sure constants like toolchain.OPENMPI are in place
+        search_toolchain('')
+
+        input_params = {'nr_ranks': 123, 'cmd': 'this_is_just_a_test'}
+
+        for mpi_fam in [toolchain.OPENMPI, toolchain.MPICH, toolchain.MPICH2, toolchain.MVAPICH2]:
+            mpi_cmd_tmpl, params = get_mpi_cmd_template(mpi_fam, input_params)
+            self.assertEqual(mpi_cmd_tmpl, "mpirun -n %(nr_ranks)s %(cmd)s")
+            self.assertEqual(params, input_params)
+
+        # Intel MPI is a special case, also requires MPI version to be known
+        impi = toolchain.INTELMPI
+        error_pattern = "Intel MPI version unknown, can't determine MPI command template!"
+        self.assertErrorRegex(EasyBuildError, error_pattern, get_mpi_cmd_template, impi, {})
+
+        mpi_cmd_tmpl, params = get_mpi_cmd_template(toolchain.INTELMPI, input_params, mpi_version='1.0')
+        self.assertEqual(mpi_cmd_tmpl, "mpirun %(mpdbf)s %(nodesfile)s -np %(nr_ranks)s %(cmd)s")
+        self.assertEqual(sorted(params.keys()), ['cmd', 'mpdbf', 'nodesfile', 'nr_ranks'])
+        self.assertEqual(params['cmd'], 'this_is_just_a_test')
+        self.assertEqual(params['nr_ranks'], 123)
+
+        mpdbf = params['mpdbf']
+        regex = re.compile('^--file=.*/mpdboot$')
+        self.assertTrue(regex.match(mpdbf), "'%s' should match pattern '%s'" % (mpdbf, regex.pattern))
+        self.assertTrue(os.path.exists(mpdbf.split('=')[1]))
+
+        nodesfile = params['nodesfile']
+        regex = re.compile('^-machinefile /.*/nodes$')
+        self.assertTrue(regex.match(nodesfile), "'%s' should match pattern '%s'" % (nodesfile, regex.pattern))
+        self.assertTrue(os.path.exists(nodesfile.split(' ')[1]))
+
     def test_prepare_deps(self):
         """Test preparing for a toolchain when dependencies are involved."""
         tc = self.get_toolchain('GCC', version='6.4.0-2.28')
diff --git a/test/framework/toy_build.py b/test/framework/toy_build.py
index 7ddcefbf67..6c15b16915 100644
--- a/test/framework/toy_build.py
+++ b/test/framework/toy_build.py
@@ -54,7 +54,7 @@
 from easybuild.tools.filetools import adjust_permissions, mkdir, read_file, remove_dir, remove_file, which, write_file
 from easybuild.tools.module_generator import ModuleGeneratorTcl
 from easybuild.tools.modules import Lmod
-from easybuild.tools.py2vs3 import string_type
+from easybuild.tools.py2vs3 import reload, string_type
 from easybuild.tools.run import run_cmd
 from easybuild.tools.version import VERSION as EASYBUILD_VERSION
 
@@ -74,7 +74,31 @@ def setUp(self):
 
     def tearDown(self):
         """Cleanup."""
+
+        # kick out any paths for included easyblocks from sys.path,
+        # to avoid infected any other tests
+        for path in sys.path[:]:
+            if '/included-easyblocks' in path:
+                sys.path.remove(path)
+
+        # reload toy easyblock (and generic toy_extension easyblock that imports it) after cleaning up sys.path,
+        # to avoid trouble in other tests due to included toy easyblock that is cached somewhere
+        # (despite the cleanup in sys.modules);
+        # important for tests that include a customised copy of the toy easyblock
+        # (like test_toy_build_enhanced_sanity_check)
+        import easybuild.easyblocks.toy
+        reload(easybuild.easyblocks.toy)
+        import easybuild.easyblocks.toytoy
+        reload(easybuild.easyblocks.toytoy)
+        import easybuild.easyblocks.generic.toy_extension
+        reload(easybuild.easyblocks.generic.toy_extension)
+
+        del sys.modules['easybuild.easyblocks.toy']
+        del sys.modules['easybuild.easyblocks.toytoy']
+        del sys.modules['easybuild.easyblocks.generic.toy_extension']
+
         super(ToyBuildTest, self).tearDown()
+
         # remove logs
         if os.path.exists(self.dummylogfn):
             os.remove(self.dummylogfn)
@@ -1339,7 +1363,7 @@ def test_external_dependencies(self):
         write_file(toy_ec, ectxt + extraectxt)
 
         if isinstance(self.modtool, Lmod):
-            err_msg = r"Module command \\'module load nosuchbuilddep/0.0.0\\' failed"
+            err_msg = r"Module command \\'.*load nosuchbuilddep/0.0.0\\' failed"
         else:
             err_msg = r"Unable to locate a modulefile for 'nosuchbuilddep/0.0.0'"
 
@@ -1351,7 +1375,7 @@ def test_external_dependencies(self):
         write_file(toy_ec, ectxt + extraectxt)
 
         if isinstance(self.modtool, Lmod):
-            err_msg = r"Module command \\'module load nosuchmodule/1.2.3\\' failed"
+            err_msg = r"Module command \\'.*load nosuchmodule/1.2.3\\' failed"
         else:
             err_msg = r"Unable to locate a modulefile for 'nosuchmodule/1.2.3'"
 
@@ -1889,6 +1913,169 @@ def test_sanity_check_paths_lib64(self):
         write_file(test_ec, ectxt)
         self.test_toy_build(ec_file=test_ec, raise_error=True)
 
+    def test_toy_build_enhanced_sanity_check(self):
+        """Test enhancing of sanity check."""
+
+        # if toy easyblock was imported, get rid of corresponding entry in sys.modules,
+        # to avoid that it messes up the use of --include-easyblocks=toy.py below...
+        if 'easybuild.easyblocks.toy' in sys.modules:
+            del sys.modules['easybuild.easyblocks.toy']
+
+        test_dir = os.path.join(os.path.abspath(os.path.dirname(__file__)))
+        toy_ec = os.path.join(test_dir, 'easyconfigs', 'test_ecs', 't', 'toy', 'toy-0.0.eb')
+        toy_ec_txt = read_file(toy_ec)
+
+        test_ec = os.path.join(self.test_prefix, 'test.eb')
+
+        # get rid of custom sanity check paths in test easyconfig
+        regex = re.compile(r'^sanity_check_paths\s*=\s*{[^}]+}', re.M)
+        test_ec_txt = regex.sub('', toy_ec_txt)
+        write_file(test_ec, test_ec_txt)
+
+        self.assertFalse('sanity_check_' in test_ec_txt)
+
+        # create custom easyblock for toy that has a custom sanity_check_step
+        toy_easyblock = os.path.join(test_dir, 'sandbox', 'easybuild', 'easyblocks', 't', 'toy.py')
+
+        toy_easyblock_txt = read_file(toy_easyblock)
+
+        toy_custom_sanity_check_step = '\n'.join([
+            '',
+            "    def sanity_check_step(self):",
+            "        paths = {",
+            "            'files': ['bin/toy'],",
+            "            'dirs': [],",
+            "        }",
+            "        cmds = ['toy']",
+            "        return super(EB_toy, self).sanity_check_step(custom_paths=paths, custom_commands=cmds)",
+        ])
+        test_toy_easyblock = os.path.join(self.test_prefix, 'toy.py')
+        write_file(test_toy_easyblock, toy_easyblock_txt + toy_custom_sanity_check_step)
+
+        eb_args = [
+            '--extended-dry-run',
+            '--include-easyblocks=%s' % test_toy_easyblock,
+        ]
+
+        # by default, sanity check commands & paths specified by easyblock are used
+        self.mock_stdout(True)
+        self.test_toy_build(ec_file=test_ec, extra_args=eb_args, verify=False, testing=False, raise_error=True)
+        stdout = self.get_stdout()
+        self.mock_stdout(False)
+
+        pattern_lines = [
+            r"Sanity check paths - file.*",
+            r"\s*\* bin/toy",
+            r"Sanity check paths - \(non-empty\) directory.*",
+            r"\s*\(none\)",
+            r"Sanity check commands",
+            r"\s*\* toy",
+            r'',
+        ]
+        regex = re.compile(r'\n'.join(pattern_lines), re.M)
+        self.assertTrue(regex.search(stdout), "Pattern '%s' should be found in: %s" % (regex.pattern, stdout))
+
+        # we need to manually wipe the entry for the included toy easyblock,
+        # to avoid trouble with subsequent EasyBuild sessions in this test
+        del sys.modules['easybuild.easyblocks.toy']
+
+        # easyconfig specifies custom sanity_check_paths & sanity_check_commands,
+        # the ones defined by the easyblock are skipped by default
+        test_ec_txt = test_ec_txt + '\n'.join([
+            '',
+            "sanity_check_paths = {",
+            "    'files': ['README'],",
+            "    'dirs': ['bin/']",
+            "}",
+            "sanity_check_commands = ['ls %(installdir)s']",
+        ])
+        write_file(test_ec, test_ec_txt)
+
+        self.mock_stdout(True)
+        self.test_toy_build(ec_file=test_ec, extra_args=eb_args, verify=False, testing=False, raise_error=True)
+        stdout = self.get_stdout()
+        self.mock_stdout(False)
+
+        pattern_lines = [
+            r"Sanity check paths - file.*",
+            r"\s*\* README",
+            r"Sanity check paths - \(non-empty\) directory.*",
+            r"\s*\* bin/",
+            r"Sanity check commands",
+            r"\s*\* ls .*/software/toy/0.0",
+            r'',
+        ]
+        regex = re.compile(r'\n'.join(pattern_lines), re.M)
+        self.assertTrue(regex.search(stdout), "Pattern '%s' should be found in: %s" % (regex.pattern, stdout))
+
+        del sys.modules['easybuild.easyblocks.toy']
+
+        # if enhance_sanity_check is enabled, then sanity check paths/commands specified in easyconfigs
+        # are used in addition to those defined in easyblock
+        test_ec_txt = test_ec_txt + '\nenhance_sanity_check = True'
+        write_file(test_ec, test_ec_txt)
+
+        self.mock_stdout(True)
+        self.test_toy_build(ec_file=test_ec, extra_args=eb_args, verify=False, testing=False, raise_error=True)
+        stdout = self.get_stdout()
+        self.mock_stdout(False)
+
+        # now 'bin/toy' file and 'toy' command should also be part of sanity check
+        pattern_lines = [
+            r"Sanity check paths - file.*",
+            r"\s*\* README",
+            r"\s*\* bin/toy",
+            r"Sanity check paths - \(non-empty\) directory.*",
+            r"\s*\* bin/",
+            r"Sanity check commands",
+            r"\s*\* ls .*/software/toy/0.0",
+            r"\s*\* toy",
+            r'',
+        ]
+        regex = re.compile(r'\n'.join(pattern_lines), re.M)
+        self.assertTrue(regex.search(stdout), "Pattern '%s' should be found in: %s" % (regex.pattern, stdout))
+
+        del sys.modules['easybuild.easyblocks.toy']
+
+        # sanity_check_paths with only one key is allowed if enhance_sanity_check is enabled;
+        test_ec_txt = test_ec_txt + "\nsanity_check_paths = {'files': ['README']}"
+        write_file(test_ec, test_ec_txt)
+
+        # we need to do a non-dry run here, to ensure the code we want to test is triggered
+        # (EasyConfig.dump called by 'reproduce_build' function from 'build_and_install_one')
+        eb_args = [
+            '--include-easyblocks=%s' % test_toy_easyblock,
+            '--trace',
+        ]
+
+        self.mock_stdout(True)
+        self.test_toy_build(ec_file=test_ec, extra_args=eb_args, verify=False, testing=False, raise_error=True)
+        stdout = self.get_stdout()
+        self.mock_stdout(False)
+
+        pattern_lines = [
+            r"^== sanity checking\.\.\.",
+            r"  >> file 'bin/toy' found: OK",
+        ]
+        regex = re.compile(r'\n'.join(pattern_lines), re.M)
+        self.assertTrue(regex.search(stdout), "Pattern '%s' should be found in: %s" % (regex.pattern, stdout))
+
+        # no directories are checked in sanity check now, only files (since dirs is an empty list)
+        regex = re.compile(r"directory .* found:", re.M)
+        self.assertFalse(regex.search(stdout), "Pattern '%s' should be not found in: %s" % (regex.pattern, stdout))
+
+        del sys.modules['easybuild.easyblocks.toy']
+
+        # if enhance_sanity_check is disabled, both files/dirs keys are strictly required in sanity_check_paths
+        test_ec_txt = test_ec_txt + '\nenhance_sanity_check = False'
+        write_file(test_ec, test_ec_txt)
+
+        error_pattern = " Missing mandatory key 'dirs' in sanity_check_paths."
+        self.assertErrorRegex(EasyBuildError, error_pattern, self.test_toy_build, ec_file=test_ec,
+                              extra_args=eb_args, raise_error=True, verbose=False)
+
+        del sys.modules['easybuild.easyblocks.toy']
+
     def test_toy_dumped_easyconfig(self):
         """ Test dumping of file in eb_filerepo in both .eb and .yeb format """
         filename = 'toy-0.0'
@@ -2070,9 +2257,16 @@ def test_toy_modaltsoftname(self):
 
     def test_toy_build_trace(self):
         """Test use of --trace"""
+
+        topdir = os.path.dirname(os.path.abspath(__file__))
+        toy_ec_file = os.path.join(topdir, 'easyconfigs', 'test_ecs', 't', 'toy', 'toy-0.0.eb')
+
+        test_ec = os.path.join(self.test_prefix, 'test.eb')
+        write_file(test_ec, read_file(toy_ec_file) + '\nsanity_check_commands = ["toy"]')
+
         self.mock_stderr(True)
         self.mock_stdout(True)
-        self.test_toy_build(extra_args=['--trace', '--experimental'], verify=False, testing=False)
+        self.test_toy_build(ec_file=test_ec, extra_args=['--trace', '--experimental'], verify=False, testing=False)
         stderr = self.get_stderr()
         stdout = self.get_stdout()
         self.mock_stderr(False)
@@ -2097,6 +2291,8 @@ def test_toy_build_trace(self):
                 r"== sanity checking\.\.\.",
                 r"  >> file 'bin/yot' or 'bin/toy' found: OK",
                 r"  >> \(non-empty\) directory 'bin' found: OK",
+                r"  >> running command 'toy' \.\.\.",
+                r"  >> result for command 'toy': OK",
             ]) + r'$',
             r"^== creating module\.\.\.\n  >> generating module file @ .*/modules/all/toy/0\.0(?:\.lua)?$",
         ]
diff --git a/test/framework/utilities.py b/test/framework/utilities.py
index 2c2bd73ffb..1d98dbcced 100644
--- a/test/framework/utilities.py
+++ b/test/framework/utilities.py
@@ -125,9 +125,8 @@ def setUp(self):
         os.environ['EASYBUILD_ROBOT_PATHS'] = os.path.join(testdir, 'easyconfigs', 'test_ecs')
 
         # make sure no deprecated behaviour is being triggered (unless intended by the test)
-        # trip *all* log.deprecated statements by setting deprecation version ridiculously high
         self.orig_current_version = eb_build_log.CURRENT_VERSION
-        os.environ['EASYBUILD_DEPRECATED'] = '10000000'
+        self.disallow_deprecated_behaviour()
 
         init_config()
 
@@ -181,6 +180,11 @@ def setUp(self):
         self.reset_modulepath([os.path.join(testdir, 'modules')])
         reset_module_caches()
 
+    def disallow_deprecated_behaviour(self):
+        """trip *all* log.deprecated statements by setting deprecation version ridiculously high"""
+        os.environ['EASYBUILD_DEPRECATED'] = '10000000'
+        eb_build_log.CURRENT_VERSION = os.environ['EASYBUILD_DEPRECATED']
+
     def allow_deprecated_behaviour(self):
         """Restore EasyBuild version to what it was originally, to allow triggering deprecated behaviour."""
         if 'EASYBUILD_DEPRECATED' in os.environ: