#!/usr/bin/env python
"""
Module for arithmetic and string operations with sample functions.
# [Module-level] This docstring explains the purpose of the module.
"""

# -------------------------------
# Function: add_numbers
# -------------------------------
def add_numbers(x, y):
    # [Line 8] Function definition for adding two numbers.
    """Return the sum of x and y."""
    # [Line 10] Directly returns the sum; assumes x and y are of types that support '+'
    return x + y  # [Consideration] For better type safety, consider adding type hints (e.g., x: float, y: float) and input validation.


# -------------------------------
# Function: subtract_numbers
# -------------------------------
def subtract_numbers(x, y):
    # [Line 15] Function definition for subtracting y from x.
    """Return the difference between x and y."""
    # [Line 17] Direct subtraction; ensure x and y are numbers to avoid TypeErrors.
    return x - y  # [Improvement] Type hints could help clarify expected argument types.


# -------------------------------
# Function: multiply_numbers
# -------------------------------
def multiply_numbers(x, y):
    # [Line 22] Function definition for multiplying two numbers.
    """Return the product of x and y."""
    # [Line 24] Multiplies x and y; may lead to unexpected results if types are not numeric.
    return x * y  # [Suggestion] Consider input checks or type hints to enforce numerical multiplication.


# -------------------------------
# Function: divide_numbers
# -------------------------------
def divide_numbers(x, y):
    # [Line 29] Function definition for dividing x by y.
    """Return the result of dividing x by y. Raises ZeroDivisionError if y is zero."""
    # [Line 31] Direct division; note that if y is zero, Python automatically raises ZeroDivisionError.
    # [Edge-case] Consider explicitly checking for zero to provide a more informative error message.
    return x / y  # [Performance/Security] This is efficient; however, input type hints can clarify expectations.


# -------------------------------
# Function: concatenate_strings
# -------------------------------
def concatenate_strings(s1, s2):
    # [Line 36] Function definition for concatenating two strings.
    """Return the concatenation of s1 and s2."""
    # [Line 38] Uses '+' operator for string concatenation; ensure s1 and s2 are indeed strings.
    # [Potential Bug] If non-string types are passed, this might lead to unexpected results or errors.
    return s1 + s2  # [Fix Suggestion] Optionally enforce string conversion (e.g., str(s1) + str(s2)) if appropriate.


# -------------------------------
# Function: list_index_error
# -------------------------------
def list_index_error():
    # [Line 43] Function definition intended to demonstrate safe list indexing.
    """Return a valid element from the list to avoid IndexError."""
    # [Line 45] Creates a local list with three integer elements.
    local_list = [1, 2, 3]  # [Note] The list is hardcoded; consider allowing dynamic input if needed.
    # [Line 46] Returns the first element of the list (index 0) to avoid indexing errors.
    return local_list[0]  # [Edge-case] If the list were empty, accessing index 0 would raise an IndexError; here it is hardcoded to avoid that.

    
# -------------------------------
# Additional Constructive Feedback:
# -------------------------------
# 1. Code Quality & Best Practices:
#    - Consider adding type hints to all functions for readability and easier debugging.
#      For example:
#         def add_numbers(x: float, y: float) -> float:
#             return x + y
#
# 2. Potential Bugs/Edge Cases:
#    - In divide_numbers, while Python raises ZeroDivisionError naturally, you might want to handle
#      division by zero gracefully or provide custom error messages.
#    - In concatenate_strings, there is an implicit assumption that parameters are strings.
#
# 3. Performance:
#    - The operations are basic arithmetic and string concatenation, which perform well.
#
# 4. Security:
#    - There are no significant security risks in these simple functions. Just ensure that callers
#      validate input types, especially in larger projects.
#
# 5. Style & Consistency:
#    - The code is largely consistent. Adding type hints and possibly parameter validation would
#      further improve clarity and maintainability.
#
# Overall, the code is simple and functional. Adding type hints and input validations where needed
# would further enhance its robustness and clarity.

import pytest
from evaluate.issues import (
    add_numbers,
    subtract_numbers,
    multiply_numbers,
    divide_numbers,
    concatenate_strings,
    list_index_error
)

def test_add_numbers():
    # Typical cases
    assert add_numbers(2, 3) == 5
    assert add_numbers(-1, 1) == 0
    # Edge cases
    assert add_numbers(0, 0) == 0
    # Float addition
    assert add_numbers(2.5, 3.5) == 6.0

def test_subtract_numbers():
    # Typical cases
    assert subtract_numbers(5, 3) == 2
    assert subtract_numbers(3, 5) == -2
    # Edge cases
    assert subtract_numbers(0, 0) == 0
    # Float subtraction
    assert subtract_numbers(5.5, 2.5) == 3.0

def test_multiply_numbers():
    # Typical cases
    assert multiply_numbers(4, 3) == 12
    # Multiplying by zero
    assert multiply_numbers(10, 0) == 0
    # Edge cases with negatives
    assert multiply_numbers(-2, 3) == -6
    # Float multiplication
    assert multiply_numbers(2.5, 4) == 10.0

def test_divide_numbers():
    # Typical case
    assert divide_numbers(10, 2) == 5
    # Division resulting in float
    assert divide_numbers(7, 2) == 3.5
    # Negative division
    assert divide_numbers(-9, 3) == -3
    # Testing division by zero using pytest.raises
    with pytest.raises(ZeroDivisionError):
        divide_numbers(5, 0)

def test_concatenate_strings():
    # Typical cases
    assert concatenate_strings("Hello", "World") == "HelloWorld"
    # Edge cases: with empty strings
    assert concatenate_strings("", "Test") == "Test"
    assert concatenate_strings("Test", "") == "Test"
    assert concatenate_strings("", "") == ""
    # Concatenation with spaces
    assert concatenate_strings("Hello ", "World") == "Hello World"

def test_list_index_error():
    # The function always returns the first element of the list [1,2,3]
    assert list_index_error() == 1