///! ACC-20中文标准测试
///! 测试ACC-20协议的所有功能

使用 ../acc/acc20;

// ============================================================================
// 测试合约
// ============================================================================

合约 ACC20测试 {
    私有 代币: ACC20基础;
    
    构造函数() {
        代币 = ACC20基础::新建(
            "测试代币",
            "TEST",
            18,
            1000000 * (10 ** 18)
        );
    }
    
    // 测试1: 基本信息查询
    函数 测试基本信息() {
        要求(代币.名称() == "测试代币", "名称错误");
        要求(代币.符号() == "TEST", "符号错误");
        要求(代币.小数位() == 18, "小数位错误");
        要求(代币.总供应量() == 1000000 * (10 ** 18), "总供应量错误");
    }
    
    // 测试2: 转账功能
    函数 测试转账() {
        让 发送者 = 消息::发送者();
        让 接收者 = 地址::从十六进制("0x1234567890123456789012345678901234567890");
        让 数量 = 1000 * (10 ** 18);
        
        // 转账前余额
        让 发送者余额前 = 代币.持有量(发送者);
        让 接收者余额前 = 代币.持有量(接收者);
        
        // 执行转账
        代币.转移(接收者, 数量);
        
        // 转账后余额
        让 发送者余额后 = 代币.持有量(发送者);
        让 接收者余额后 = 代币.持有量(接收者);
        
        // 验证
        要求(发送者余额后 == 发送者余额前 - 数量, "发送者余额错误");
        要求(接收者余额后 == 接收者余额前 + 数量, "接收者余额错误");
    }
    
    // 测试3: 授权功能
    函数 测试授权() {
        让 所有者 = 消息::发送者();
        让 授权者 = 地址::从十六进制("0x1234567890123456789012345678901234567890");
        让 数量 = 500 * (10 ** 18);
        
        // 授权前额度
        让 额度前 = 代币.授权额度(所有者, 授权者);
        要求(额度前 == 0, "初始额度应为0");
        
        // 执行授权
        代币.授权(授权者, 数量);
        
        // 授权后额度
        让 额度后 = 代币.授权额度(所有者, 授权者);
        要求(额度后 == 数量, "授权额度错误");
    }
    
    // 测试4: 转移从功能
    函数 测试转移从() {
        让 所有者 = 消息::发送者();
        让 授权者 = 地址::从十六进制("0x1234567890123456789012345678901234567890");
        让 接收者 = 地址::从十六进制("0x2345678901234567890123456789012345678901");
        让 授权数量 = 500 * (10 ** 18);
        让 转移数量 = 200 * (10 ** 18);
        
        // 先授权
        代币.授权(授权者, 授权数量);
        
        // 转移前余额和额度
        让 所有者余额前 = 代币.持有量(所有者);
        让 接收者余额前 = 代币.持有量(接收者);
        让 额度前 = 代币.授权额度(所有者, 授权者);
        
        // 执行转移从（需要模拟授权者调用）
        // 注意：实际测试需要切换调用者
        代币.转移从(所有者, 接收者, 转移数量);
        
        // 转移后余额和额度
        让 所有者余额后 = 代币.持有量(所有者);
        让 接收者余额后 = 代币.持有量(接收者);
        让 额度后 = 代币.授权额度(所有者, 授权者);
        
        // 验证
        要求(所有者余额后 == 所有者余额前 - 转移数量, "所有者余额错误");
        要求(接收者余额后 == 接收者余额前 + 转移数量, "接收者余额错误");
        要求(额度后 == 额度前 - 转移数量, "授权额度错误");
    }
    
    // 测试5: 增发功能
    函数 测试增发() {
        让 接收者 = 消息::发送者();
        让 增发数量 = 10000 * (10 ** 18);
        
        // 增发前
        让 总供应量前 = 代币.总供应量();
        让 余额前 = 代币.持有量(接收者);
        
        // 执行增发
        代币.增发(接收者, 增发数量);
        
        // 增发后
        让 总供应量后 = 代币.总供应量();
        让 余额后 = 代币.持有量(接收者);
        
        // 验证
        要求(总供应量后 == 总供应量前 + 增发数量, "总供应量错误");
        要求(余额后 == 余额前 + 增发数量, "余额错误");
    }
    
    // 测试6: 销毁功能
    函数 测试销毁() {
        让 持有者 = 消息::发送者();
        让 销毁数量 = 5000 * (10 ** 18);
        
        // 销毁前
        让 总供应量前 = 代币.总供应量();
        让 余额前 = 代币.持有量(持有者);
        
        // 执行销毁
        代币.销毁(销毁数量);
        
        // 销毁后
        让 总供应量后 = 代币.总供应量();
        让 余额后 = 代币.持有量(持有者);
        
        // 验证
        要求(总供应量后 == 总供应量前 - 销毁数量, "总供应量错误");
        要求(余额后 == 余额前 - 销毁数量, "余额错误");
    }
    
    // 测试7: 暂停功能
    函数 测试暂停() {
        // 暂停前应该可以转账
        让 接收者 = 地址::从十六进制("0x1234567890123456789012345678901234567890");
        代币.转移(接收者, 100);
        
        // 暂停
        代币.暂停();
        要求(代币.是否已暂停() == 真, "暂停状态错误");
        
        // 暂停后不能转账（这里会失败）
        // 代币.转移(接收者, 100); // 应该抛出错误
        
        // 恢复
        代币.恢复();
        要求(代币.是否已暂停() == 假, "恢复状态错误");
        
        // 恢复后可以转账
        代币.转移(接收者, 100);
    }
    
    // 运行所有测试
    函数 运行所有测试() {
        测试基本信息();
        测试转账();
        测试授权();
        测试转移从();
        测试增发();
        测试销毁();
        测试暂停();
    }
}