Fix the strict notation functional tests

Author: Pierre-Sassoulas

doc/data/messages/b/bad-float-notation/good/pep515.py

@@ -1,3 +1 @@
 proper_grouping = 123_456_789
-scientific_notation = 1.2345678e16
-engineering_notation = 12.345678e15

pylint/checkers/format.py

@@ -313,22 +313,29 @@ def open(self) -> None:
         scientific = self.linter.config.strict_scientific_notation
         engineering = self.linter.config.strict_engineering_notation
         underscore = self.linter.config.strict_underscore_notation
-        float_config = sum([scientific, engineering, underscore])
-        if float_config > 1:
+        number_of_strict_float_notation = sum([scientific, engineering, underscore])
+        if number_of_strict_float_notation > 1:
             raise ValueError(
                 "Only one of strict-scientific-notation, "
-                "strict-engineering-notation, or strict-underscore-notation "
+                "'strict-engineering-notation', or 'strict-underscore-notation' "
                 "can be set to True at a time."
             )
-        if float_config == 0:
-            # i.e. nothing is strict so we should check all
-            self.should_check_scientific_notation = True
-            self.should_check_engineering_notation = True
-            self.should_check_underscore_notation = True
-        else:
-            self.should_check_scientific_notation = scientific
-            self.should_check_engineering_notation = engineering
-            self.should_check_underscore_notation = underscore
+        self.all_float_notation_allowed = number_of_strict_float_notation == 0
+        if (
+            self.linter.config.float_notation_threshold < 10
+            and self.linter.config.strict_scientific_notation
+        ):
+            raise ValueError(
+                "'float-notation-threshold' must be at least 10 "
+                "when 'strict-scientific-notation' is enabled, got "
+                f"{self.linter.config.float_notation_threshold}."
+            )
+        if self.linter.config.float_notation_threshold < 1000:
+            raise ValueError(
+                "'float-notation-threshold' must be at least 1000 "
+                f"when 'strict-scientific-notation' is disabled, got "
+                f"{self.linter.config.float_notation_threshold}."
+            )
 
     def new_line(self, tokens: TokenWrapper, line_end: int, line_start: int) -> None:
         """A new line has been encountered, process it if necessary."""
@@ -557,6 +564,9 @@ def to_standard_or_engineering_base(cls, number: float) -> tuple[str, str]:
         """
         if number == 0:
             return "0", "0"
+        if number == math.inf:
+            return "math.inf", "0"
+        print(f"Converting {number} to standard or engineering base")
         exponent = math.floor(math.log10(abs(number)))
         if exponent == 0:
             return str(number), "0"
@@ -570,6 +580,8 @@ def to_standard_or_engineering_base(cls, number: float) -> tuple[str, str]:
     @classmethod
     def to_standard_scientific_notation(cls, number: float) -> str:
         base, exp = cls.to_standard_or_engineering_base(number)
+        if base == "math.inf":
+            return "math.inf"
         if exp != "0":
             return f"{base}e{int(exp)}"
         if "." in base:
@@ -579,6 +591,8 @@ def to_standard_scientific_notation(cls, number: float) -> str:
     @classmethod
     def to_standard_engineering_notation(cls, number: float) -> str:
         base, exp = cls.to_standard_or_engineering_base(number)
+        if base == "math.inf":
+            return "math.inf"
         exp_value = int(exp)
         remainder = exp_value % 3
         # For negative exponents, the adjustment is different
@@ -623,91 +637,114 @@ def to_standard_underscore_grouping(cls, number: float) -> str:
             grouped_int_part = digit + grouped_int_part
         return f"{grouped_int_part}.{dec_part}"
 
-    def _check_bad_float_notation(
+    def _check_bad_float_notation(  # pylint: disable=too-many-locals
         self, line_num: int, start: tuple[int, int], string: str
     ) -> None:
+        value = float(string)
+        engineering = (
+            self.all_float_notation_allowed
+            or self.linter.config.strict_engineering_notation
+        )
+        scientific = (
+            self.all_float_notation_allowed
+            or self.linter.config.strict_scientific_notation
+        )
+        pep515 = (
+            self.all_float_notation_allowed
+            or self.linter.config.strict_underscore_notation
+        )
 
-        def raise_bad_float_notation(suggested: set[str]) -> None:
+        def raise_bad_float_notation() -> None:
+            suggested = set()
+            if scientific:
+                suggested.add(self.to_standard_scientific_notation(value))
+            if engineering:
+                suggested.add(self.to_standard_engineering_notation(value))
+            if pep515:
+                suggested.add(self.to_standard_underscore_grouping(value))
+            print("\tBad float notation, suggesting:", suggested)
             return self.add_message(
                 "bad-float-notation",
-                args=("' or '".join(suggested)),
+                args=("' or '".join(sorted(suggested))),
                 line=line_num,
+                end_lineno=line_num,
                 col_offset=start[1],
+                end_col_offset=start[1] + len(string),
                 confidence=HIGH,
             )
 
-        value = float(string)
-        threshold = self.linter.config.float_notation_threshold
-        abs_value = abs(value)
         has_underscore = "_" in string
         has_exponent = "e" in string or "E" in string
+        should_be_written_simply = (
+            1 <= value < 10 and self.linter.config.strict_scientific_notation
+        ) or 1 <= value < 1000
+        is_written_complexly = has_underscore or has_exponent
+        print(f"Checking {string} line {line_num}")
+        if should_be_written_simply and is_written_complexly:
+            print(f"\t{value} is a simple number")
+            # If the value does not deserve a complex notation then write it in a simple way.
+            # The threshold is guaranteed to be higher than those value.
+            # When 1 <= value < 10 the engineering notation is equivalent to the scientific notation
+            return raise_bad_float_notation()
+
+        abs_value = abs(value)
+        should_not_be_checked_because_of_threshold = (
+            abs_value < self.linter.config.float_notation_threshold  # under threshold
+            and (  # use scientific or engineering notation and under 1/threshold
+                self.linter.config.strict_underscore_notation
+                or abs_value > 1 / self.linter.config.float_notation_threshold
+            )
+        )
         print(
-            f"Checking {string} {line_num}: "
-            f"s:{self.should_check_scientific_notation} "
-            f"e:{self.should_check_engineering_notation} "
-            f"u;{self.should_check_underscore_notation} "
-            f"has_underscore: {has_underscore} "
-            f"has_exponent: {has_exponent} "
-            f"abs_value: {abs_value} "
-            f"threshold: {threshold} "
-            f"strict_scientific_notation: {self.linter.config.strict_scientific_notation} "
+            "\tshould_not_be_checked_because_of_threshold=",
+            should_not_be_checked_because_of_threshold,
         )
+        if not is_written_complexly:
+            if should_not_be_checked_because_of_threshold:
+                # This number is free style, we do not have to check it, unless it's
+                # written complexly, then it could be badly written
+                print("\tFree style number, no need to check")
+                return None
+            return raise_bad_float_notation()
         if has_exponent:
             if self.linter.config.strict_underscore_notation:
                 # If we have exponent it means it's not proper underscore
-                return raise_bad_float_notation(
-                    {self.to_standard_underscore_grouping(value)}
-                )
-            if abs_value > threshold or abs_value < 1 / threshold:
-                value_as_str, exponent_as_str = string.lower().split("e")
-                value = float(value_as_str)
-                wrong_scientific_notation = (
-                    self.should_check_scientific_notation and not (1 <= value < 10)
-                )
-                if (
-                    self.linter.config.strict_scientific_notation
-                    and wrong_scientific_notation
-                ):
-                    return raise_bad_float_notation(
-                        {self.to_standard_scientific_notation(value)}
-                    )
-                wrong_engineering_notation = (
-                    self.should_check_engineering_notation
-                    and not (1 <= value < 1000 and int(exponent_as_str) % 3 == 0)
-                )
-                if (
-                    self.linter.config.strict_engineering_notation
-                    and wrong_engineering_notation
-                ):
-                    return raise_bad_float_notation(
-                        {self.to_standard_engineering_notation(value)}
-                    )
-                if wrong_scientific_notation and wrong_engineering_notation:
-                    return raise_bad_float_notation(
-                        {
-                            self.to_standard_scientific_notation(value),
-                            self.to_standard_engineering_notation(value),
-                            self.to_standard_underscore_grouping(value),
-                        }
-                    )
-        if has_underscore:
+                return raise_bad_float_notation()
+            base_as_str, exponent_as_str = string.lower().split("e")
+            base = float(base_as_str)
+            print("\tBase:", base, "Exponent:", exponent_as_str)
+            wrong_scientific_notation = not (1 <= base < 10)
+            print(f"\twrong_scientific_notation:{wrong_scientific_notation}")
+            if (
+                self.linter.config.strict_scientific_notation
+                and wrong_scientific_notation
+            ):
+                return raise_bad_float_notation()
+            wrong_engineering_notation = not (
+                1 <= base < 1000 and int(exponent_as_str) % 3 == 0
+            )
+            print(f"\twrong_engineering_notation:{wrong_engineering_notation}")
+            if (
+                self.linter.config.strict_engineering_notation
+                and wrong_engineering_notation
+            ) or (wrong_scientific_notation and wrong_engineering_notation):
+                return raise_bad_float_notation()
+        elif has_underscore:
             # If we have underscore and exponent, we suggest exponent by default
-            if self.linter.config.strict_scientific_notation:
-                return raise_bad_float_notation(
-                    {self.to_standard_scientific_notation(value)}
-                )
-            if self.linter.config.strict_engineering_notation:
-                return raise_bad_float_notation(
-                    {self.to_standard_engineering_notation(value)}
-                )
-            underscore_notation = has_underscore and re.match(
+            print("\tHas underscore, checking underscore grouping")
+            if (
+                self.linter.config.strict_scientific_notation
+                or self.linter.config.strict_engineering_notation
+            ):
+                return raise_bad_float_notation()
+            wrong_underscore_notation = not re.match(
                 r"^\d{0,3}(_\d{3})*\.?\d*([eE]-?\d{0,3}(_\d{3})*)?$", string
             )
-            if not underscore_notation:
-                return raise_bad_float_notation(
-                    {self.to_standard_underscore_grouping(value)}
-                )
-            return None
+            print(f"\twrong_underscore_notation:{wrong_underscore_notation}")
+            if pep515 and wrong_underscore_notation:
+                return raise_bad_float_notation()
+        else:
+            return raise_bad_float_notation()
         return None
 
     def _check_line_ending(self, line_ending: str, line_num: int) -> None:

tests/functional/b/bad_float/bad_float_engineering_notation.txt

@@ -0,0 +1,4 @@
+bad-float-notation:3:33:3:38::float literal should be written as '1.23e6' instead:HIGH
+bad-float-notation:4:38:4:45::float literal should be written as '12.344999999999999e9' instead:HIGH
+bad-float-notation:5:35:5:43::float literal should be written as '10e6' instead:HIGH
+bad-float-notation:6:33:6:38::float literal should be written as '990.0' instead:HIGH

tests/functional/b/bad_float/bad_float_notation_default.py

@@ -24,22 +24,22 @@
 under_a_thousand = 990
 
 # Content of bad_float_scientific_notation strict tests tested with default configuration
-base_not_between_one_and_ten = 10e3  # [bad-float-notation]
+base_not_between_one_and_ten = 10e3
 above_threshold_without_exponent_2 = 10000000  # [bad-float-notation]
 under_ten_with_exponent = 9.9e0  # [bad-float-notation]
 base_between_one_and_ten = 1e4
 above_threshold_with_exponent = 1e7
 under_ten = 9.9
 
 
-wrong_big = 45.3e6  # [bad-float-notation]
-uppercase_e_wrong = 45.3E6  # [bad-float-notation]
+wrong_big = 45.3e7  # [bad-float-notation]
+uppercase_e_wrong = 45.3E7  # [bad-float-notation]
 wrong_small = 0.00012e-26  # [bad-float-notation]
 uppercase_e_wrong_small = 0.00012E-26  # [bad-float-notation]
-wrong_negative_and_big = -10e3  # [bad-float-notation]
-actual_trolling = 11000e26  # [bad-float-notation]
+wrong_negative_and_big = -10e5  # [bad-float-notation]
+actual_trolling = 11000e27  # [bad-float-notation]
 scientific_double_digit = 12e8  # [bad-float-notation]
-scientific_triple_digit = 123e3  # [bad-float-notation]
+scientific_triple_digit = 123e3
 zero_before_decimal_small = 0.0001e-5  # [bad-float-notation]
 zero_before_decimal_big = 0.0001e5  # [bad-float-notation]
 negative_decimal = -0.5e10  # [bad-float-notation]
@@ -57,9 +57,10 @@
 correct_with_plus = 1.2e+10
 correct_decimal_only = 3.14
 negative_correct = -5.67e-8
-correct_small_exponent = 1.5e1
-actually_nine = 9e0
-actually_one = 1.0e0
+correct_small_exponent = 1.5e1  # [bad-float-notation]
+actually_nine = 9e0  # [bad-float-notation]
+actually_one = 1.0e0  # [bad-float-notation]
+
 
 
 hex_constant = 0x1e4  # Hexadecimal, not scientific notation
@@ -76,15 +77,15 @@
 
 complex_number = 1.5e3 + 2.5e3j  # Complex number with scientific notation
 # false negative for complex numbers:
-complex_number_wrong = 15e3 + 25e3j  # [bad-float-notation]
+complex_number_wrong = 15e4 + 25e7j  # [bad-float-notation]
 
 
 #+1: [bad-float-notation, bad-float-notation]
-def function_with_sci(param=10.0e3, other_param=20.0e3):
+def function_with_sci(param=10.0e4, other_param=20.0e5):
     return param, other_param
 
 #+1: [bad-float-notation, bad-float-notation]
-result = function_with_sci(20.0e3, 10.0e3)
+result = function_with_sci(20.0e4, 10.0e7)
 
 valid_underscore_int = 1_000_000
 valid_underscore_float = 1_000_000.12345

tests/functional/b/bad_float/bad_float_pep515.py

@@ -3,6 +3,7 @@
 not_grouped_by_three = 1_23_456_7_89  # [bad-float-notation]
 mixing_with_exponent = 1_23_4_5_67_8e9  # [bad-float-notation]
 above_threshold_without_grouping = 123456789  # [bad-float-notation]
+scientific_notation = 1.2345678e16 # [bad-float-notation]
+engineering_notation = 12.345678e15 # [bad-float-notation]
+
 proper_grouping = 123_456_789
-scientific_notation = 1.2345678e16
-engineering_notation = 12.345678e15

tests/functional/b/bad_float/bad_float_pep515.txt

@@ -0,0 +1,5 @@
+bad-float-notation:3:23:3:36::float literal should be written as '123_456_789.0' instead:HIGH
+bad-float-notation:4:23:4:38::float literal should be written as '1.2345678e+16' instead:HIGH
+bad-float-notation:5:35:5:44::float literal should be written as '123_456_789.0' instead:HIGH
+bad-float-notation:6:22:6:34::float literal should be written as '1.2345678e+16' instead:HIGH
+bad-float-notation:7:23:7:35::float literal should be written as '1.2345678e+16' instead:HIGH

tests/functional/b/bad_float/bad_float_scientific_notation.txt

@@ -0,0 +1,3 @@
+bad-float-notation:3:31:3:35::float literal should be written as '1e4' instead:HIGH
+bad-float-notation:4:35:4:43::float literal should be written as '1e7' instead:HIGH
+bad-float-notation:5:26:5:31::float literal should be written as '9.9' instead:HIGH