EP Asynchrony

[Test]/test.py

@@ -13,103 +13,61 @@ class Test(Asynchronous):
         super().__init__(c={"timeout":2},b={"timeout":10})
         self.a = 1
 
-async def geta(obj:Test) -> int:
-    # 字段a已在__init__中初始化，可以直接访问
-    if obj.is_field_initialized('a'):
-        print(f"geta:{obj.a}")
-        return obj.a
-    else:
-        # 使用异步方法获取
-        value = await obj.get_field_async('a')
-        print(f"geta:{value}")
-        return value
 
-async def getb(obj:Test) -> int:
-    # 字段b有超时设置但未初始化，使用异步方法获取
-    try:
-        value = await obj.get_field_async('b')
-        print(f"getb:{value}")
-        return value
-    except TimeoutError as e:
-        print(f"getb timeout: {e}")
-        raise
-
-async def getc(obj:Test) -> int:
-    # 字段c有超时设置但未初始化，使用异步方法获取
-    try:
-        value = await obj.get_field_async('c')
-        print(f"getc:{value}")
-        return value
-    except TimeoutError as e:
-        print(f"getc timeout: {e}")
-        raise
+async def seta(obj:Test, value:int, delay:float = 1) -> None:
+    await asyncio.sleep(delay)
+    obj.a = value
 
 async def setb(obj:Test, value:int, delay:float = 1) -> None:
     await asyncio.sleep(delay)
     obj.b = value
+    
+async def setc(obj:Test, value:int, delay:float = 1) -> None:
+    await asyncio.sleep(delay)
+    obj.c = value
 
 async def run():
     print("=== 测试优化后的异步字段系统 ===")
     test = Test()
     
     # 测试字段状态检查
-    print(f"字段初始化状态 - a: {test.is_field_initialized('a')}, b: {test.is_field_initialized('b')}, c: {test.is_field_initialized('c')}")
-    
-    # 测试超时设置查询
-    print(f"字段超时设置 - b: {test.get_field_timeout('b')}s, c: {test.get_field_timeout('c')}s")
+    assert test.is_field_initialized('a')
+    assert not test.is_field_initialized('b')
+    assert not test.is_field_initialized('c')
     
     print("\n=== 测试1：未设置值的情况（应该超时）===")
     try:
-        print("开始并发获取字段值...")
-        r = await asyncio.gather(geta(test), getb(test), getc(test))
-        print(f"结果: {r}")
+        print(f"失败: {test.a,test.b,test.c}")
+        raise RuntimeError("测试1应该超时")
     except Exception as e:
-        print(f"捕获到异常: {e}")
+        print(f"成功: {e}")
     
     print("\n=== 测试2：在超时前设置字段b的值 ===")
     # 创建新的测试实例
     test2 = Test()
-    print(f"设置前字段b初始化状态: {test2.is_field_initialized('b')}")
+    assert not test2.is_field_initialized('b')
     
-    try:
-        # 启动并发任务：设置b的值和获取b的值
-        print("启动并发任务：0.5秒后设置b=42，同时尝试获取b的值（超时10秒）")
-        
-        # 并发执行：设置b值（延迟0.5秒）和获取b值
-        results = await asyncio.gather(
-            setb(test2, 42, delay=0.5),  # 0.5秒后设置b=42
-            getb(test2),                 # 尝试获取b值（会等待直到被设置）
-            return_exceptions=True
-        )
-        
-        print(f"并发任务结果: {results}")
-        print(f"设置后字段b初始化状态: {test2.is_field_initialized('b')}")
-        
-        # 再次访问b，应该能立即获取到值
-        print("再次访问字段b（应该立即返回）:")
-        b_value = await test2.get_field_async('b')
-        print(f"字段b的值: {b_value}")
-        
-    except Exception as e:
-        print(f"测试2出现异常: {e}")
+    # 启动并发任务：设置b的值和获取b的值
+    # 并发执行：设置b值（延迟0.5秒）和获取b值
+    await asyncio.gather(
+        setb(test2, 42, delay=0.5),  # 0.5秒后设置b=42
+        return_exceptions=True
+    )
+    
+    assert test2.b == 42
+    assert test2.is_field_initialized('b')
+    assert test2.b == 42
     
-    print("\n=== 测试3：使用同步方式设置，异步方式获取 ===")
     test3 = Test()
-    print("使用同步方式设置字段b = 100")
     test3.b = 100
-    print(f"设置后字段b初始化状态: {test3.is_field_initialized('b')}")
+    assert test3.is_field_initialized('b')
+    assert test3.b == 100
     
-    # 异步获取值
-    b_sync_set_value = await test3.get_field_async('b')
-    print(f"异步获取同步设置的值: {b_sync_set_value}")
-    
-    print("\n=== 测试4：测试字段c（短超时，应该仍然超时）===")
+    print("\n=== 测试3：测试字段c（短超时，应该仍然超时）===")
     try:
-        print("尝试单独访问字段c（2秒超时）...")
-        c_value = await test.get_field_async('c')
-        print(f"字段c的值: {c_value}")
+        print(f"失败: {test.c}")
     except TimeoutError as timeout_e:
-        print(f"字段c访问超时（预期）: {timeout_e}")
+        print(f"成功: {timeout_e}")
 
 def test_sync_access():
     """测试同步访问（在非异步上下文中）"""
@@ -118,15 +76,16 @@ def test_sync_access():
     
     # 测试已初始化字段的同步访问
     try:
-        print(f"同步访问字段a: {test.a}")
+        print(f"成功: a = {test.a}")
     except Exception as e:
-        print(f"同步访问字段a失败: {e}")
+        raise
     
     # 测试未初始化字段的同步访问（应该有更友好的错误提示）
     try:
-        print(f"同步访问字段c: {test.c}")
+        print(f"失败: c = {test.c}")
+        raise RuntimeError("字段c此时不应该能够被访问")
     except Exception as e:
-        print(f"同步访问字段c失败 (预期): {e}")
+        print(f"成功: {e}")
 
 if __name__ == "__main__":
     # 测试同步访问