Write a function that checks whether a given string matches the format of a US phone number such as `123-456-7890`. The format requires:

- Three digits;
- A dash (`-`);
- Three more digits;
- Another dash (`-`);
- Four digits.

Use regular expressions to perform this validation. The function should return `True` if the input string matches the required pattern, and `False` otherwise.

**Example valid phone number:**

- `123-456-7890`

**Example invalid phone numbers:**

- `1234567890`  
- `123-45-6789`  
- `abc-def-ghij`



import unittest
import user_code
import ast
import re   
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_valid_number(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.is_valid_phone_number("123-456-7890")
        _dynamic_test(
            self,
            result is True,
            "Returns True for valid phone number 123-456-7890",
            f"Expected True for '123-456-7890', got {result}",
        )

    def test_missing_dashes(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.is_valid_phone_number("1234567890")
        _dynamic_test(
            self,
            result is False,
            "Returns False for missing dashes",
            f"Expected False for '1234567890', got {result}",
        )

    def test_wrong_digit_groups(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.is_valid_phone_number("123-45-6789")
        _dynamic_test(
            self,
            result is False,
            "Returns False for incorrect digit groups",
            f"Expected False for '123-45-6789', got {result}",
        )

    def test_non_digit(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.is_valid_phone_number("abc-def-ghij")
        _dynamic_test(
            self,
            result is False,
            "Returns False for non-digit input",
            f"Expected False for 'abc-def-ghij', got {result}",
        )

    def test_extra_characters(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.is_valid_phone_number("123-456-7890 ")
        _dynamic_test(
            self,
            result is False,
            "Returns False for trailing space",
            f"Expected False for '123-456-7890 ', got {result}",
        )
        result2 = user_code.is_valid_phone_number(" 123-456-7890")
        _dynamic_test(
            self,
            result2 is False,
            "Returns False for leading space",
            f"Expected False for ' 123-456-7890', got {result2}",
        )
        result3 = user_code.is_valid_phone_number("123-456-7890x")
        _dynamic_test(
            self,
            result3 is False,
            "Returns False for extra character at end",
            f"Expected False for '123-456-7890x', got {result3}",
        )

    def test_partial_match(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.is_valid_phone_number("0123-456-7890")
        _dynamic_test(
            self,
            result is False,
            "Returns False for too many digits at start",
            f"Expected False for '0123-456-7890', got {result}",
        )
        result2 = user_code.is_valid_phone_number("123-4567-890")
        _dynamic_test(
            self,
            result2 is False,
            "Returns False for incorrect grouping",
            f"Expected False for '123-4567-890', got {result2}",
        )

    def test_empty_string(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.is_valid_phone_number("")
        _dynamic_test(
            self,
            result is False,
            "Returns False for empty string",
            f"Expected False for empty string, got {result}",
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    start_line = node.lineno - 1
                    line = lines[start_line]
                    indent = ' ' * (len(line) - len(line.lstrip()))
                    lines[start_line] = f"{indent}{var_name} = {value}"
                    next_line = len(lines)
                    for next_node in tree.body[i+1:]:
                        if hasattr(next_node, 'lineno'):
                            next_line = next_node.lineno - 1
                            break
                    if next_line > start_line + 1:
                        lines[start_line+1:next_line] = []
                    
                    return '\\n'.join(lines)
    return code

if __name__ == "__main__":
    unittest.main()


test_main.py

A comprehensive course on Python regular expressions, designed for learners with basic Python knowledge. This course covers regex syntax, pattern matching, advanced features, and practical applications through theory and hands-on tasks.

Learn the fundamentals of regular expressions in Python, including basic syntax, pattern matching, and essential regex functions.

Delve deeper into regex with grouping, quantifiers, anchors, and substitution techniques.

Master advanced regex features such as lookahead/lookbehind, non-greedy matching, and apply regex to real-world text processing problems.

Challenge: Validate Phone Numbers

Lösning

Awesome!

Challenge: Validate Phone Numbers

Lösning