import pytest  # used for our unit tests
from workload import funcA

# unit tests

# 1. Basic Test Cases

def test_funcA_small_positive():
    # Test with small positive integers
    codeflash_output = funcA(1) # 2.62μs -> 2.46μs (6.53% faster)
    codeflash_output = funcA(2) # 1.50μs -> 1.52μs (1.25% slower)
    codeflash_output = funcA(5) # 1.44μs -> 1.52μs (5.32% slower)

def test_funcA_typical_values():
    # Test with typical values
    codeflash_output = funcA(10) # 3.41μs -> 3.26μs (4.64% faster)
    codeflash_output = funcA(3) # 1.27μs -> 1.26μs (0.792% faster)

def test_funcA_zero_and_negative():
    # Test with zero and negative numbers
    codeflash_output = funcA(0) # 2.18μs -> 1.91μs (14.2% faster)
    codeflash_output = funcA(-1) # 1.24μs -> 1.19μs (4.28% faster)
    codeflash_output = funcA(-100) # 992ns -> 932ns (6.44% faster)

def test_funcA_string_output_format():
    # Test output is a single string, not a list or other type
    codeflash_output = funcA(4); result = codeflash_output # 2.90μs -> 2.81μs (3.21% faster)

# 2. Edge Test Cases

def test_funcA_large_exact_limit():
    # Test with number exactly at the cap (1000)
    codeflash_output = funcA(1000); output = codeflash_output # 78.9μs -> 72.7μs (8.46% faster)
    expected = " ".join(str(i) for i in range(1000))

def test_funcA_above_limit():
    # Test with number above the cap (should still return 0..999)
    codeflash_output = funcA(1500); output = codeflash_output # 78.2μs -> 72.3μs (8.18% faster)
    expected = " ".join(str(i) for i in range(1000))

def test_funcA_at_and_below_zero():
    # Test with zero and negative numbers (should return empty string)
    codeflash_output = funcA(0) # 2.15μs -> 1.91μs (12.5% faster)
    codeflash_output = funcA(-10) # 1.28μs -> 1.20μs (6.66% faster)

def test_funcA_one_below_cap():
    # Test with one below the cap
    codeflash_output = funcA(999); output = codeflash_output # 78.1μs -> 71.9μs (8.68% faster)
    expected = " ".join(str(i) for i in range(999))

def test_funcA_non_integer_input():
    # Test with non-integer input: should raise TypeError
    with pytest.raises(TypeError):
        funcA("10")
    with pytest.raises(TypeError):
        funcA(None)
    with pytest.raises(TypeError):
        funcA(5.5)  # floats are not allowed


def test_funcA_large_negative():
    # Test with a large negative number
    codeflash_output = funcA(-1000000) # 2.41μs -> 2.24μs (7.58% faster)

# 3. Large Scale Test Cases

def test_funcA_performance_near_limit():
    # Test with a large number near the upper limit (999)
    codeflash_output = funcA(999); output = codeflash_output # 77.7μs -> 71.8μs (8.22% faster)
    # Check first and last few elements
    parts = output.split(" ")

def test_funcA_performance_at_limit():
    # Test with the maximum allowed (1000)
    codeflash_output = funcA(1000); output = codeflash_output # 77.9μs -> 70.9μs (9.93% faster)
    parts = output.split(" ")

def test_funcA_performance_above_limit():
    # Test with a value above the maximum allowed (should still be capped at 1000)
    codeflash_output = funcA(2000); output = codeflash_output # 77.7μs -> 71.6μs (8.55% faster)
    parts = output.split(" ")

def test_funcA_output_no_trailing_space():
    # The output should not have a trailing space
    codeflash_output = funcA(20); output = codeflash_output # 4.22μs -> 4.13μs (2.18% faster)

def test_funcA_output_empty_string_is_empty():
    # When output is empty, it should be exactly an empty string
    codeflash_output = funcA(0) # 2.12μs -> 1.98μs (7.06% faster)
    codeflash_output = funcA(-1) # 1.29μs -> 1.18μs (9.39% faster)
    codeflash_output = funcA(-1000) # 1.12μs -> 1.11μs (0.899% faster)

# 4. Additional Robustness Tests

@pytest.mark.parametrize("n,expected", [
    (0, ""),
    (1, "0"),
    (2, "0 1"),
    (3, "0 1 2"),
    (10, "0 1 2 3 4 5 6 7 8 9"),
    (1000, " ".join(str(i) for i in range(1000))),
])
def test_funcA_parametrized(n, expected):
    # Parametrized test for various values
    codeflash_output = funcA(n) # 2.12μs -> 1.94μs (9.32% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest  # used for our unit tests
from workload import funcA

# unit tests

# 1. Basic Test Cases

def test_funcA_zero():
    # Should return empty string for 0
    codeflash_output = funcA(0) # 2.26μs -> 2.03μs (11.3% faster)

def test_funcA_one():
    # Should return "0" for 1
    codeflash_output = funcA(1) # 2.51μs -> 2.44μs (3.24% faster)

def test_funcA_small_number():
    # Should return "0 1 2" for 3
    codeflash_output = funcA(3) # 2.87μs -> 2.73μs (4.79% faster)

def test_funcA_typical_number():
    # Should return correct string for 10
    codeflash_output = funcA(10) # 3.24μs -> 3.24μs (0.000% faster)

# 2. Edge Test Cases

def test_funcA_negative():
    # Should return empty string for negative input
    codeflash_output = funcA(-5) # 2.09μs -> 1.98μs (5.60% faster)

def test_funcA_large_number_cap():
    # Should cap output at 1000 elements
    codeflash_output = funcA(1500); result = codeflash_output # 77.9μs -> 72.1μs (8.15% faster)
    parts = result.split()

def test_funcA_exactly_1000():
    # Should return 1000 numbers for input 1000
    codeflash_output = funcA(1000); result = codeflash_output # 77.3μs -> 71.4μs (8.32% faster)
    parts = result.split()

def test_funcA_just_below_cap():
    # Should return 999 numbers for input 999
    codeflash_output = funcA(999); result = codeflash_output # 77.3μs -> 71.5μs (8.10% faster)
    parts = result.split()

def test_funcA_non_integer_float():
    # Should raise TypeError for float input
    with pytest.raises(TypeError):
        funcA(5.5)

def test_funcA_non_integer_string():
    # Should raise TypeError for string input
    with pytest.raises(TypeError):
        funcA("10")

def test_funcA_none_input():
    # Should raise TypeError for None input
    with pytest.raises(TypeError):
        funcA(None)


def test_funcA_large_negative():
    # Should return empty string for large negative
    codeflash_output = funcA(-10000) # 2.77μs -> 2.58μs (7.35% faster)

def test_funcA_minimum_integer():
    # Should return empty string for minimum integer value
    codeflash_output = funcA(-2**31) # 2.77μs -> 2.58μs (7.77% faster)

# 3. Large Scale Test Cases

def test_funcA_large_scale_500():
    # Test with 500 elements
    codeflash_output = funcA(500); result = codeflash_output # 41.7μs -> 39.2μs (6.44% faster)
    parts = result.split()

def test_funcA_large_scale_999():
    # Test with 999 elements
    codeflash_output = funcA(999); result = codeflash_output # 79.6μs -> 73.6μs (8.15% faster)
    parts = result.split()

def test_funcA_large_scale_edge():
    # Test with exactly 1000 elements (the cap)
    codeflash_output = funcA(1000); result = codeflash_output # 79.1μs -> 73.0μs (8.43% faster)
    parts = result.split()
    # Ensure all numbers are present in order
    for i, val in enumerate(parts):
        pass

def test_funcA_large_scale_above_cap():
    # Test with input above cap (e.g., 1001)
    codeflash_output = funcA(1001); result = codeflash_output # 79.2μs -> 73.0μs (8.57% faster)
    parts = result.split()

def test_funcA_performance():
    # Performance test: make sure it runs quickly for cap value
    import time
    start = time.time()
    codeflash_output = funcA(1000); result = codeflash_output # 78.9μs -> 72.7μs (8.51% faster)
    end = time.time()
    parts = result.split()

# Additional edge: very large input (should not crash, but cap at 1000)
def test_funcA_very_large_input():
    codeflash_output = funcA(10**6); result = codeflash_output # 78.5μs -> 72.8μs (7.89% faster)
    parts = result.split()
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.