Python进阶测试用例¶

import pytest
from functools import wraps
import time

def test_basic_decorator():
    """测试基础装饰器"""
    def my_decorator(func):
        @wraps(func)  # @wraps保留被装饰函数的元信息（名称、文档字符串等）
        def wrapper(*args, **kwargs):  # *args/**kwargs接收任意位置参数和关键字参数
            print("Before function call")
            result = func(*args, **kwargs)
            print("After function call")
            return result
        return wrapper

    @my_decorator
    def greet(name):
        return f"Hello, {name}!"

    result = greet("Alice")
    assert result == "Hello, Alice!"

    # 验证函数名和文档字符串
    assert greet.__name__ == "greet"

    print("✓ 基础装饰器测试通过")

def test_decorator_with_args():
    """测试带参数的装饰器"""
    def repeat(times):
        def decorator(func):
            @wraps(func)
            def wrapper(*args, **kwargs):
                results = []
                for _ in range(times):
                    result = func(*args, **kwargs)
                    results.append(result)
                return results
            return wrapper
        return decorator

    @repeat(3)
    def greet(name):
        return f"Hello, {name}!"

    results = greet("Alice")
    assert results == ["Hello, Alice!", "Hello, Alice!", "Hello, Alice!"]

    print("✓ 带参数的装饰器测试通过")

def test_class_decorator():
    """测试类装饰器"""
    def singleton(cls):
        instances = {}

        @wraps(cls)
        def get_instance(*args, **kwargs):
            if cls not in instances:
                instances[cls] = cls(*args, **kwargs)
            return instances[cls]

        return get_instance

    @singleton
    class MyClass:
        def __init__(self, value):
            self.value = value

    # 创建两个实例
    instance1 = MyClass(10)
    instance2 = MyClass(20)

    # 验证是同一个实例
    assert instance1 is instance2
    assert instance1.value == 10  # 第一个创建的值

    print("✓ 类装饰器测试通过")

def test_basic_generator():
    """测试基础生成器"""
    def simple_generator():
        yield 1  # yield将函数变为生成器，惰性逐个产出值
        yield 2
        yield 3

    # 获取生成器
    gen = simple_generator()

    # 使用next获取值
    assert next(gen) == 1
    assert next(gen) == 2
    assert next(gen) == 3

    # 使用for循环
    gen = simple_generator()
    result = list(gen)
    assert result == [1, 2, 3]

    print("✓ 基础生成器测试通过")

def test_generator_expression():
    """测试生成器表达式"""
    # 生成器表达式
    squares = (x**2 for x in range(5))

    # 验证是生成器
    assert hasattr(squares, '__iter__')  # hasattr()检查对象是否拥有指定属性
    assert hasattr(squares, '__next__')

    # 转换为列表
    result = list(squares)
    assert result == [0, 1, 4, 9, 16]

    # 带条件的生成器表达式
    even_squares = (x**2 for x in range(10) if x % 2 == 0)
    result = list(even_squares)
    assert result == [0, 4, 16, 36, 64]

    print("✓ 生成器表达式测试通过")

def test_yield_from():
    """测试yield from"""
    def sub_generator1():
        yield 1
        yield 2

    def sub_generator2():
        yield 3
        yield 4

    def main_generator():
        yield from sub_generator1()  # yield from委托给子生成器，简化嵌套yield
        yield from sub_generator2()
        yield 5

    result = list(main_generator())
    assert result == [1, 2, 3, 4, 5]

    print("✓ yield from测试通过")

def test_context_manager():
    """测试上下文管理器"""
    class MyContext:
        def __enter__(self):
            print("Entering context")
            return self

        def __exit__(self, exc_type, exc_val, exc_tb):
            print("Exiting context")
            return False

    # 使用with语句
    with MyContext() as ctx:
        assert ctx is not None
        print("Inside context")

    print("✓ 基础上下文管理器测试通过")

from contextlib import contextmanager

def test_contextlib_decorator():
    """测试contextlib装饰器"""
    @contextmanager  # @contextmanager用yield将普通函数变为上下文管理器
    def my_context():
        print("Entering context")
        try:
            yield "resource"
        finally:
            print("Cleaning up")

    # 使用with语句
    with my_context() as resource:
        assert resource == "resource"
        print("Using resource")

    print("✓ contextlib装饰器测试通过")

import threading

def test_multithreading():
    """测试多线程"""
    results = []

    def worker(value):
        results.append(value * 2)

    # 创建线程
    threads = []
    for i in range(5):
        t = threading.Thread(target=worker, args=(i,))  # threading.Thread创建新线程执行并发任务
        threads.append(t)
        t.start()

    # 等待所有线程完成
    for t in threads:
        t.join()

    # 验证结果
    assert len(results) == 5
    assert set(results) == {0, 2, 4, 6, 8}

    print("✓ 多线程测试通过")

def test_thread_lock():
    """测试线程锁"""
    counter = 0
    lock = threading.Lock()

    def increment():
        nonlocal counter  # nonlocal声明引用外层函数的变量（非全局）
        for _ in range(1000):
            with lock:
                counter += 1

    # 创建线程
    threads = []
    for _ in range(10):
        t = threading.Thread(target=increment)
        threads.append(t)
        t.start()

    # 等待所有线程完成
    for t in threads:
        t.join()

    # 验证结果
    assert counter == 10000

    print("✓ 线程锁测试通过")

import asyncio

async def test_async_await():
    """测试async/await"""
    async def fetch_data(delay):  # async def定义协程函数，await暂停等待异步结果
        await asyncio.sleep(delay)
        return f"Data after {delay}s"

    # 创建协程
    coro1 = fetch_data(0.1)
    coro2 = fetch_data(0.2)

    # 并发执行
    results = await asyncio.gather(coro1, coro2)

    # 验证结果
    assert len(results) == 2
    assert "Data after 0.1s" in results[0]
    assert "Data after 0.2s" in results[1]

    print("✓ async/await测试通过")

def test_async_with_pytest():
    """在pytest中测试async函数"""
    asyncio.run(test_async_await())  # asyncio.run()启动异步事件循环并执行协程

import timeit

def test_list_comprehension_performance():
    """测试列表推导性能"""
    # 列表推导
    list_comp_time = timeit.timeit(
        "[x**2 for x in range(1000)]",
        number=1000,
        globals=globals(),
    )

    # for循环
    for_loop_time = timeit.timeit(
        """
result = []
for x in range(1000):
    result.append(x**2)
""",
        number=1000,
        globals=globals(),
    )

    print(f"列表推导时间: {list_comp_time:.4f}s")
    print(f"for循环时间: {for_loop_time:.4f}s")

    # 列表推导应该更快
    assert list_comp_time < for_loop_time

    print("✓ 列表推导性能测试通过")

import sys

def test_generator_memory():
    """测试生成器内存使用"""
    # 列表
    list_obj = [x**2 for x in range(1000000)]
    list_size = sys.getsizeof(list_obj)

    # 生成器
    gen_obj = (x**2 for x in range(1000000))
    gen_size = sys.getsizeof(gen_obj)

    print(f"列表大小: {list_size / 1024:.2f} KB")
    print(f"生成器大小: {gen_size / 1024:.2f} KB")

    # 生成器应该占用更少内存
    assert gen_size < list_size

    print("✓ 生成器内存测试通过")

def test_metaclass():
    """测试元类"""
    class SingletonMeta(type):
        _instances = {}

        def __call__(cls, *args, **kwargs):  # __call__使实例可像函数一样被调用
            if cls not in cls._instances:
                cls._instances[cls] = super().__call__(*args, **kwargs)  # super()调用父类方法
            return cls._instances[cls]

    class MyClass(metaclass=SingletonMeta):
        def __init__(self, value):
            self.value = value

    # 创建两个实例
    instance1 = MyClass(10)
    instance2 = MyClass(20)

    # 验证是同一个实例
    assert instance1 is instance2
    assert instance1.value == 10

    print("✓ 元类测试通过")

def test_dynamic_attributes():
    """测试动态属性访问"""
    class DynamicAttributes:
        def __init__(self):
            self._data = {}

        def __getattr__(self, name):
            if name.startswith('_'):
                raise AttributeError(name)
            return self._data.get(name, f"Default: {name}")

        def __setattr__(self, name, value):
            if name.startswith('_'):
                super().__setattr__(name, value)
            else:
                self._data[name] = value

    obj = DynamicAttributes()

    # 设置属性
    obj.name = "Alice"
    obj.age = 25

    # 获取属性
    assert obj.name == "Alice"
    assert obj.age == 25
    assert obj.city == "Default: city"

    # 访问不存在的私有属性（_data 存在于 __dict__ 中，不会触发 __getattr__）
    # __getattr__ 仅在常规属性查找失败时才被调用
    assert isinstance(obj._data, dict)  # _data 通过 super().__setattr__ 设置，可正常访问

    # 访问不存在的私有属性会触发 __getattr__，从而抛出 AttributeError
    try:
        _ = obj._nonexistent
        assert False, "Should raise AttributeError"
    except AttributeError:
        pass

    print("✓ 动态属性访问测试通过")