robotframework-nl 3.0.0__tar.gz → 3.2.0__tar.gz

{robotframework-nl-3.0.0/robotframework_nl.egg-info → robotframework_nl-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: robotframework-nl
-Version: 3.0.0
+Version: 3.2.0
 Summary: robotnl is a proving ground to boost Robot framework closer to Natural Language.
 Author-email: Johan Foederer <github@famfoe.nl>
 License: BSD 3-Clause License
@@ -42,14 +42,15 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: robotframework>=7.0
+Dynamic: license-file
 
-# robotframeworkNL - the oneliner
-robotframeworkNL is a proving ground to boost Robot framework closer to Natural Language.
+# RobotNL - the oneliner
+RobotNL is a proving ground to boost Robot framework closer to Natural Language.
 
 ## Introduction
 This project is an extension to [Robot framework](https://robotframework.org/) and although [Robot framework](https://robotframework.org/) made a very good step towards the goals of [keyword-driven testing ](https://en.wikipedia.org/wiki/Keyword-driven_testing) to make it readable for all stakeholders, there is still quite a lot of syntax involved that keeps test cases from really staying concise and to-the-point. In this project we will be introducing concepts to lift [Robot framework](https://robotframework.org/) to an even higher level.
 
-This second release introduces ``inline keywords`` and a set of  ``Check that`` keywords that help to vastly reduce the amount of ``${...}`` cluttering in your test cases. Combining these concepts helps to write a cleaner [Domain Specific Language](https://en.wikipedia.org/wiki/Domain-specific_language) around your [domain vocabulary](https://en.wikipedia.org/wiki/Jargon).
+This release introduces ``inline keywords`` and a set of  ``Check that`` keywords that help to vastly reduce the amount of ``${...}`` cluttering in your test cases. Combining these concepts helps to write a cleaner [Domain Specific Language](https://en.wikipedia.org/wiki/Domain-specific_language) around your [domain vocabulary](https://en.wikipedia.org/wiki/Jargon).
 
 ## Installation
 The recommended installation method is using [pip](http://pip-installer.org)
@@ -100,17 +101,20 @@ Using *Check that* keywords offers a large reduction in the need for variables i
 
 ### Time constraints
 
-*Check that* offers support for executing checks that may take some time to complete. When using the optional `within` argument, followed by a time duration, *Check that* will apply *smart polling* to re-evaluate the expression and the keywords during the given period. Specifying the time limit is done using the standard [Robot Framework time format](https://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#toc-entry-176). It is advised to use a realistic time duration. This sets the correct expectation for the reader and helps robotnl optimise its polling algorithm.
+*Check that* offers support for executing checks that may take some time to complete. When using the optional `within` argument, followed by a time duration, *Check that* will apply *smart polling* to re-evaluate the expression and the keywords during the given period. Specifying the time limit is done using the standard [Robot Framework time format](https://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#toc-entry-176). It is advised to use a realistic time duration. This sets the correct expectation for the reader and helps RobotNL optimise its polling algorithm.
 
 |**Example using time constaints**||||||
 |---|---|---|---|---|---|
 | Request elevator at floor | 3 |||||
 | Check that | elevator doors are closed | within | 20 seconds ||
 | Check that | current elevator floor | equals | 3 | within | 1 minute |
+| Check that | elevator doors are opened | within | same timespan ||
+
+The last line in the example uses the special argument `same timespan` to indicate that this check is linked to the same time constraint as the previous check. So, once the doors are closed, the elevator should not only reach the requested floor within 1 minute, but also the doors should be opened within that same 1-minute timespan. To use `within    same timespan` you must have executed a check with a time constraint before. This is not necessarily the directly preceding line. The most recent time constraint set within scope is used as starting point. For test suites, that is the current test suite, for keywords that is the current keyword.
 
 ### Hybrid manual testing
 
-To manually interact with your automated test run during testing or test case development, robotnl offers the *Check manual* and *Check interactive* keywords. These keywords can be included at any point in the test case to suspend the test run at the current position for user input.
+To manually interact with your automated test run during testing or test case development, RobotNL offers the *Check manual* and *Check interactive* keywords. These keywords can be included at any point in the test case to suspend the test run at the current position for user input.
 
 ***Check Manual*** allows asking the tester a question. The question typically requests manual verification of an expected outcome. The answer will PASS or FAIL the test case, which is also reflected in the test report.
 

{robotframework-nl-3.0.0 → robotframework_nl-3.2.0}/README.md

@@ -1,10 +1,10 @@
-# robotframeworkNL - the oneliner
-robotframeworkNL is a proving ground to boost Robot framework closer to Natural Language.
+# RobotNL - the oneliner
+RobotNL is a proving ground to boost Robot framework closer to Natural Language.
 
 ## Introduction
 This project is an extension to [Robot framework](https://robotframework.org/) and although [Robot framework](https://robotframework.org/) made a very good step towards the goals of [keyword-driven testing ](https://en.wikipedia.org/wiki/Keyword-driven_testing) to make it readable for all stakeholders, there is still quite a lot of syntax involved that keeps test cases from really staying concise and to-the-point. In this project we will be introducing concepts to lift [Robot framework](https://robotframework.org/) to an even higher level.
 
-This second release introduces ``inline keywords`` and a set of  ``Check that`` keywords that help to vastly reduce the amount of ``${...}`` cluttering in your test cases. Combining these concepts helps to write a cleaner [Domain Specific Language](https://en.wikipedia.org/wiki/Domain-specific_language) around your [domain vocabulary](https://en.wikipedia.org/wiki/Jargon).
+This release introduces ``inline keywords`` and a set of  ``Check that`` keywords that help to vastly reduce the amount of ``${...}`` cluttering in your test cases. Combining these concepts helps to write a cleaner [Domain Specific Language](https://en.wikipedia.org/wiki/Domain-specific_language) around your [domain vocabulary](https://en.wikipedia.org/wiki/Jargon).
 
 ## Installation
 The recommended installation method is using [pip](http://pip-installer.org)
@@ -55,17 +55,20 @@ Using *Check that* keywords offers a large reduction in the need for variables i
 
 ### Time constraints
 
-*Check that* offers support for executing checks that may take some time to complete. When using the optional `within` argument, followed by a time duration, *Check that* will apply *smart polling* to re-evaluate the expression and the keywords during the given period. Specifying the time limit is done using the standard [Robot Framework time format](https://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#toc-entry-176). It is advised to use a realistic time duration. This sets the correct expectation for the reader and helps robotnl optimise its polling algorithm.
+*Check that* offers support for executing checks that may take some time to complete. When using the optional `within` argument, followed by a time duration, *Check that* will apply *smart polling* to re-evaluate the expression and the keywords during the given period. Specifying the time limit is done using the standard [Robot Framework time format](https://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#toc-entry-176). It is advised to use a realistic time duration. This sets the correct expectation for the reader and helps RobotNL optimise its polling algorithm.
 
 |**Example using time constaints**||||||
 |---|---|---|---|---|---|
 | Request elevator at floor | 3 |||||
 | Check that | elevator doors are closed | within | 20 seconds ||
 | Check that | current elevator floor | equals | 3 | within | 1 minute |
+| Check that | elevator doors are opened | within | same timespan ||
+
+The last line in the example uses the special argument `same timespan` to indicate that this check is linked to the same time constraint as the previous check. So, once the doors are closed, the elevator should not only reach the requested floor within 1 minute, but also the doors should be opened within that same 1-minute timespan. To use `within    same timespan` you must have executed a check with a time constraint before. This is not necessarily the directly preceding line. The most recent time constraint set within scope is used as starting point. For test suites, that is the current test suite, for keywords that is the current keyword.
 
 ### Hybrid manual testing
 
-To manually interact with your automated test run during testing or test case development, robotnl offers the *Check manual* and *Check interactive* keywords. These keywords can be included at any point in the test case to suspend the test run at the current position for user input.
+To manually interact with your automated test run during testing or test case development, RobotNL offers the *Check manual* and *Check interactive* keywords. These keywords can be included at any point in the test case to suspend the test run at the current position for user input.
 
 ***Check Manual*** allows asking the tester a question. The question typically requests manual verification of an expected outcome. The answer will PASS or FAIL the test case, which is also reflected in the test report.
 

{robotframework-nl-3.0.0 → robotframework_nl-3.2.0}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "robotframework-nl"
-version = "3.0.0"
+version = "3.2.0"
 description = "robotnl is a proving ground to boost Robot framework closer to Natural Language."
 readme = "README.md"
 authors = [{ name = "Johan Foederer", email = "github@famfoe.nl" }]

{robotframework-nl-3.0.0 → robotframework_nl-3.2.0/robotframework_nl.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: robotframework-nl
-Version: 3.0.0
+Version: 3.2.0
 Summary: robotnl is a proving ground to boost Robot framework closer to Natural Language.
 Author-email: Johan Foederer <github@famfoe.nl>
 License: BSD 3-Clause License
@@ -42,14 +42,15 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: robotframework>=7.0
+Dynamic: license-file
 
-# robotframeworkNL - the oneliner
-robotframeworkNL is a proving ground to boost Robot framework closer to Natural Language.
+# RobotNL - the oneliner
+RobotNL is a proving ground to boost Robot framework closer to Natural Language.
 
 ## Introduction
 This project is an extension to [Robot framework](https://robotframework.org/) and although [Robot framework](https://robotframework.org/) made a very good step towards the goals of [keyword-driven testing ](https://en.wikipedia.org/wiki/Keyword-driven_testing) to make it readable for all stakeholders, there is still quite a lot of syntax involved that keeps test cases from really staying concise and to-the-point. In this project we will be introducing concepts to lift [Robot framework](https://robotframework.org/) to an even higher level.
 
-This second release introduces ``inline keywords`` and a set of  ``Check that`` keywords that help to vastly reduce the amount of ``${...}`` cluttering in your test cases. Combining these concepts helps to write a cleaner [Domain Specific Language](https://en.wikipedia.org/wiki/Domain-specific_language) around your [domain vocabulary](https://en.wikipedia.org/wiki/Jargon).
+This release introduces ``inline keywords`` and a set of  ``Check that`` keywords that help to vastly reduce the amount of ``${...}`` cluttering in your test cases. Combining these concepts helps to write a cleaner [Domain Specific Language](https://en.wikipedia.org/wiki/Domain-specific_language) around your [domain vocabulary](https://en.wikipedia.org/wiki/Jargon).
 
 ## Installation
 The recommended installation method is using [pip](http://pip-installer.org)
@@ -100,17 +101,20 @@ Using *Check that* keywords offers a large reduction in the need for variables i
 
 ### Time constraints
 
-*Check that* offers support for executing checks that may take some time to complete. When using the optional `within` argument, followed by a time duration, *Check that* will apply *smart polling* to re-evaluate the expression and the keywords during the given period. Specifying the time limit is done using the standard [Robot Framework time format](https://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#toc-entry-176). It is advised to use a realistic time duration. This sets the correct expectation for the reader and helps robotnl optimise its polling algorithm.
+*Check that* offers support for executing checks that may take some time to complete. When using the optional `within` argument, followed by a time duration, *Check that* will apply *smart polling* to re-evaluate the expression and the keywords during the given period. Specifying the time limit is done using the standard [Robot Framework time format](https://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#toc-entry-176). It is advised to use a realistic time duration. This sets the correct expectation for the reader and helps RobotNL optimise its polling algorithm.
 
 |**Example using time constaints**||||||
 |---|---|---|---|---|---|
 | Request elevator at floor | 3 |||||
 | Check that | elevator doors are closed | within | 20 seconds ||
 | Check that | current elevator floor | equals | 3 | within | 1 minute |
+| Check that | elevator doors are opened | within | same timespan ||
+
+The last line in the example uses the special argument `same timespan` to indicate that this check is linked to the same time constraint as the previous check. So, once the doors are closed, the elevator should not only reach the requested floor within 1 minute, but also the doors should be opened within that same 1-minute timespan. To use `within    same timespan` you must have executed a check with a time constraint before. This is not necessarily the directly preceding line. The most recent time constraint set within scope is used as starting point. For test suites, that is the current test suite, for keywords that is the current keyword.
 
 ### Hybrid manual testing
 
-To manually interact with your automated test run during testing or test case development, robotnl offers the *Check manual* and *Check interactive* keywords. These keywords can be included at any point in the test case to suspend the test run at the current position for user input.
+To manually interact with your automated test run during testing or test case development, RobotNL offers the *Check manual* and *Check interactive* keywords. These keywords can be included at any point in the test case to suspend the test run at the current position for user input.
 
 ***Check Manual*** allows asking the tester a question. The question typically requests manual verification of an expected outcome. The answer will PASS or FAIL the test case, which is also reflected in the test report.
 

robotframework_nl-3.2.0/robotnl/CheckOperator.py

@@ -0,0 +1,394 @@
+# -*- coding: utf-8 -*-
+
+# BSD 3-Clause License
+#
+# Copyright (c) 2021, J. Foederer
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its
+#    contributors may be used to endorse or promote products derived from
+#    this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from robot.api import TypeInfo
+from robot.libraries.BuiltIn import BuiltIn
+from robot.running.arguments import TypeConverter
+from robot.utils import is_list_like
+
+from .inline_keywords import keyword
+
+class CheckOperator:
+    """
+    This class defines a set of commonly used operators for use by 'Check that'
+    and other check keywords
+    """
+
+    ################################################################################################
+    # Generic operators that can work on basically any object type
+    def equals(self, lValue, rValue):
+        """Checks whether the left and right side are equal to each other [`=`]
+
+        Applies Robot type conversions when executing the check.
+        Examples:
+        | `Check that` | 7 | `=` | 7 |
+        | `Check that` | ${7} | `=` | 7.0 |
+        | `Check that` | _Two times_ | 6 | `equals` | 12 |
+        | `Check that` | text | `equals` | TeXT |
+        """
+        return OperatorProxy("==").basicOperator(lValue, rValue)
+
+    def is_less_than(self, lValue, rValue):
+        """Checks whether the left side `is less than` or smaller than the right side [`<`]
+
+        Applies Robot type conversions when executing the check.
+        Examples:
+        | `Check that` | 2 | `<` | 4 |
+        | `Check that` | 2 | `is less than` | 4 |
+        """
+        return OperatorProxy("<").basicOperator(lValue, rValue)
+
+    def is_greater_than(self, lValue, rValue):
+        """Checks whether the left side `is greater than` or larger than the right side [`>`]
+
+        Applies Robot type conversions when executing the check.
+        Examples:
+        | `Check that` | 4 | `>` | 2 |
+        | `Check that` | 4 | `is greater than` | 2 |
+        """
+        return OperatorProxy(">").basicOperator(lValue, rValue)
+
+    def is_less_than_or_equal_to(self, lValue, rValue):
+        """Checks whether the left side `is less than or equal to` the right side [`≤`]
+
+        Applies Robot type conversions when executing the check.
+        Examples:
+        | `Check that` | 2 | `≤` | 2 |
+        | `Check that` | 2 | `is less than or equal to` | 4 |
+        """
+        return OperatorProxy("<=").basicOperator(lValue, rValue)
+
+    def is_greater_than_or_equal_to(self, lValue, rValue):
+        """Checks whether the left side `is greater than or equal to` the right side [`≥`]
+
+        Applies Robot type conversions when executing the check.
+        Examples:
+        | `Check that` | 4 | `≥` | 4 |
+        | `Check that` | 4 | `is greater than or equal to` | 2 |
+        """
+        return OperatorProxy(">=").basicOperator(lValue, rValue)
+
+    def does_not_equal(self, lValue, rValue):
+        """Checks whether the left side `does not equal`, i.e. is different from the right side [`≠`]
+
+        Applies Robot type conversions when executing the check.
+        Examples:
+        | `Check that` | 7 | `≠` | 13 |
+        | `Check that` | 7 | `≠` | 7.01 |
+        | `Check that` | _Two times_ | 6 | `does not equal` | 13 |
+        | `Check that` | random text | `does not equal` | my text |
+        """
+        return OperatorProxy("!=").basicOperator(lValue, rValue)
+
+    ################################################################################################
+    # Operators that work on text items str() or Unicode()
+    def contains_text(self, baseString, subString):
+        """Performs a case insensitive check whether the right side is a substring of the left side
+
+        Examples:
+        | `Check that` | the time is now | `contains text` | me |
+        | `Check that` | the time is now | `contains text` | ME |
+        | `Check That` | Robotstraße | `contains text` | Strasse |
+        """
+        try:
+            return self.contains_exact_text(baseString.casefold(), subString.casefold())
+        except:
+            return False
+
+    def contains_exact_text(self, baseString, subString):
+        """Performs a case sensitive check whether the right side is a substring of the left side
+
+        Examples:
+        | `Check that` | the time is now | `contains text` | me |
+        | `Check That` | Robotstraße | `contains text` | straße |
+        """
+        try:
+            return subString in baseString
+        except:
+            return False
+
+    def matches_without_case_to(self, leftText, rightText):
+        """Performs a case insensitive check whether the left and right side texts are equal
+
+        Examples:
+        | `Check that` | the time is now | `matches without case to` | the time is now |
+        | `Check that` | the time is now | `matches without case to` | THE TIME IS NOW |
+        | `Check That` | Robotstraße | `matches without case to` | ROBOTstrasse |
+        """
+        try:
+            return self.matches_with_case_to(leftText.casefold(), rightText.casefold())
+        except:
+            return False
+
+    def matches_with_case_to(self, leftText, rightText):
+        """Performs a case sensitive check whether the left and right side texts are equal
+
+        Examples:
+        | `Check that` | the time is now | `matches with case to` | the time is now |
+        | `Check That` | Robotstraße | `matches with case to` | Robotstraße |
+        """
+        return leftText == rightText
+
+    def does_not_contain_text(self, baseString, subString):
+        """Performs a case insensitive check whether the right side is not a substring of the left side
+
+        Examples:
+        | `Check that` | random text | `does not contain text` | my text |
+        """
+        return not self.contains_text(baseString, subString)
+
+    def does_not_contain_exact_text(self, baseString, subString):
+        """Performs a case sensitive check whether the right side is not a substring of the left side
+
+        Examples:
+        | `Check that` | random text | `does not contain exact text` | my text |
+        | `Check that` | random text | `does not contain exact text` | RANDOM text |
+        """
+        return not self.contains_exact_text(baseString, subString)
+
+    def does_not_match_without_case_to(self, leftText, rightText):
+        """Performs a case insensitive check whether the left and right side texts are different
+
+        Examples:
+        | `Check that` | random text | `does not match without case to` | my text |
+        """
+        return not self.matches_without_case_to(leftText, rightText)
+
+    def does_not_match_with_case_to(self, leftText, rightText):
+        """Performs a case sensitive check whether the left and right side texts are different
+
+        Examples:
+        | `Check that` | random text | `does not match with case to` | my text |
+        | `Check that` | random text | `does not match with case to` | RANDOM text |
+        """
+        return not self.matches_with_case_to(leftText, rightText)
+
+    ################################################################################################
+    # Operators that work on lists or other sequences
+    def is_empty(self, sequence):
+        """Checks whether the sequence on the left does not contain any items.
+
+        Example:
+        | Take a new suitcase |
+        | `Check that` | suitcase | `is empty` |
+        _Assumes a 'box' type to be defined with associated action and observation keywords._
+        """
+        return len(sequence) == 0
+
+    @keyword("contains ${n} items")
+    def contains_n_items(self, n:int, sequence):
+        """Checks whether the sequence on the left contains ${n} items. Uses python's len-operator
+        to count the number of items.
+
+        Example:
+        | `Check precondition` | suitcase | `is empty` |
+        | Put toothbrush into suitcase |
+        | `Check that` | suitcase | `contains 1 item` |
+        | Put t-shirt into suitcase |
+        | `Check that` | suitcase | `contains 2 items` |
+        _Assumes a 'suitcase' type to be defined with associated action and observation keywords._
+        """
+        count = len(sequence)
+        BuiltIn().log(f"Counted {count} items")
+        return count == n
+
+    def contains_1_item(self, sequence):
+        return self.contains_n_items(1, sequence)
+    contains_1_item.__doc__ = contains_n_items.__doc__
+
+    def contains(self, sequence, part):
+        """Checks whether part is present in sequence. Uses Python's primitive in-operator.
+
+        Example:
+        | Put toothbrush into suitcase |
+        | Put t-shirt into suitcase |
+        | `Check that` | suitcase | `contains` | toothbrush |
+        | `Check that` | suitcase | `contains` | t-shirt |
+        _Assumes a 'suitcase' type to be defined with associated action and observation keywords._
+        """
+        return part in sequence
+
+    def does_not_contain(self, sequence, part):
+        """Checks whether part is present in sequence. Uses Python's primitive 'not in' operator.
+
+        Example:
+        | `Check precondition` | suitcase | `is empty` |
+        | Put toothbrush into suitcase |
+        | `Check that` | suitcase | `does not contain` | t-shirt |
+        _Assumes a 'suitcase' type to be defined with associated action and observation keywords._
+        """
+        return part not in sequence
+
+    def contains_item(self, sequence, part):
+        """Checks whether the right side item(s) is/are part of the sequence on the left side.
+
+        `Contains item` and the plural `Contains items` are aliases. The difference with `Contains`
+        is that these iterate over the sequence and applies *automatic Robot type conversion*
+        between elements when applicable. Duplicate items from the right side can match a single
+        item from the left side.
+
+        Example:
+        | Put toothbrush into suitcase |
+        | Put t-shirt into suitcase |
+        | `Check that` | suitcase | `contains item` | toothbrush |
+        | `Check that` | suitcase | `contains items` | t-shirt | toothbrush |
+        | `Check that` | suitcase's lock code | `contains items` | 7 | ${2} |
+        _Assumes a 'suitcase' type to be defined with associated action and observation keywords._
+        """
+        if not is_list_like(part):
+            part = [part]
+        for elem in part:
+            BuiltIn().log(f"Processing '{elem}' from right side")
+            for item in sequence:
+                if self.equals(elem, item):
+                    BuiltIn().log("Matched")
+                    break
+                BuiltIn().log("No match")
+            else:
+                BuiltIn().log(f"{elem} not present in left side list")
+                return False
+        return True
+
+    # Alias for plural form
+    contains_items = contains_item
+
+    def contains_exactly_the_items_from(self, sequence, sequence_right):
+        """
+        Checks whether the sequence on the right side contains all items of the left side and vice versa.
+        Iterates over sequence on the left and matches each element with a single element on the right.
+        The items can be in any order. Automatic Robot type conversion is applied when applicable.
+
+        Example:
+        | `Check precondition` | suitcase | `is empty` |
+        | Put toothbrush into suitcase |
+        | Put t-shirt into suitcase |
+        | `Check that` | suitcase | `contains exactly the items from` | toothbrush | t-shirt |
+        | `Check that` | suitcase | `contains exactly the items from` | t-shirt | toothbrush |
+        | `Check that` | my packing list | `contains exactly the items from` | toothbrush | t-shirt |
+        | `Check that` | suitcase | `contains exactly the items from` | my packing list |
+        _Assumes a 'suitcase' type to be defined with associated action and observation keywords._
+        """
+        if isinstance(sequence_right, str):
+            sequence_right = [sequence_right]
+        sequence_right = [*sequence_right]
+        for item in sequence:
+            BuiltIn().log(f"Processing '{item}' from left side list")
+            for i in range(len(sequence_right)):
+                if self.equals(item, sequence_right[i]):
+                    sequence_right.pop(i)
+                    break
+            else:
+                BuiltIn().log(f"Item '{item}' from left side is not found in the list on the right side")
+                return False
+        if len(sequence_right) > 0:
+            BuiltIn().log(f"Not all items from right side list are present: {sequence_right}")
+            return False
+
+        return True
+
+    def does_not_contain_item(self, sequence, part):
+        """
+        Checks whether the right side item is not part of the sequence on the left side.
+        Iterates over the sequence and applies automatic Robot type conversion where applicable.
+
+        No plural variant is available for this keyword due to ambiguity with List-like values. When
+        writing "[2, 4, 6] does not contain items [4, 5, 6]", one could expect a pass, because the
+        set [4, 5, 6] is not contained, but also a fail because item 4 *is* part of the left side set.
+
+        Example:
+        | `Check precondition` | suitcase | `is empty` |
+        | Put toothbrush into suitcase |
+        | `Check that` | suitcase | `does not contain item` | t-shirt |
+        _Assumes a 'suitcase' type to be defined with associated action and observation keywords._
+        """
+        if is_list_like(part):
+            raise TypeError("List-like items not accepted as right side value")
+        return not self.contains_item(sequence, part)
+
+# Add operator keywords that do not comply to Python's identifier syntax
+setattr(CheckOperator, "=", CheckOperator.equals)
+setattr(CheckOperator, "<", CheckOperator.is_less_than)
+setattr(CheckOperator, ">", CheckOperator.is_greater_than)
+setattr(CheckOperator, "≤", CheckOperator.is_less_than_or_equal_to)
+setattr(CheckOperator, "≥", CheckOperator.is_greater_than_or_equal_to)
+setattr(CheckOperator, "≠", CheckOperator.does_not_equal)
+
+class OperatorProxy:
+    """
+    Proxy class for mapping generic Robot comparison keywords to Python operators
+    """
+    def __init__(self, s_operator):
+        self.__s_Operator = s_operator
+
+    @staticmethod
+    def __typeCastRobotStringValue(leadingValue, otherValue, name):
+        """
+        When Robot files are parsed, arguments are always passed as string even when comparing
+        numbers or other objects. When a string argument is detected the other argument is
+        deemed leading. This function converts the other argument to the leading value's type
+        when possible. Otherwise the value is kept unchanged, inevitably leading to a mismatch
+        in comparison.
+
+        Precondition: otherValue is of types str and supports .casefold()
+        returns type casted otherValue
+        """
+        CastedOther = otherValue # By default leave untouched
+        converter = TypeConverter.converter_for(TypeInfo.from_type(type(leadingValue)))
+        if converter:
+            try:
+                CastedOther = converter.convert(otherValue, name)
+            except ValueError as err:
+                BuiltIn().log(err, level='DEBUG')
+            BuiltIn().log(f"Comparing as {converter.type_name} values")
+
+        if isinstance(CastedOther, str):
+            # By default compare as case insensitive Unicode. Note that it already was a string.
+            BuiltIn().log(f"Interpreting {name} '{otherValue}' as string (case insensitive)")
+            CastedOther = str(otherValue).casefold()
+
+        return CastedOther
+
+    def basicOperator(self, lvalue, rvalue):
+        # Local argument copies for assignment
+        lValue = lvalue
+        rValue = rvalue
+
+        if type(lvalue) is str:
+            lValue = OperatorProxy.__typeCastRobotStringValue(rvalue, lvalue, "left operand")
+
+        if type(rvalue) is str:
+            rValue = OperatorProxy.__typeCastRobotStringValue(lvalue, rvalue, "right operand")
+
+        if lValue is lvalue and rValue is rvalue:
+            BuiltIn().log("Comparing values as is")
+
+        return eval(f"lValue {self.__s_Operator} rValue")

{robotframework-nl-3.0.0 → robotframework_nl-3.2.0}/robotnl/RobotChecks.py

@@ -38,6 +38,7 @@ except ImportError:
     tkinter = False
 
 from robot.libraries.BuiltIn import BuiltIn
+from robot.running import RUN_KW_REGISTER
 from robot.utils import timestr_to_secs, secs_to_timestr
 from .inline_keywords import is_keyword
 
@@ -47,7 +48,25 @@ class CheckFailed(RuntimeError):
 class RobotChecks:
     ROBOT_LIBRARY_SCOPE = "GLOBAL"
     def __init__(self):
+        self.ROBOT_LIBRARY_LISTENER = self
         self.__gui = None
+        self.scope_depth = 0
+        self.nested_timespans = {}
+
+    def _start_suite(self, data, result):
+        self.scope_depth = 0
+        self.nested_timespans = {}
+    _end_suite = _start_suite
+
+    def _start_keyword(self, data, result):
+        self.scope_depth += 1
+
+    def _end_keyword(self, data, result):
+        if self.scope_depth + 1 in self.nested_timespans:
+            # use depth+1 because 'check that' itself is also a keyword. The +1
+            # keeps all check thats on the same level grouped.
+            self.nested_timespans.pop(self.scope_depth + 1)
+        self.scope_depth -= 1
 
     @property
     def _gui(self):
@@ -73,10 +92,11 @@ class RobotChecks:
         point where it was able to check the requirement it was testing for.
         """
         try:
-            return RobotChecks.__execute_check("Precondition", *args)
+            return self.__execute_check("Precondition", *args)
         except CheckFailed as failure:
             failure.ROBOT_CONTINUE_ON_FAILURE = False
             raise failure
+    RUN_KW_REGISTER.register_run_keyword('robotnl', check_precondition.__name__, args_to_process=0, deprecation_warning=False)
 
     def check_postcondition(self, *args):
         """
@@ -89,10 +109,11 @@ class RobotChecks:
         the cause of failure.
         """
         try:
-            return RobotChecks.__execute_check("Postcondition", *args)
+            return self.__execute_check("Postcondition", *args)
         except CheckFailed as failure:
             failure.ROBOT_CONTINUE_ON_FAILURE = False
             raise failure
+    RUN_KW_REGISTER.register_run_keyword('robotnl', check_postcondition.__name__, args_to_process=0, deprecation_warning=False)
 
     def check_that(self, *args):
         """
@@ -105,37 +126,51 @@ class RobotChecks:
         Check that has two basic forms.
         - A single keyword (with its arguments) can be evaluated to a truth value
         - Two values or keywords (with their arguments) can be evaluated using an operator. It will
-          then have the form Check that ``<keyword or value>`` ``<operator>`` ``<keyword or value>``.
+          then have the form: Check that ``<keyword or value>`` ``<operator>`` ``<keyword or value>``.
 
-        Operator can be any Robot keyword taking exactly two values (left and right operands) as
-        input. A number of predefined operators on numeric, string and list types are included in
-        this library.
+        Operator can be any Robot keyword taking at least one argument as input. The first argument is
+        placed on the left side of the operator, the left operand. Any following arguments are placed
+        to the right of the operator and form the right operands. A keyword with its argument values is
+        treated as a single operand. A number of predefined operators on numeric, string and list types
+        are included in this library.
 
         Examples:
         | `Check that` | 3 | `=` | 3 |
-        | `Check that` | Two times | 6 | `equals` | 12 |
-        | `Check that` | Two times | 5 | `≠` | Two times | 7 |
-        | `Check that` | Earth exists |
+        | `Check that` | _Two times_ | 6 | `equals` | 12 |
+        | `Check that` | _Two times_ | 5 | `≠` | _Two times_ | 7 |
+        | `Check that` | _the shoe box_ | _contains 2 items_ |
+        | `Check that` | _Earth exists_ |
 
         'Two times' in these examples is assumed to be defined as a Robot keyword that takes one
-        argument and multiplies it by 2. Check that will pass if the evaluated result of Two times 6
-        equals the fixed expected value 12.
+        argument and multiplies it by 2. `Check that` will pass if the evaluated result of _Two
+        times_ 6 equals the fixed expected value 12.
 
         *Adding time constraints*:\n
                 Any check can be extended with an additional timing constraint by adding ``within``
                 This will cause the condition to be reevaluated until it becomes true, or until
                 the specified time has passed. In the latter case the test case will fail.
 
+                Multiple checks can be linked to the same time constraint by using ``same timespan``
+                as the time constraint value. Suppose the previous time constraint was 5 seconds
+                and that check took 2 seconds to complete. If the next check uses
+                ``within    same timespan``, then this check has the remaining 3 seconds to
+                complete.
+
         Example with time constraint:
-        | `Check that` | condition is true | within | 1 minute 30 seconds |
+        | `Check that` | _condition is true_ | within | 1 minute 30 seconds |
 
         Elevator example:
-        | `Check that` | elevator doors are closed |
-        | Request elevator at floor | 3 |
-        | `Check that` | elevator floor | `equals` | 3 | within | 20 seconds |
-        | `Check that` | offset to floor level in mm | `≤` | 5 | within | 3 seconds |
+        | _Request elevator at floor_ | 3 |
+        | `Check that` | _elevator doors are closed_ | within | 20 seconds |
+        | `Check that` | _elevator floor_ | `equals` | 3 | within | 1 minute |
+        | `Check that` | _elevator doors are opened_ | within | same timespan |
+
+        In the elevator example, the doors should be closed within 20 seconds after requesting a
+        floor. Then the elevator can take a maximum of 1 minute to reach the floor and open its
+        doors. `Check that` will continue as soon as the condition is detected.
         """
-        return RobotChecks.__execute_check("Requirement", *args)
+        return self.__execute_check("Requirement", *args)
+    RUN_KW_REGISTER.register_run_keyword('robotnl', check_that.__name__, args_to_process=0, deprecation_warning=False)
 
     def check_manual(self, checkRequestText=""):
         """
@@ -206,8 +241,7 @@ class RobotChecks:
                 except Exception as e:
                     BuiltIn().log_to_console("Error in interactive keyword '%s'\n\n%s" % (newInput, e))
 
-    @staticmethod
-    def __execute_check(checkType, *args):
+    def __execute_check(self, checkType, *args):
         """
         Parse arguments for check keyword to determine its operands, evaluate them and execute the
         check.
@@ -219,14 +253,35 @@ class RobotChecks:
         TimeOutInSeconds = 0
         TimeRemaining = True
         s_TimeConstraint = ""
+        StartTime = time.perf_counter()
         if len(Arguments) >= 2 and str(Arguments[-2]).lower() == 'within':
-            EvaluatedTimeArg = RobotChecks.__evaluateOperand([Arguments[-1]])[0]
-            TimeOutInSeconds = timestr_to_secs(EvaluatedTimeArg)
-            s_TimeConstraint = Arguments[-1]
+            timearg = Arguments[-1]
             Arguments = Arguments[:-2]
+            running_timespan_start, running_timespan, s_TimeConstraint =self.nested_timespans.get(
+                self.scope_depth, (None, None, ''))
+            if str(timearg).lower() == 'same timespan':
+                if running_timespan is None:
+                    BuiltIn().fail("Joint timespan expected, but was not set before this check.")
+                TimeOutInSeconds = round(running_timespan_start + running_timespan - StartTime, ndigits=3)
+
+                remaining = self._human_time(0 if TimeOutInSeconds < 0 else TimeOutInSeconds)
+                BuiltIn().log(f"Reusing joint timespan: {s_TimeConstraint}\n"
+                              f"Must complete within the remaining {remaining}")
+            else:
+                try:
+                    EvaluatedTimeArg, s_TimeConstraint = RobotChecks.__evaluateOperand([timearg])
+                    TimeOutInSeconds = timestr_to_secs(EvaluatedTimeArg)
+                except:
+                    # End any running timespan on error
+                    if self.scope_depth in self.nested_timespans:
+                        self.nested_timespans.pop(self.scope_depth)
+                    raise
+                if is_keyword(timearg):
+                    s_TimeConstraint = f"{timearg} [{secs_to_timestr(TimeOutInSeconds)}]"
+                self.nested_timespans[self.scope_depth] = (StartTime, TimeOutInSeconds, s_TimeConstraint)
 
         if not len(Arguments):
-            BuiltIn().fail("%s check failed. There was nothing to check." % checkType)
+            BuiltIn().fail(f"{checkType} check failed. There was nothing to check.")
 
         ############################################################################################
         # Build expression
@@ -259,8 +314,6 @@ class RobotChecks:
         # Evaluate expression
         EvaluatedResult = None
 
-        StartTime = time.perf_counter()
-        TimeLeft = TimeOutInSeconds
         PollMax = 20 # After 20s people start wondering: "Is it still going?" Time for an update.
         PollMin = min(PollMax/8, TimeOutInSeconds*3/100) # Shortest delay is 3% of the target time.
         PollDelay = PollMin # Initial poll delay will be 2x PollMin
@@ -308,8 +361,14 @@ class RobotChecks:
             ReportString = f"{checkType} check on '{s_LeftOperand} {OperatorKeyword} {s_RightOperand}'"
 
         if s_TimeConstraint:
-            ReportString += " within %s" % secs_to_timestr(TimeOutInSeconds)
+            running_start, timespan, timestr = self.nested_timespans.get(self.scope_depth, (None, None, ''))
+            if TimeRemaining and running_start != StartTime:
+                elapsed = time.perf_counter() - running_start
+                BuiltIn().log(f"Check completed {self._human_time(elapsed)} into the alotted timespan ({timestr})")
+            ReportString += f" within {timestr}"
             if not TimeRemaining and EvaluatedResult == "passed":
+                overshoot = time.perf_counter() - (running_start + timespan)
+                BuiltIn().log(f"Check completed {self._human_time(overshoot)} too late")
                 ReportString += " (too late)"
                 raise CheckFailed(ReportString)
 
@@ -352,3 +411,10 @@ class RobotChecks:
             s_Operand += f" [{s_Value}]"
 
         return Value, s_Operand
+
+    @staticmethod
+    def _human_time(time_in_seconds: float):
+        """return a human readable string for a time in seconds"""
+        SKIP_MILLI = 10  # Do not report milliseconds for timespans above SKIP_MILLI seconds
+        rounded_time = int(time_in_seconds) if time_in_seconds > SKIP_MILLI else round(time_in_seconds, ndigits=3)
+        return secs_to_timestr(rounded_time)

robotframework_nl-3.2.0/robotnl/version.py

@@ -0,0 +1 @@
+VERSION = '3.2.0'

robotframework-nl-3.0.0/robotnl/CheckOperator.py

@@ -1,228 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# BSD 3-Clause License
-#
-# Copyright (c) 2021, J. Foederer
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-# 1. Redistributions of source code must retain the above copyright notice, this
-#    list of conditions and the following disclaimer.
-#
-# 2. Redistributions in binary form must reproduce the above copyright notice,
-#    this list of conditions and the following disclaimer in the documentation
-#    and/or other materials provided with the distribution.
-#
-# 3. Neither the name of the copyright holder nor the names of its
-#    contributors may be used to endorse or promote products derived from
-#    this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-from robot.api import TypeInfo
-from robot.libraries.BuiltIn import BuiltIn
-from robot.running.arguments import TypeConverter
-
-
-class CheckOperator:
-    """
-    This class defines a set of commonly used operators for use by 'Check that'
-    and other check keywords
-    """
-
-    ################################################################################################
-    # Generic operators that can work on basically any object type
-    def equals(self, lValue, rValue):
-        """Checks whether the left and right side are equal to each other [=]"""
-        return OperatorProxy("==").basicOperator(lValue, rValue)
-
-    def is_less_than(self, lValue, rValue):
-        """Checks whether the left side is less than or smaller than the right side [<]"""
-        return OperatorProxy("<").basicOperator(lValue, rValue)
-
-    def is_greater_than(self, lValue, rValue):
-        """Checks whether the left side is greater than or larger than the right side [>]"""
-        return OperatorProxy(">").basicOperator(lValue, rValue)
-
-    def is_less_than_or_equal_to(self, lValue, rValue):
-        """Checks whether the left side is less than or equal to the right side [≤]"""
-        return OperatorProxy("<=").basicOperator(lValue, rValue)
-
-    def is_greater_than_or_equal_to(self, lValue, rValue):
-        """Checks whether the left side is greater than or equal to the right side [≥]"""
-        return OperatorProxy(">=").basicOperator(lValue, rValue)
-
-    def does_not_equal(self, lValue, rValue):
-        """Checks whether the left side is different from the right side [≠]"""
-        return OperatorProxy("!=").basicOperator(lValue, rValue)
-
-    ################################################################################################
-    # Operators that work on text items str() or Unicode()
-    def contains_text(self, baseString, subString):
-        """Performs a case insensitive check whether the right side is a substring of the left side"""
-        try:
-            return self.contains_exact_text(baseString.lower(), subString.lower())
-        except:
-            return False
-
-    def contains_exact_text(self, baseString, subString):
-        """Performs a case sensitive check whether the right side is a substring of the left side"""
-        try:
-            return subString in baseString
-        except:
-            return False
-
-    def matches_without_case_to(self, leftText, rightText):
-        """Performs a case insensitive check whether the left and right side texts are equal"""
-        try:
-            return self.matches_with_case_to(leftText.lower(), rightText.lower())
-        except:
-            return False
-
-    def matches_with_case_to(self, leftText, rightText):
-        """Performs a case sensitive check whether the left and right side texts are equal"""
-        return leftText == rightText
-
-    def does_not_contain_text(self, baseString, subString):
-        """Performs a case insensitive check whether the right side is not a substring of the left side"""
-        return not self.contains_text(baseString, subString)
-
-    def does_not_contain_exact_text(self, baseString, subString):
-        """Performs a case sensitive check whether the right side is not a substring of the left side"""
-        return not self.contains_exact_text(baseString, subString)
-
-    def does_not_match_without_case_to(self, leftText, rightText):
-        """Performs a case insensitive check whether the left and right side texts are different"""
-        return not self.matches_without_case_to(leftText, rightText)
-
-    def does_not_match_with_case_to(self, leftText, rightText):
-        """Performs a case sensitive check whether the left and right side texts are different"""
-        return not self.matches_with_case_to(leftText, rightText)
-
-    ################################################################################################
-    # Operators that work on lists or other sequences
-    def is_empty(self, iterable):
-        return len(iterable) == 0
-
-    def contains(self, iterable, part):
-        """Checks whether part is present in iterable. Uses primitive 'in' operator."""
-        return part in iterable
-
-    def does_not_contain(self, iterable, part):
-        """Checks whether part is present in iterable. Uses primitive 'not in' operator."""
-        return part not in iterable
-
-    def contains_item(self, sequence, part):
-        """
-        Checks whether the right side item is part of the sequence on the left side.
-        Iterates over the sequence to apply automatic Robot type conversion where applicable.
-        """
-        for item in sequence:
-            BuiltIn().log(f"Processing '{item}' from list")
-            if self.equals(part, item):
-                BuiltIn().log("Matched")
-                return True
-            BuiltIn().log("No match")
-        return False
-
-    def contains_exactly_the_items_from(self, sequence, sequence_right):
-        """
-        Checks whether the sequence on the right side contains all items of the left side and vice versa.
-        Iterates over sequence on the left and matches each element with a single element on the right.
-        """
-        if isinstance(sequence_right, str):
-            sequence_right = [sequence_right]
-        sequence_right = [*sequence_right]
-        for item in sequence:
-            item_found_in_parts = False
-            BuiltIn().log(f"Processing '{item}' from left side list")
-            for i in range(len(sequence_right)):
-                if self.equals(item, sequence_right[i]):
-                    sequence_right.pop(i)
-                    item_found_in_parts = True
-                    break
-            if not item_found_in_parts:
-                BuiltIn().log(f"Item '{item}' from left side is not found in the list on the right side")
-                return False
-        if len(sequence_right) > 0:
-            BuiltIn().log(f"Not all items from right side list are present: {sequence_right}")
-            return False
-
-        return True
-
-    def does_not_contain_item(self, sequence, part):
-        """
-        Checks whether the right side item is not part of the sequence on the left side.
-        Iterates over the sequence to apply automatic Robot type conversion where applicable.
-        """
-        return not self.contains_item(sequence, part)
-
-# Add operator keywords that do not comply to Python's identifier syntax
-setattr(CheckOperator, "=", CheckOperator.equals)
-setattr(CheckOperator, "<", CheckOperator.is_less_than)
-setattr(CheckOperator, ">", CheckOperator.is_greater_than)
-setattr(CheckOperator, "≤", CheckOperator.is_less_than_or_equal_to)
-setattr(CheckOperator, "≥", CheckOperator.is_greater_than_or_equal_to)
-setattr(CheckOperator, "≠", CheckOperator.does_not_equal)
-
-class OperatorProxy:
-    """
-    Proxy class for mapping generic Robot comparison keywords to Python operators
-    """
-    def __init__(self, s_operator):
-        self.__s_Operator = s_operator
-
-    @staticmethod
-    def __typeCastRobotStringValue(leadingValue, otherValue, name):
-        """
-        When Robot files are parsed, arguments are always passed as string even when comparing
-        numbers or other objects. When a string argument is detected the other argument is
-        deemed leading. This function converts the other argument to the leading value's type
-        when possible. Otherwise the value is kept unchanged, inevitably leading to a mismatch
-        in comparison.
-
-        Precondition: otherValue is of types str and supports .casefold()
-        returns type casted otherValue
-        """
-        CastedOther = otherValue # By default leave untouched
-        converter = TypeConverter.converter_for(TypeInfo.from_type(type(leadingValue)))
-        if converter:
-            try:
-                CastedOther = converter.convert(otherValue, name)
-            except ValueError as err:
-                BuiltIn().log(err, level='DEBUG')
-            BuiltIn().log(f"Comparing as {converter.type_name} values")
-
-        if isinstance(CastedOther, str):
-            # By default compare as case insensitive Unicode. Note that it already was a string.
-            BuiltIn().log(f"Interpreting {name} '{otherValue}' as string (case insensitive)")
-            CastedOther = str(otherValue).casefold()
-
-        return CastedOther
-
-    def basicOperator(self, lvalue, rvalue):
-        # Local argument copies for assignment
-        lValue = lvalue
-        rValue = rvalue
-
-        if type(lvalue) is str:
-            lValue = OperatorProxy.__typeCastRobotStringValue(rvalue, lvalue, "left operand")
-
-        if type(rvalue) is str:
-            rValue = OperatorProxy.__typeCastRobotStringValue(lvalue, rvalue, "right operand")
-
-        if lValue is lvalue and rValue is rvalue:
-            BuiltIn().log("Comparing values as is")
-
-        return eval(f"lValue {self.__s_Operator} rValue")

robotframework-nl-3.0.0/robotnl/version.py

@@ -1 +0,0 @@
-VERSION = '3.0.0'