robotframework 6.1.1__zip → 7.0a1__zip

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/model/stats.py

@@ -13,6 +13,8 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from datetime import timedelta
+
 from robot.utils import (Sortable, elapsed_time_to_string, html_escape,
                          is_string, normalize)
 
@@ -31,14 +33,10 @@ class Stat(Sortable):
         #: or name of the tag for
         #: :class:`~robot.model.tagstatistics.TagStatistics`
         self.name = name
-        #: Number of passed tests.
         self.passed = 0
-        #: Number of failed tests.
         self.failed = 0
-        #: Number of skipped tests.
         self.skipped = 0
-        #: Number of milliseconds it took to execute.
-        self.elapsed = 0
+        self.elapsed = timedelta()
         self._norm_name = normalize(name, ignore='_')
 
     def get_attributes(self, include_label=False, include_elapsed=False,
@@ -49,8 +47,7 @@ class Stat(Sortable):
         if include_label:
             attrs['label'] = self.name
         if include_elapsed:
-            attrs['elapsed'] = elapsed_time_to_string(self.elapsed,
-                                                      include_millis=False)
+            attrs['elapsed'] = elapsed_time_to_string(self.elapsed, include_millis=False)
         if exclude_empty:
             attrs = dict((k, v) for k, v in attrs.items() if v not in ('', None))
         if values_as_strings:
@@ -83,7 +80,7 @@ class Stat(Sortable):
             self.failed += 1
 
     def _update_elapsed(self, test):
-        self.elapsed += test.elapsedtime
+        self.elapsed += test.elapsed_time
 
     @property
     def _sort_key(self):
@@ -106,12 +103,9 @@ class SuiteStat(Stat):
     type = 'suite'
 
     def __init__(self, suite):
-        Stat.__init__(self, suite.longname)
-        #: Identifier of the suite, e.g. `s1-s2`.
+        super().__init__(suite.full_name)
         self.id = suite.id
-        #: Number of milliseconds it took to execute this suite,
-        #: including sub-suites.
-        self.elapsed = suite.elapsedtime
+        self.elapsed = suite.elapsed_time
         self._name = suite.name
 
     def _get_custom_attrs(self):
@@ -131,7 +125,7 @@ class TagStat(Stat):
     type = 'tag'
 
     def __init__(self, name, doc='', links=None, combined=None):
-        Stat.__init__(self, name)
+        super().__init__(name)
         #: Documentation of tag as a string.
         self.doc = doc
         #: List of tuples in which the first value is the link URL and
@@ -164,7 +158,7 @@ class TagStat(Stat):
 class CombinedTagStat(TagStat):
 
     def __init__(self, pattern, name=None, doc='', links=None):
-        TagStat.__init__(self, name or pattern, doc, links, combined=pattern)
+        super().__init__(name or pattern, doc, links, combined=pattern)
         self.pattern = TagPattern.from_string(pattern)
 
     def match(self, tags):

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/model/tags.py

@@ -105,7 +105,7 @@ class Tags(Sequence[str]):
 
 class TagPatterns(Sequence['TagPattern']):
 
-    def __init__(self, patterns: Iterable[str]):
+    def __init__(self, patterns: Iterable[str] = ()):
         self._patterns = tuple(TagPattern.from_string(p) for p in Tags(patterns))
 
     def match(self, tags: Iterable[str]) -> bool:

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/model/testcase.py

@@ -13,7 +13,6 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-import sys
 from pathlib import Path
 from typing import Any, Generic, Sequence, Type, TYPE_CHECKING, TypeVar
 
@@ -22,7 +21,7 @@ from robot.utils import setter
 from .body import Body, BodyItem
 from .fixture import create_fixture
 from .itemlist import ItemList
-from .keyword import Keyword, Keywords
+from .keyword import Keyword
 from .modelobject import DataDict, ModelObject
 from .tags import Tags
 
@@ -35,7 +34,7 @@ TC = TypeVar('TC', bound='TestCase')
 KW = TypeVar('KW', bound='Keyword', covariant=True)
 
 
-class TestCase(ModelObject, Generic[KW] if sys.version_info >= (3, 7) else object):
+class TestCase(ModelObject, Generic[KW]):
     """Base model for a single test case.
 
     Extended by :class:`robot.running.model.TestCase` and
@@ -43,7 +42,7 @@ class TestCase(ModelObject, Generic[KW] if sys.version_info >= (3, 7) else objec
     """
     body_class = Body
     # See model.TestSuite on removing the type ignore directive
-    fixture_class: Type[KW] = Keyword # type: ignore
+    fixture_class: Type[KW] = Keyword    # type: ignore
     repr_args = ('name',)
     __slots__ = ['parent', 'name', 'doc', 'timeout', 'lineno', '_setup', '_teardown']
 
@@ -121,7 +120,7 @@ class TestCase(ModelObject, Generic[KW] if sys.version_info >= (3, 7) else objec
         return bool(self._setup)
 
     @property
-    def teardown(self) -> Keyword:
+    def teardown(self) -> KW:
         """Test teardown as a :class:`~.model.keyword.Keyword` object.
 
         See :attr:`setup` for more information.
@@ -144,19 +143,6 @@ class TestCase(ModelObject, Generic[KW] if sys.version_info >= (3, 7) else objec
         """
         return bool(self._teardown)
 
-    @property
-    def keywords(self) -> Keywords:
-        """Deprecated since Robot Framework 4.0
-
-        Use :attr:`body`, :attr:`setup` or :attr:`teardown` instead.
-        """
-        keywords = [self.setup] + list(self.body) + [self.teardown]
-        return Keywords(self, [kw for kw in keywords if kw])
-
-    @keywords.setter
-    def keywords(self, keywords):
-        Keywords.raise_deprecation_error()
-
     @property
     def id(self) -> str:
         """Test case id in format like ``s1-t3``.
@@ -171,11 +157,16 @@ class TestCase(ModelObject, Generic[KW] if sys.version_info >= (3, 7) else objec
         return f'{self.parent.id}-t{index + 1}'
 
     @property
-    def longname(self) -> str:
-        """Test name prefixed with the long name of the parent suite."""
+    def full_name(self) -> str:
+        """Test name prefixed with the full name of the parent suite."""
         if not self.parent:
             return self.name
-        return f'{self.parent.longname}.{self.name}'
+        return f'{self.parent.full_name}.{self.name}'
+
+    @property
+    def longname(self) -> str:
+        """Deprecated since Robot Framework 7.0. Use :attr:`full_name` instead."""
+        return self.full_name
 
     @property
     def source(self) -> 'Path|None':

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/model/testsuite.py

@@ -13,7 +13,6 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-import sys
 from collections.abc import Mapping
 from pathlib import Path
 from typing import Any, Generic, Iterator, Sequence, Type, TypeVar
@@ -25,7 +24,7 @@ from .configurer import SuiteConfigurer
 from .filter import Filter, EmptySuiteRemover
 from .fixture import create_fixture
 from .itemlist import ItemList
-from .keyword import Keyword, Keywords
+from .keyword import Keyword
 from .metadata import Metadata
 from .modelobject import DataDict, ModelObject
 from .tagsetter import TagSetter
@@ -37,14 +36,14 @@ KW = TypeVar('KW', bound=Keyword, covariant=True)
 TC = TypeVar('TC', bound=TestCase, covariant=True)
 
 
-class TestSuite(ModelObject, Generic[KW, TC] if sys.version_info >= (3, 7)  else object):
+class TestSuite(ModelObject, Generic[KW, TC]):
     """Base model for single suite.
 
     Extended by :class:`robot.running.model.TestSuite` and
     :class:`robot.result.model.TestSuite`.
     """
     # FIXME: Type Ignore declarations: Typevars only accept subclasses of the bound class
-    # assiging `Type[KW]` to `Keyword` results in an error. In RF 7 the class should be
+    # assigning `Type[KW]` to `Keyword` results in an error. In RF 7 the class should be
     # made impossible to instantiate directly, and the assignments can be replaced with
     # KnownAtRuntime
     fixture_class: Type[KW] = Keyword  # type: ignore
@@ -192,11 +191,19 @@ class TestSuite(ModelObject, Generic[KW, TC] if sys.version_info >= (3, 7)  else
             suite.adjust_source(relative_to, root)
 
     @property
-    def longname(self) -> str:
-        """Suite name prefixed with the long name of the parent suite."""
+    def full_name(self) -> str:
+        """Suite name prefixed with the full name of the possible parent suite.
+
+        Just :attr:`name` of the suite if it has no :attr:`parent`.
+        """
         if not self.parent:
             return self.name
-        return f'{self.parent.longname}.{self.name}'
+        return f'{self.parent.full_name}.{self.name}'
+
+    @property
+    def longname(self) -> str:
+        """Deprecated since Robot Framework 7.0. Use :attr:`full_name` instead."""
+        return self.full_name
 
     @setter
     def metadata(self, metadata: 'Mapping[str, str]|None') -> Metadata:
@@ -217,12 +224,12 @@ class TestSuite(ModelObject, Generic[KW, TC] if sys.version_info >= (3, 7)  else
                 suite.validate_execution_mode()
                 if rpa is None:
                     rpa = suite.rpa
-                    name = suite.longname
+                    name = suite.full_name
                 elif rpa is not suite.rpa:
                     mode1, mode2 = ('tasks', 'tests') if rpa else ('tests', 'tasks')
                     raise DataError(
                         f"Conflicting execution modes: Suite '{name}' has {mode1} but "
-                        f"suite '{suite.longname}' has {mode2}. Resolve the conflict "
+                        f"suite '{suite.full_name}' has {mode2}. Resolve the conflict "
                         f"or use '--rpa' or '--norpa' options to set the execution "
                         f"mode explicitly."
                     )
@@ -309,19 +316,6 @@ class TestSuite(ModelObject, Generic[KW, TC] if sys.version_info >= (3, 7)  else
         """
         return bool(self._teardown)
 
-    @property
-    def keywords(self) -> Keywords:
-        """Deprecated since Robot Framework 4.0.
-
-        Use :attr:`setup` or :attr:`teardown` instead.
-        """
-        keywords = [self.setup, self.teardown]
-        return Keywords(self, [kw for kw in keywords if kw])
-
-    @keywords.setter
-    def keywords(self, keywords):
-        Keywords.raise_deprecation_error()
-
     @property
     def id(self) -> str:
         """An automatically generated unique id.

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/model/visitor.py

@@ -21,7 +21,7 @@ and the :mod:`result model <robot.result.model>`, but the objects passed to
 the visitor methods are slightly different depending on the model they are
 used with. The main differences are that on the execution side keywords do
 not have child keywords nor messages, and that only the result objects have
-status related attributes like :attr:`status` and :attr:`starttime`.
+status related attributes like :attr:`status` and :attr:`start_time`.
 
 This module contains :class:`SuiteVisitor` that implements the core logic to
 visit a test suite structure, and the :mod:`~robot.result` package contains
@@ -80,19 +80,19 @@ Type hints
 
 Visitor methods have type hints to give more information about the model objects
 they receive to editors. Because visitors can be used with both running and result
-models, the types that are used are base classes from the :mod:`robot.model`
-module. Actual visitors may want to import appropriate types from
-:mod:`robot.running.model` or from :mod:`robot.result.model` modules instead.
-For example, this code that prints failed tests uses result side model objects::
+models, the types that are used as type hints are base classes from the
+:mod:`robot.model` module. Actual visitor implementations can import appropriate
+types from the :mod:`robot.running` or the :mod:`robot.result` module instead.
+For example, this visitor uses the result side model objects::
 
     from robot.api import SuiteVisitor
-    from robot.result.model import TestCase, TestSuite
+    from robot.result import TestCase, TestSuite
 
 
     class FailurePrinter(SuiteVisitor):
 
         def start_suite(self, suite: TestSuite):
-            print(f"{suite.longname}: {suite.statistics.failed} failed")
+            print(f"{suite.full_name}: {suite.statistics.failed} failed")
 
         def visit_test(self, test: TestCase):
             if test.failed:
@@ -107,7 +107,7 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from robot.model import (Break, BodyItem, Continue, Error, For, If, IfBranch,
                              Keyword, Message, Return, TestCase, TestSuite, Try,
-                             TryBranch, While)
+                             TryBranch, Var, While)
     from robot.result import ForIteration, WhileIteration
 
 
@@ -178,10 +178,15 @@ class SuiteVisitor:
         the body of the keyword
         """
         if self.start_keyword(keyword) is not False:
+            self._possible_setup(keyword)
             self._possible_body(keyword)
             self._possible_teardown(keyword)
             self.end_keyword(keyword)
 
+    def _possible_setup(self, item: 'BodyItem'):
+        if getattr(item, 'has_setup', False):
+            item.setup.visit(self)    # type: ignore
+
     def _possible_body(self, item: 'BodyItem'):
         if hasattr(item, 'body'):
             item.body.visit(self)    # type: ignore
@@ -422,6 +427,28 @@ class SuiteVisitor:
         """
         self.end_body_item(iteration)
 
+    def visit_var(self, var: 'Var'):
+        """Visits a VAR elements."""
+        if self.start_var(var) is not False:
+            self._possible_body(var)
+            self.end_var(var)
+
+    def start_var(self, var: 'Var') -> 'bool|None':
+        """Called when a VAR element starts.
+
+        By default, calls :meth:`start_body_item` which, by default, does nothing.
+
+        Can return explicit ``False`` to stop visiting.
+        """
+        return self.start_body_item(var)
+
+    def end_var(self, var: 'Var'):
+        """Called when a VAR element ends.
+
+        By default, calls :meth:`end_body_item` which, by default, does nothing.
+        """
+        self.end_body_item(var)
+
     def visit_return(self, return_: 'Return'):
         """Visits a RETURN elements."""
         if self.start_return(return_) is not False:

robotframework-7.0a1/src/robot/output/console/dotted.py

@@ -0,0 +1,90 @@
+#  Copyright 2008-2015 Nokia Networks
+#  Copyright 2016-     Robot Framework Foundation
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+import sys
+
+from robot.model import SuiteVisitor
+from robot.result import TestCase, TestSuite
+from robot.utils import plural_or_not as s, secs_to_timestr
+
+from .highlighting import HighlightingStream
+from ..loggerapi import LoggerApi
+
+
+class DottedOutput(LoggerApi):
+
+    def __init__(self, width=78, colors='AUTO', stdout=None, stderr=None):
+        self.width = width
+        self.stdout = HighlightingStream(stdout or sys.__stdout__, colors)
+        self.stderr = HighlightingStream(stderr or sys.__stderr__, colors)
+        self.markers_on_row = 0
+
+    def start_suite(self, data, result):
+        if not data.parent:
+            count = data.test_count
+            ts = ('test' if not data.rpa else 'task') + s(count)
+            self.stdout.write(f"Running suite '{result.name}' with {count} {ts}.\n")
+            self.stdout.write('=' * self.width + '\n')
+
+    def end_test(self, data, result):
+        if self.markers_on_row == self.width:
+            self.stdout.write('\n')
+            self.markers_on_row = 0
+        self.markers_on_row += 1
+        if result.passed:
+            self.stdout.write('.')
+        elif result.skipped:
+            self.stdout.highlight('s', 'SKIP')
+        elif result.tags.robot('exit'):
+            self.stdout.write('x')
+        else:
+            self.stdout.highlight('F', 'FAIL')
+
+    def end_suite(self, data, result):
+        if not data.parent:
+            self.stdout.write('\n')
+            StatusReporter(self.stdout, self.width).report(result)
+            self.stdout.write('\n')
+
+    def message(self, msg):
+        if msg.level in ('WARN', 'ERROR'):
+            self.stderr.error(msg.message, msg.level)
+
+    def output_file(self, name, path):
+        self.stdout.write(f"{name+':':8} {path}\n")
+
+
+class StatusReporter(SuiteVisitor):
+
+    def __init__(self, stream, width):
+        self.stream = stream
+        self.width = width
+
+    def report(self, suite: TestSuite):
+        suite.visit(self)
+        stats = suite.statistics
+        ts = ('test' if not suite.rpa else 'task') + s(stats.total)
+        elapsed = secs_to_timestr(suite.elapsed_time)
+        self.stream.write(f"{'=' * self.width}\nRun suite '{suite.name}' with "
+                          f"{stats.total} {ts} in {elapsed}.\n\n")
+        ed = 'ED' if suite.status != 'SKIP' else 'PED'
+        self.stream.highlight(suite.status + ed, suite.status)
+        self.stream.write(f'\n{stats.message}\n')
+
+    def visit_test(self, test: TestCase):
+        if test.failed and not test.tags.robot('exit'):
+            self.stream.write('-' * self.width + '\n')
+            self.stream.highlight('FAIL')
+            self.stream.write(f': {test.full_name}\n{test.message.strip()}\n')

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/output/console/quiet.py

@@ -16,9 +16,10 @@
 import sys
 
 from .highlighting import HighlightingStream
+from ..loggerapi import LoggerApi
 
 
-class QuietOutput:
+class QuietOutput(LoggerApi):
 
     def __init__(self, colors='AUTO', stderr=None):
         self._stderr = HighlightingStream(stderr or sys.__stderr__, colors)
@@ -28,5 +29,5 @@ class QuietOutput:
             self._stderr.error(msg.message, msg.level)
 
 
-class NoOutput:
+class NoOutput(LoggerApi):
     pass

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/output/console/verbose.py

@@ -16,58 +16,58 @@
 import sys
 
 from robot.errors import DataError
-from robot.utils import (get_console_length, getshortdoc, isatty,
-                         pad_console_length)
+from robot.utils import get_console_length, getshortdoc, isatty, pad_console_length
 
 from .highlighting import HighlightingStream
+from ..loggerapi import LoggerApi
 
 
-class VerboseOutput:
+class VerboseOutput(LoggerApi):
 
     def __init__(self, width=78, colors='AUTO', markers='AUTO', stdout=None,
                  stderr=None):
-        self._writer = VerboseWriter(width, colors, markers, stdout, stderr)
-        self._started = False
-        self._started_keywords = 0
-        self._running_test = False
-
-    def start_suite(self, suite):
-        if not self._started:
-            self._writer.suite_separator()
-            self._started = True
-        self._writer.info(suite.longname, suite.doc, start_suite=True)
-        self._writer.suite_separator()
-
-    def end_suite(self, suite):
-        self._writer.info(suite.longname, suite.doc)
-        self._writer.status(suite.status)
-        self._writer.message(suite.full_message)
-        self._writer.suite_separator()
-
-    def start_test(self, test):
-        self._writer.info(test.name, test.doc)
-        self._running_test = True
-
-    def end_test(self, test):
-        self._writer.status(test.status, clear=True)
-        self._writer.message(test.message)
-        self._writer.test_separator()
-        self._running_test = False
-
-    def start_keyword(self, kw):
-        self._started_keywords += 1
-
-    def end_keyword(self, kw):
-        self._started_keywords -= 1
-        if self._running_test and not self._started_keywords:
-            self._writer.keyword_marker(kw.status)
+        self.writer = VerboseWriter(width, colors, markers, stdout, stderr)
+        self.started = False
+        self.started_keywords = 0
+        self.running_test = False
+
+    def start_suite(self, data, result):
+        if not self.started:
+            self.writer.suite_separator()
+            self.started = True
+        self.writer.info(data.full_name, result.doc, start_suite=True)
+        self.writer.suite_separator()
+
+    def end_suite(self, data, result):
+        self.writer.info(data.full_name, result.doc)
+        self.writer.status(result.status)
+        self.writer.message(result.full_message)
+        self.writer.suite_separator()
+
+    def start_test(self, data, result):
+        self.writer.info(result.name, result.doc)
+        self.running_test = True
+
+    def end_test(self, data, result):
+        self.writer.status(result.status, clear=True)
+        self.writer.message(result.message)
+        self.writer.test_separator()
+        self.running_test = False
+
+    def start_body_item(self, data, result):
+        self.started_keywords += 1
+
+    def end_body_item(self, data, result):
+        self.started_keywords -= 1
+        if self.running_test and not self.started_keywords:
+            self.writer.keyword_marker(result.status)
 
     def message(self, msg):
         if msg.level in ('WARN', 'ERROR'):
-            self._writer.error(msg.message, msg.level, clear=self._running_test)
+            self.writer.error(msg.message, msg.level, clear=self.running_test)
 
     def output_file(self, name, path):
-        self._writer.output(name, path)
+        self.writer.output(name, path)
 
 
 class VerboseWriter:
@@ -75,10 +75,10 @@ class VerboseWriter:
 
     def __init__(self, width=78, colors='AUTO', markers='AUTO', stdout=None,
                  stderr=None):
-        self._width = width
-        self._stdout = HighlightingStream(stdout or sys.__stdout__, colors)
-        self._stderr = HighlightingStream(stderr or sys.__stderr__, colors)
-        self._keyword_marker = KeywordMarker(self._stdout, markers)
+        self.width = width
+        self.stdout = HighlightingStream(stdout or sys.__stdout__, colors)
+        self.stderr = HighlightingStream(stderr or sys.__stderr__, colors)
+        self._keyword_marker = KeywordMarker(self.stdout, markers)
         self._last_info = None
 
     def info(self, name, doc, start_suite=False):
@@ -88,18 +88,18 @@ class VerboseWriter:
         self._keyword_marker.reset_count()
 
     def _write_info(self):
-        self._stdout.write(self._last_info)
+        self.stdout.write(self._last_info)
 
     def _get_info_width_and_separator(self, start_suite):
         if start_suite:
-            return self._width, '\n'
-        return self._width - self._status_length - 1, ' '
+            return self.width, '\n'
+        return self.width - self._status_length - 1, ' '
 
     def _get_info(self, name, doc, width):
         if get_console_length(name) > width:
             return pad_console_length(name, width)
         doc = getshortdoc(doc, linesep=' ')
-        info = '%s :: %s' % (name, doc) if doc else name
+        info = f'{name} :: {doc}' if doc else name
         return pad_console_length(info, width)
 
     def suite_separator(self):
@@ -109,14 +109,14 @@ class VerboseWriter:
         self._fill('-')
 
     def _fill(self, char):
-        self._stdout.write('%s\n' % (char * self._width))
+        self.stdout.write(f'{char * self.width}\n')
 
     def status(self, status, clear=False):
         if self._should_clear_markers(clear):
             self._clear_status()
-        self._stdout.write('| ', flush=False)
-        self._stdout.highlight(status, flush=False)
-        self._stdout.write(' |\n')
+        self.stdout.write('| ', flush=False)
+        self.stdout.highlight(status, flush=False)
+        self.stdout.write(' |\n')
 
     def _should_clear_markers(self, clear):
         return clear and self._keyword_marker.marking_enabled
@@ -126,12 +126,12 @@ class VerboseWriter:
         self._write_info()
 
     def _clear_info(self):
-        self._stdout.write('\r%s\r' % (' ' * self._width))
+        self.stdout.write(f"\r{' ' * self.width}\r")
         self._keyword_marker.reset_count()
 
     def message(self, message):
         if message:
-            self._stdout.write(message.strip() + '\n')
+            self.stdout.write(message.strip() + '\n')
 
     def keyword_marker(self, status):
         if self._keyword_marker.marker_count == self._status_length:
@@ -142,18 +142,18 @@ class VerboseWriter:
     def error(self, message, level, clear=False):
         if self._should_clear_markers(clear):
             self._clear_info()
-        self._stderr.error(message, level)
+        self.stderr.error(message, level)
         if self._should_clear_markers(clear):
             self._write_info()
 
     def output(self, name, path):
-        self._stdout.write('%-8s %s\n' % (name+':', path))
+        self.stdout.write(f"{name+':':8} {path}\n")
 
 
 class KeywordMarker:
 
     def __init__(self, highlighter, markers):
-        self._highlighter = highlighter
+        self.highlighter = highlighter
         self.marking_enabled = self._marking_enabled(markers, highlighter)
         self.marker_count = 0
 
@@ -164,13 +164,13 @@ class KeywordMarker:
         try:
             return options[markers.upper()]
         except KeyError:
-            raise DataError("Invalid console marker value '%s'. Available "
-                            "'AUTO', 'ON' and 'OFF'." % markers)
+            raise DataError(f"Invalid console marker value '{markers}'. "
+                            f"Available 'AUTO', 'ON' and 'OFF'.")
 
     def mark(self, status):
         if self.marking_enabled:
             marker, status = ('.', 'PASS') if status != 'FAIL' else ('F', 'FAIL')
-            self._highlighter.highlight(marker, status)
+            self.highlighter.highlight(marker, status)
             self.marker_count += 1
 
     def reset_count(self):