import random  # for generating large random lists
import string  # for string sorting tests
import sys  # for sys.maxsize edge case

# imports
import pytest  # used for our unit tests
from code_to_optimize.bubble_sort import sorter

# unit tests

# --- BASIC TEST CASES ---

def test_sorter_basic_sorted():
    # Already sorted list should remain unchanged
    arr = [1, 2, 3, 4, 5]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_basic_reverse():
    # Reverse sorted list should be sorted ascending
    arr = [5, 4, 3, 2, 1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_basic_unsorted():
    # Unsorted list with positive integers
    arr = [3, 1, 4, 2, 5]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_basic_duplicates():
    # List with duplicate values
    arr = [2, 3, 1, 2, 3, 1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_basic_negative_numbers():
    # List with negative and positive numbers
    arr = [-1, 3, 0, -5, 2]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_basic_single_element():
    # List with a single element
    arr = [42]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_basic_two_elements():
    # List with two elements, unsorted
    arr = [2, 1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_basic_strings():
    # List of strings
    arr = ["banana", "apple", "cherry"]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_basic_floats():
    # List of floats
    arr = [2.2, 1.1, 3.3]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_basic_mixed_int_float():
    # List with mixed ints and floats
    arr = [3, 1.5, 2]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

# --- EDGE TEST CASES ---

def test_sorter_edge_empty():
    # Empty list should return empty list
    arr = []
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_edge_all_equal():
    # All elements equal
    arr = [7, 7, 7, 7]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_edge_large_numbers():
    # List with very large and very small integers
    arr = [sys.maxsize, -sys.maxsize-1, 0]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_edge_min_max_float():
    # List with min and max float values
    arr = [float('inf'), float('-inf'), 0.0]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_edge_unicode_strings():
    # List of strings with unicode characters
    arr = ["éclair", "apple", "banana", "Éclair"]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_edge_single_type_error():
    # List with incomparable types should raise TypeError
    arr = [1, "two", 3]
    with pytest.raises(TypeError):
        sorter(arr.copy())


def test_sorter_edge_nan_values():
    # List with NaN values (NaN is never equal or ordered)
    arr = [float('nan'), 1, 2]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_edge_boolean_values():
    # List with boolean values (True == 1, False == 0)
    arr = [True, False, True, False]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_edge_strings_numbers():
    # List with strings and numbers should raise TypeError
    arr = [1, "1"]
    with pytest.raises(TypeError):
        sorter(arr.copy())

# --- LARGE SCALE TEST CASES ---

def test_sorter_large_sorted():
    # Large already sorted list
    arr = list(range(1000))
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_large_reverse():
    # Large reverse sorted list
    arr = list(range(999, -1, -1))
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_large_random():
    # Large random list of integers
    arr = random.sample(range(1000), 1000)
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_large_duplicates():
    # Large list with many duplicates
    arr = [random.choice([0, 1, 2, 3, 4, 5]) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_large_strings():
    # Large list of random strings
    arr = [''.join(random.choices(string.ascii_letters, k=5)) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_large_negative_numbers():
    # Large list with negative numbers
    arr = [random.randint(-10000, 0) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_large_floats():
    # Large list of random floats
    arr = [random.uniform(-1000, 1000) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_large_mixed_int_float():
    # Large list of mixed ints and floats
    arr = [random.choice([random.randint(-1000, 1000), random.uniform(-1000, 1000)]) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import random  # used for large scale random input

# imports
import pytest  # used for our unit tests
from code_to_optimize.bubble_sort import sorter

# unit tests

# ------------------------------
# Basic Test Cases
# ------------------------------

def test_sorter_already_sorted():
    # Already sorted list should remain unchanged
    arr = [1, 2, 3, 4, 5]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_reverse_sorted():
    # Reverse sorted list should become sorted
    arr = [5, 4, 3, 2, 1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_unsorted():
    # Unsorted list should be sorted
    arr = [3, 1, 4, 2, 5]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_with_duplicates():
    # List with duplicates should be sorted and preserve duplicates
    arr = [4, 2, 2, 3, 1, 4]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_with_negatives():
    # List with negative numbers should be sorted correctly
    arr = [0, -1, 5, -10, 3]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_single_element():
    # Single element list should remain unchanged
    arr = [42]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_two_elements_sorted():
    # Two elements already sorted
    arr = [1, 2]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_two_elements_unsorted():
    # Two elements unsorted
    arr = [2, 1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

# ------------------------------
# Edge Test Cases
# ------------------------------

def test_sorter_empty_list():
    # Empty list should return empty list
    arr = []
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_all_identical():
    # All elements identical
    arr = [7, 7, 7, 7, 7]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_large_and_small_numbers():
    # List with large and small (including negative) numbers
    arr = [999999, -999999, 0, 123456, -123456]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_floats_and_integers():
    # List with floats and integers
    arr = [3.2, 1, 4.5, 2, 0.0]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_already_sorted_negative():
    # Already sorted with negatives
    arr = [-5, -4, -3, -2, -1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_min_max_int():
    # List with min and max integer values
    import sys
    arr = [sys.maxsize, -sys.maxsize-1, 0]
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_mutation():
    # Ensure input list is mutated (in-place sort)
    arr = [2, 1]
    sorter(arr)

def test_sorter_stability():
    # Test stability: equal elements retain relative order (not guaranteed by bubble sort, but in-place sort should not change order of equal elements)
    class Obj:
        def __init__(self, val, tag):
            self.val = val
            self.tag = tag
        def __lt__(self, other):
            return self.val < other.val
        def __gt__(self, other):
            return self.val > other.val
        def __eq__(self, other):
            return self.val == other.val
        def __repr__(self):
            return f"Obj({self.val},{self.tag})"
    a = Obj(1, "a")
    b = Obj(1, "b")
    arr = [b, a]
    # Bubble sort is not stable, so this test documents that it may not be stable
    codeflash_output = sorter(arr.copy()); result = codeflash_output

# ------------------------------
# Large Scale Test Cases
# ------------------------------

def test_sorter_large_random_list():
    # Large random list of 1000 elements
    arr = [random.randint(-10000, 10000) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_large_sorted_list():
    # Large already sorted list
    arr = list(range(1000))
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_large_reverse_sorted_list():
    # Large reverse sorted list
    arr = list(range(999, -1, -1))
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_large_duplicates():
    # Large list with many duplicates
    arr = [random.choice([1, 2, 3, 4, 5]) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_large_floats():
    # Large list of random floats
    arr = [random.uniform(-1e6, 1e6) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output

def test_sorter_performance_upper_bound():
    # Test that a list of 1000 elements does not take too long (not a strict performance test, but ensures it finishes)
    arr = [random.randint(-1_000_000, 1_000_000) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.