Merge branch 'master' into bugfix/reruns-exitcode

Author: vkarak

docs/manpage.rst

@@ -1043,7 +1043,7 @@ The way the tests are generated and how they interact with the test filtering op
 
    Parameterize a test on an existing variable.
 
-   This option will create a new test with a parameter named ``$VAR`` with the values given in the comma-separated list ``VAL0,VAL1,...``.
+   The test will behave as if the variable ``VAR`` was a parameter taking the values ``VAL0,VAL1,...``.
    The values will be converted based on the type of the target variable ``VAR``.
    The ``TEST.`` prefix will only parameterize the variable ``VAR`` of test ``TEST``.
 

reframe/core/pipeline.py

@@ -1646,7 +1646,9 @@ def _resolve_fixtures(self):
             # registered under the same fixture class. So the loop below must
             # also inspect the fixture data the instance was registered with.
             for fixt_name, fixt_data in registry[f.cls].items():
-                if f.scope != fixt_data.scope:
+                if fixt_data.variables != f.variables:
+                    continue
+                elif f.scope != fixt_data.scope:
                     continue
                 elif fixt_data.variant_num not in target_variants:
                     continue

reframe/core/schedulers/slurm.py

@@ -351,6 +351,7 @@ def filternodes(self, job, nodes):
         option_parser.add_argument('-w', '--nodelist')
         option_parser.add_argument('-C', '--constraint')
         option_parser.add_argument('-x', '--exclude')
+        self.log(f'Filtering by Slurm options: {" ".join(options)}')
         parsed_args, _ = option_parser.parse_known_args(options)
         reservation = parsed_args.reservation
         partitions = parsed_args.partition
@@ -363,7 +364,7 @@ def filternodes(self, job, nodes):
         else:
             nodes = {node for node in nodes if not node.in_state('RESERVED')}
 
-        self.log(f'[F] Filtering nodes by reservation={reservation}: '
+        self.log(f'Filtering nodes by reservation={reservation}: '
                  f'available nodes now: {len(nodes)}')
 
         if partitions:
@@ -377,27 +378,27 @@ def filternodes(self, job, nodes):
             )
             partitions = {default_partition} if default_partition else set()
             self.log(
-                f'[F] No partition specified; using {default_partition!r}'
+                f'No partition specified; using {default_partition!r}'
             )
 
         nodes = {n for n in nodes if n.partitions >= partitions}
-        self.log(f'[F] Filtering nodes by partition(s) {partitions}: '
+        self.log(f'Filtering nodes by partition(s) {partitions}: '
                  f'available nodes now: {len(nodes)}')
         if constraints:
             nodes = {n for n in nodes if n.satisfies(constraints)}
-            self.log(f'[F] Filtering nodes by constraint(s) {constraints}: '
+            self.log(f'Filtering nodes by constraint(s) {constraints}: '
                      f'available nodes now: {len(nodes)}')
 
         if nodelist:
             nodelist = nodelist.strip()
             nodes &= self._get_nodes_by_name(nodelist)
-            self.log(f'[F] Filtering nodes by nodelist: {nodelist}: '
+            self.log(f'Filtering nodes by nodelist: {nodelist}: '
                      f'available nodes now: {len(nodes)}')
 
         if exclude_nodes:
             exclude_nodes = exclude_nodes.strip()
             nodes -= self._get_nodes_by_name(exclude_nodes)
-            self.log(f'[F] Excluding node(s): {exclude_nodes}: '
+            self.log(f'Excluding node(s): {exclude_nodes}: '
                      f'available nodes now: {len(nodes)}')
 
         return nodes
@@ -711,17 +712,29 @@ def is_down(self):
         return not self.is_avail()
 
     def satisfies(self, slurm_constraint):
+        def _replacemany(s, replacements):
+            for src, dst in replacements:
+                s = s.replace(src, dst)
+
+            return s
+
         # Convert the Slurm constraint to a Python expression and evaluate it,
         # but restrict our syntax to accept only AND or OR constraints and
-        # their combinations
-        if not re.match(r'^[\w\d\(\)\|\&]*$', slurm_constraint):
+        # their combinations; to properly treat `-` in constraints we need to
+        # convert them to valid Python identifiers before evaluating the
+        # constraint.
+        if not re.match(r'^[\-\w\d\(\)\|\&]*$', slurm_constraint):
             return False
 
-        names = {grp[0]
-                 for grp in re.finditer(r'(\w(\w|\d)*)', slurm_constraint)}
-        expr = slurm_constraint.replace('|', ' or ').replace('&', ' and ')
-        vars = {n: True for n in self.active_features}
-        vars.update({n: False for n in names - self.active_features})
+        names = {
+            grp[0] for grp in re.finditer(r'[\-\w][\-\w\d]*', slurm_constraint)
+        }
+        expr = _replacemany(slurm_constraint,
+                            [('-', '_'), ('|', ' or '), ('&', ' and ')])
+        vars = {n.replace('-', '_'): True for n in self.active_features}
+        vars.update({
+            n.replace('-', '_'): False for n in names - self.active_features
+        })
         try:
             return eval(expr, {}, vars)
         except BaseException:

reframe/frontend/cli.py

@@ -1041,7 +1041,8 @@ def restrict_logging():
         with exit_gracefully_on_error('failed to retrieve test case data',
                                       printer):
             printer.info(jsonext.dumps(reporting.testcase_info(
-                options.describe_stored_testcases, namepatt
+                options.describe_stored_testcases,
+                namepatt, options.filter_expr
             ), indent=2))
             sys.exit(0)
 

reframe/frontend/loader.py

@@ -193,17 +193,31 @@ def load_from_file(self, filename, force=False):
 
         try:
             dirname = os.path.dirname(filename)
-            with osext.change_dir(dirname):
-                with util.temp_sys_path(dirname):
-                    if os.path.exists(os.path.join(dirname, '__init__.py')):
-                        # If the containing directory is a package,
-                        # import it, too.
-                        parent = util.import_module_from_file(dirname).__name__
-                    else:
-                        parent = None
 
+            # Load all parent modules of test file
+            parents = []
+            while os.path.exists(os.path.join(dirname, '__init__.py')):
+                parents.append(os.path.join(dirname))
+                dirname = os.path.split(dirname)[0]
+
+            parent_module = None
+            for pdir in reversed(parents):
+                with osext.change_dir(pdir):
+                    with util.temp_sys_path(pdir):
+                        package_path = os.path.join(pdir, '__init__.py')
+                        parent_module = util.import_module_from_file(
+                            package_path, parent=parent_module
+                        ).__name__
+
+            # Now load the actual test file
+            if not parents:
+                pdir = dirname
+
+            with osext.change_dir(pdir):
+                with util.temp_sys_path(pdir):
                     return self.load_from_module(
-                        util.import_module_from_file(filename, force, parent)
+                        util.import_module_from_file(filename, force,
+                                                     parent_module)
                     )
         except Exception:
             exc_info = sys.exc_info()

reframe/frontend/testgenerators.py

@@ -77,12 +77,12 @@ def _generate_tests(testcases, gen_fn):
 @time_function
 def distribute_tests(testcases, node_map):
     def _rfm_pin_run_nodes(obj):
-        nodelist = getattr(obj, '$nid')
+        nodelist = getattr(obj, '.nid')
         if not obj.local:
             obj.job.pin_nodes = nodelist
 
     def _rfm_pin_build_nodes(obj):
-        pin_nodes = getattr(obj, '$nid')
+        pin_nodes = getattr(obj, '.nid')
         if obj.build_job and not obj.local and not obj.build_locally:
             obj.build_job.pin_nodes = pin_nodes
 
@@ -99,9 +99,9 @@ def _rfm_set_valid_systems(obj):
                 'valid_systems': [partition.fullname],
                 # We add a partition parameter so as to differentiate the test
                 # in case another test has the same nodes in another partition
-                '$part': builtins.parameter([partition.fullname],
+                '.part': builtins.parameter([partition.fullname],
                                             loggable=False),
-                '$nid': builtins.parameter(
+                '.nid': builtins.parameter(
                     [[n] for n in node_map[partition.fullname]],
                     fmt=util.nodelist_abbrev, loggable=False
                 )
@@ -113,7 +113,7 @@ def _rfm_set_valid_systems(obj):
                 # will not be overwritten by a parent post-init hook
                 builtins.run_after('init')(_rfm_set_valid_systems),
             ]
-        ), ['$part', '$nid']
+        ), ['.part', '.nid']
 
     return _generate_tests(testcases, _make_dist_test)
 
@@ -127,10 +127,10 @@ def _make_repeat_test(testcase):
         return make_test(
             cls.__name__, (cls,),
             {
-                '$repeat_no': builtins.parameter(range(num_repeats),
+                '.repeat_no': builtins.parameter(range(num_repeats),
                                                  loggable=False)
             }
-        ), ['$repeat_no']
+        ), ['.repeat_no']
 
     return _generate_tests(testcases, _make_repeat_test)
 
@@ -164,7 +164,7 @@ def _make_parameterized_test(testcase):
                 )
                 continue
 
-            body[f'${var}'] = builtins.parameter(values, loggable=False)
+            body[f'.{var}'] = builtins.parameter(values, loggable=False)
 
         def _set_vars(self):
             for var in body.keys():

reframe/utility/__init__.py

@@ -866,7 +866,7 @@ def count_digits(n):
     '''
 
     num_digits = 1
-    while n > 10:
+    while n >= 10:
         n /= 10
         num_digits += 1
 

unittests/resources/checks_unlisted/fixtures_complex.py

@@ -102,3 +102,17 @@ def validate_fixture_resolution(self):
                 ParamFixture.num_variants
             )
         ])
+
+
+@rfm.simple_test
+class TestC(rfm.RunOnlyRegressionTest):
+    valid_systems = ['*']
+    valid_prog_environs = ['*']
+    executable = 'echo'
+    f0 = fixture(SimpleFixture, scope='environment', variables={'data': 10})
+    f1 = fixture(SimpleFixture, scope='environment', variables={'data': 20})
+
+    @sanity_function
+    def validate_vars(self):
+        return sn.all([sn.assert_eq(self.f0.data, 10),
+                       sn.assert_eq(self.f1.data, 20)])

unittests/resources/checks_unlisted/testlib/nested/__init__.py

@@ -0,0 +1,17 @@
+# Copyright 2016-2024 Swiss National Supercomputing Centre (CSCS/ETH Zurich)
+# ReFrame Project Developers. See the top-level LICENSE file for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+import reframe as rfm
+import reframe.utility.sanity as sn
+from ..utility import dummy_fixture
+
+
+@rfm.simple_test
+class dummy_test(rfm.RunOnlyRegressionTest):
+    valid_systems = ['*']
+    valid_prog_environs = ['*']
+    executable = 'true'
+    sanity_patterns = sn.assert_true(1)
+    dummy = fixture(dummy_fixture)