Fix misspelling of "tainted" word

Signed-off-by: Andrea Cervesato <andrea.cervesato@suse.com>

Author: acerv

ltp/dispatcher.py

@@ -360,12 +360,12 @@ def _run_test(self, test: Test) -> TestResults:
 
         test_data = None
 
-        # check for tained kernel status
-        tained_code_before, tained_msg_before = self._sut.get_tained_info()
-        if tained_msg_before:
-            for msg in tained_msg_before:
-                ltp.events.fire("kernel_tained", msg)
-                self._logger.debug("Kernel tained before test: %s", msg)
+        # check for tainted kernel status
+        tainted_code_before, tainted_msg_before = self._sut.get_tainted_info()
+        if tainted_msg_before:
+            for msg in tainted_msg_before:
+                ltp.events.fire("kernel_tainted", msg)
+                self._logger.debug("Kernel tainted before test: %s", msg)
 
         timed_out = False
         reboot = False
@@ -396,14 +396,15 @@ def _run_test(self, test: Test) -> TestResults:
             self._logger.debug("Kernel panic recognized")
 
         if not reboot:
-            # check again for tained kernel and if tained status has changed
+            # check again for tainted kernel and if tainted status has changed
             # just raise an exception and reboot the SUT
-            tained_code_after, tained_msg_after = self._sut.get_tained_info()
-            if tained_code_before != tained_code_after:
+            tainted_code_after, tainted_msg_after = \
+                self._sut.get_tainted_info()
+            if tainted_code_before != tainted_code_after:
                 reboot = True
-                for msg in tained_msg_after:
-                    ltp.events.fire("kernel_tained", msg)
-                    self._logger.debug("Kernel tained after test: %s", msg)
+                for msg in tainted_msg_after:
+                    ltp.events.fire("kernel_tainted", msg)
+                    self._logger.debug("Kernel tainted after test: %s", msg)
 
         if timed_out:
             test_data = {

ltp/sut.py

@@ -45,7 +45,7 @@ def flush(self) -> None:
         raise NotImplementedError()
 
 
-TAINED_MSG = [
+TAINTED_MSG = [
     "proprietary module was loaded",
     "module was force loaded",
     "kernel running on an out of specification system",
@@ -242,25 +242,25 @@ def _run_cmd(cmd: str) -> str:
 
         return ret
 
-    def get_tained_info(self) -> set:
+    def get_tainted_info(self) -> set:
         """
-        Return information about kernel if tained.
+        Return information about kernel if tainted.
         :returns: set(int, list[str]),
         """
         ret = self.run_command("cat /proc/sys/kernel/tainted", timeout=3)
         if ret["returncode"] != 0:
-            raise SUTError("Can't read tained kernel information")
+            raise SUTError("Can't read tainted kernel information")
 
         stdout = ret["stdout"].rstrip()
 
-        tained_num = len(TAINED_MSG)
+        tainted_num = len(TAINTED_MSG)
         code = int(stdout.rstrip())
-        bits = format(code, f"0{tained_num}b")[::-1]
+        bits = format(code, f"0{tainted_num}b")[::-1]
 
         messages = []
-        for i in range(0, tained_num):
+        for i in range(0, tainted_num):
             if bits[i] == "1":
-                msg = TAINED_MSG[i]
+                msg = TAINTED_MSG[i]
                 messages.append(msg)
 
         return code, messages

ltp/tests/sut.py

@@ -71,12 +71,12 @@ def test_get_info(self, sut):
         assert info["kernel"]
         assert info["arch"]
 
-    def test_get_tained_info(self, sut):
+    def test_get_tainted_info(self, sut):
         """
-        Test get_tained_info.
+        Test get_tainted_info.
         """
         sut.communicate(iobuffer=Printer())
-        code, messages = sut.get_tained_info()
+        code, messages = sut.get_tainted_info()
 
         assert code >= 0
         assert isinstance(messages, list)

ltp/tests/test_dispatcher.py

@@ -131,7 +131,7 @@ def test_exec_suites_bad_args(self, tmpdir, sut):
             ltpdir=str(tmpdir / "ltp"),
             sut=sut)
 
-        sut.get_tained_info = MagicMock(return_value=(0, ""))
+        sut.get_tainted_info = MagicMock(return_value=(0, ""))
 
         try:
             with pytest.raises(ValueError):
@@ -152,7 +152,7 @@ def test_exec_suites(self, tmpdir, sut):
             ltpdir=str(tmpdir / "ltp"),
             sut=sut)
 
-        sut.get_tained_info = MagicMock(return_value=(0, ""))
+        sut.get_tainted_info = MagicMock(return_value=(0, ""))
 
         try:
             results = dispatcher.exec_suites(suites=["dirsuite0", "dirsuite2"])
@@ -194,7 +194,7 @@ def stop_exec_suites(_):
 
         ltp.events.register("test_started", stop_exec_suites)
 
-        sut.get_tained_info = MagicMock(return_value=(0, ""))
+        sut.get_tainted_info = MagicMock(return_value=(0, ""))
 
         results = dispatcher.exec_suites(suites=["dirsuite0", "dirsuite2"])
 
@@ -212,7 +212,7 @@ def test_exec_suites_all(self, tmpdir, sut):
             ltpdir=str(tmpdir / "ltp"),
             sut=sut)
 
-        sut.get_tained_info = MagicMock(return_value=(0, ""))
+        sut.get_tainted_info = MagicMock(return_value=(0, ""))
 
         try:
             results = dispatcher.exec_suites(suites=[
@@ -289,7 +289,7 @@ def test_exec_suites_suite_timeout(self, tmpdir, sut):
             suite_timeout=0.5,
             test_timeout=15)
 
-        sut.get_tained_info = MagicMock(return_value=(0, ""))
+        sut.get_tainted_info = MagicMock(return_value=(0, ""))
 
         try:
             with pytest.raises(SuiteTimeoutError):
@@ -315,7 +315,7 @@ def test_exec_suites_test_timeout(self, tmpdir, sut):
             suite_timeout=15,
             test_timeout=0.5)
 
-        sut.get_tained_info = MagicMock(return_value=(0, ""))
+        sut.get_tainted_info = MagicMock(return_value=(0, ""))
 
         try:
             ret = dispatcher.exec_suites(suites=["sleepsuite"])
@@ -325,9 +325,9 @@ def test_exec_suites_test_timeout(self, tmpdir, sut):
         assert ret[0].tests_results[0].return_code == -1
 
     @pytest.mark.usefixtures("prepare_tmpdir")
-    def test_kernel_tained(self, tmpdir, sut):
+    def test_kernel_tainted(self, tmpdir, sut):
         """
-        Test tained kernel recognition.
+        Test tainted kernel recognition.
         """
         ltpdir = tmpdir / "ltp"
 
@@ -338,46 +338,46 @@ def test_kernel_tained(self, tmpdir, sut):
             suite_timeout=0.5,
             test_timeout=15)
 
-        class TainChecker:
+        class TaintChecker:
             def __init__(self, dispatcher, bit, msg) -> None:
                 self._dispatcher = dispatcher
                 self._bit = bit
                 self._msg = msg
                 self._first = True
-                self.tained_msg = queue.Queue()
+                self.tainted_msg = queue.Queue()
                 self.rebooted = queue.Queue()
 
-            def kernel_tained(self, msg: str):
+            def kernel_tainted(self, msg: str):
                 if self._first:
                     self._first = False
 
-                    # now we change tained information to trigger
+                    # now we change tainted information to trigger
                     # sut_restart event
-                    sut.get_tained_info = MagicMock(
+                    sut.get_tainted_info = MagicMock(
                         return_value=(self._bit, [self._msg]))
                 else:
-                    self.tained_msg.put(msg)
+                    self.tainted_msg.put(msg)
 
             def sut_restart(self, name: str):
                 self.rebooted.put(True)
 
         try:
             for i in range(0, 18):
                 bit = math.pow(2, i)
-                msg = ltp.sut.TAINED_MSG[i]
+                msg = ltp.sut.TAINTED_MSG[i]
 
-                sut.get_tained_info = MagicMock(return_value=(0, [""]))
+                sut.get_tainted_info = MagicMock(return_value=(0, [""]))
 
-                checker = TainChecker(dispatcher, bit, msg)
-                ltp.events.register("kernel_tained", checker.kernel_tained)
+                checker = TaintChecker(dispatcher, bit, msg)
+                ltp.events.register("kernel_tainted", checker.kernel_tainted)
                 ltp.events.register("sut_restart", checker.sut_restart)
 
                 dispatcher.exec_suites(suites=["dirsuite0"])
 
-                assert checker.tained_msg.get() == msg
+                assert checker.tainted_msg.get() == msg
                 assert checker.rebooted.get()
 
-                ltp.events.unregister("kernel_tained")
+                ltp.events.unregister("kernel_tainted")
                 ltp.events.unregister("sut_restart")
         finally:
             sut.stop()
@@ -404,7 +404,7 @@ def test_kernel_panic(self, tmpdir, sut):
             suite_timeout=10,
             test_timeout=10)
 
-        sut.get_tained_info = MagicMock(return_value=(0, ""))
+        sut.get_tainted_info = MagicMock(return_value=(0, ""))
 
         class PanicChecker:
             def __init__(self) -> None:

ltp/ui.py

@@ -192,12 +192,12 @@ def __init__(self, no_colors: bool = False) -> None:
 
         self._sut_not_responding = False
         self._kernel_panic = False
-        self._kernel_tained = None
+        self._kernel_tainted = None
         self._timed_out = False
 
         ltp.events.register("sut_not_responding", self.sut_not_responding)
         ltp.events.register("kernel_panic", self.kernel_panic)
-        ltp.events.register("kernel_tained", self.kernel_tained)
+        ltp.events.register("kernel_tainted", self.kernel_tainted)
         ltp.events.register("test_timed_out", self.test_timed_out)
         ltp.events.register("test_started", self.test_started)
         ltp.events.register("test_completed", self.test_completed)
@@ -208,8 +208,8 @@ def sut_not_responding(self) -> None:
     def kernel_panic(self) -> None:
         self._kernel_panic = True
 
-    def kernel_tained(self, message: str) -> None:
-        self._kernel_tained = message
+    def kernel_tainted(self, message: str) -> None:
+        self._kernel_tainted = message
 
     def test_timed_out(self, _: Test, timeout: int) -> None:
         self._timed_out = True
@@ -242,16 +242,16 @@ def test_completed(self, results: TestResults) -> None:
 
             self._print(msg, color=col, end="")
 
-            if self._kernel_tained:
+            if self._kernel_tainted:
                 self._print(" | ", end="")
-                self._print("tained", color=self.YELLOW, end="")
+                self._print("tainted", color=self.YELLOW, end="")
 
             uf_time = self._user_friendly_duration(results.exec_time)
             self._print(f"  ({uf_time})")
 
         self._sut_not_responding = False
         self._kernel_panic = False
-        self._kernel_tained = None
+        self._kernel_tainted = None
         self._timed_out = False
 
 
@@ -266,7 +266,7 @@ def __init__(self, no_colors: bool = False) -> None:
         self._timed_out = False
 
         ltp.events.register("sut_stdout_line", self.sut_stdout_line)
-        ltp.events.register("kernel_tained", self.kernel_tained)
+        ltp.events.register("kernel_tainted", self.kernel_tainted)
         ltp.events.register("test_timed_out", self.test_timed_out)
         ltp.events.register("test_started", self.test_started)
         ltp.events.register("test_completed", self.test_completed)
@@ -275,7 +275,7 @@ def __init__(self, no_colors: bool = False) -> None:
     def sut_stdout_line(self, _: str, data: str) -> None:
         self._print_stdout(data)
 
-    def kernel_tained(self, message: str) -> None:
+    def kernel_tainted(self, message: str) -> None:
         self._print(f"Tained kernel: {message}", color=self.YELLOW)
 
     def test_timed_out(self, _: Test, timeout: int) -> None: