From 624bf7e88dea8476db755d7185906522eb530d1d Mon Sep 17 00:00:00 2001 From: Selina Delgado Date: Thu, 14 Mar 2024 18:37:16 -0700 Subject: [PATCH 1/2] updated LiteralInt and LiteratInt_test --- python/selfie-lib/selfie_lib/Literals.py | 31 +++++++++++++ python/selfie-lib/tests/LiteralInt_test.py | 52 ++++++++++++++++++++++ 2 files changed, 83 insertions(+) create mode 100644 python/selfie-lib/tests/LiteralInt_test.py diff --git a/python/selfie-lib/selfie_lib/Literals.py b/python/selfie-lib/selfie_lib/Literals.py index 067a7f39..591221f8 100644 --- a/python/selfie-lib/selfie_lib/Literals.py +++ b/python/selfie-lib/selfie_lib/Literals.py @@ -2,6 +2,7 @@ from typing import Protocol, TypeVar from abc import abstractmethod from .EscapeLeadingWhitespace import EscapeLeadingWhitespace +import io T = TypeVar("T") @@ -41,6 +42,36 @@ def parse(self, string: str, language: Language) -> T: PADDING_SIZE = len(str(MAX_RAW_NUMBER)) - 1 +def _encode_underscores( + buffer: io.StringIO, value: int, language: Language +) -> io.StringIO: + if value >= MAX_RAW_NUMBER: + mod = value % MAX_RAW_NUMBER + left_padding = PADDING_SIZE - len(str(mod)) + _encode_underscores(buffer, value // MAX_RAW_NUMBER, language) + buffer.write("_") + buffer.write("0" * left_padding) + buffer.write(str(mod)) + return buffer + elif value < 0: + buffer.write("-") + _encode_underscores(buffer, abs(value), language) + return buffer + else: + buffer.write(str(value)) + return buffer + + +class LiteralInt(LiteralFormat[int]): + def encode( + self, value: int, language: Language, encoding_policy: EscapeLeadingWhitespace + ) -> str: + return _encode_underscores(io.StringIO(), value, language).getvalue() + + def parse(self, string: str, language: Language) -> int: + return int(string.replace("_", "")) + + class LiteralBoolean(LiteralFormat[bool]): def encode( self, value: bool, language: Language, encoding_policy: EscapeLeadingWhitespace diff --git a/python/selfie-lib/tests/LiteralInt_test.py b/python/selfie-lib/tests/LiteralInt_test.py new file mode 100644 index 00000000..b28577f4 --- /dev/null +++ b/python/selfie-lib/tests/LiteralInt_test.py @@ -0,0 +1,52 @@ +from selfie_lib.Literals import LiteralInt, Language +from selfie_lib.EscapeLeadingWhitespace import EscapeLeadingWhitespace + + +def _encode(value: int, expected: str): + literal_int = LiteralInt() + actual = literal_int.encode(value, Language.PYTHON, EscapeLeadingWhitespace.NEVER) + assert actual == expected, f"Expected '{expected}', but got '{actual}'" + + +def _decode(value: str, expected: int): + literal_int = LiteralInt() + actual = literal_int.parse(value, Language.PYTHON) + assert actual == expected, f"Expected '{expected}', but got '{actual}'" + + +class TestLiteralInt: + def test_encode(self): + test_cases = [ + (0, "0"), + (1, "1"), + (-1, "-1"), + (999, "999"), + (-999, "-999"), + (1_000, "1_000"), + (-1_000, "-1_000"), + (1_000_000, "1_000_000"), + (-1_000_000, "-1_000_000"), + (2400500, "2_400_500"), + (2400501, "2_400_501"), + (200, "200"), + (1001, "1_001"), + (1010, "1_010"), + (10010, "10_010"), + ] + for value, expected in test_cases: + _encode(value, expected) + + def test_decode(self): + test_cases = [ + ("0", 0), + ("1", 1), + ("-1", -1), + ("999", 999), + ("9_99", 999), + ("9_9_9", 999), + ("-999", -999), + ("-9_99", -999), + ("-9_9_9", -999), + ] + for value, expected in test_cases: + _decode(value, expected) From f2afb6486c094151684feb30c7004cad10d6605d Mon Sep 17 00:00:00 2001 From: Selina Delgado Date: Fri, 15 Mar 2024 15:10:58 -0700 Subject: [PATCH 2/2] made encode_underscores a private method of LiteralInt --- python/selfie-lib/selfie_lib/Literals.py | 41 ++++++++++++------------ 1 file changed, 20 insertions(+), 21 deletions(-) diff --git a/python/selfie-lib/selfie_lib/Literals.py b/python/selfie-lib/selfie_lib/Literals.py index 591221f8..cd27e92e 100644 --- a/python/selfie-lib/selfie_lib/Literals.py +++ b/python/selfie-lib/selfie_lib/Literals.py @@ -42,31 +42,30 @@ def parse(self, string: str, language: Language) -> T: PADDING_SIZE = len(str(MAX_RAW_NUMBER)) - 1 -def _encode_underscores( - buffer: io.StringIO, value: int, language: Language -) -> io.StringIO: - if value >= MAX_RAW_NUMBER: - mod = value % MAX_RAW_NUMBER - left_padding = PADDING_SIZE - len(str(mod)) - _encode_underscores(buffer, value // MAX_RAW_NUMBER, language) - buffer.write("_") - buffer.write("0" * left_padding) - buffer.write(str(mod)) - return buffer - elif value < 0: - buffer.write("-") - _encode_underscores(buffer, abs(value), language) - return buffer - else: - buffer.write(str(value)) - return buffer - - class LiteralInt(LiteralFormat[int]): + def _encode_underscores( + self, buffer: io.StringIO, value: int, language: Language + ) -> io.StringIO: + if value >= MAX_RAW_NUMBER: + mod = value % MAX_RAW_NUMBER + left_padding = PADDING_SIZE - len(str(mod)) + self._encode_underscores(buffer, value // MAX_RAW_NUMBER, language) + buffer.write("_") + buffer.write("0" * left_padding) + buffer.write(str(mod)) + return buffer + elif value < 0: + buffer.write("-") + self._encode_underscores(buffer, abs(value), language) + return buffer + else: + buffer.write(str(value)) + return buffer + def encode( self, value: int, language: Language, encoding_policy: EscapeLeadingWhitespace ) -> str: - return _encode_underscores(io.StringIO(), value, language).getvalue() + return self._encode_underscores(io.StringIO(), value, language).getvalue() def parse(self, string: str, language: Language) -> int: return int(string.replace("_", ""))