鸿蒙软总线传输可靠性测试套件设计与实现 原创

#鸿蒙软总线传输可靠性测试套件设计与实现

一、测试套件架构设计

本测试套件基于鸿蒙分布式软总线技术，参考游戏场景中的多设备数据同步机制，构建完整的可靠性验证体系：

graph TD
    A[测试控制端] -->|发送测试指令| B(被测设备1)
    A -->|发送测试指令| C(被测设备2)
    B -->|软总线传输| D[可靠性分析引擎]
    C -->|软总线传输| D
    D --> E[生成测试报告]

二、核心测试模块实现

1. 测试控制服务（基于分布式数据同步）

// TestController.ets
import distributedData from '@ohos.data.distributedData';
import softBus from '@ohos.distributedBus';

class TestController {
  private static instance: TestController;
  private kvManager: distributedData.KVManager;
  private kvStore: distributedData.KVStore;
  private deviceList: TestDevice[] = [];
  
  static getInstance(): TestController {
    if (!TestController.instance) {
      TestController.instance = new TestController();
    }
    return TestController.instance;
  }
  
  private constructor() {
    this.initDistributedKV();
    this.initSoftBus();
  }
  
  private async initDistributedKV() {
    const config = {
      bundleName: 'com.example.softbus_test',
      userInfo: {
        userId: 'test_controller',
        userType: distributedData.UserType.SAME_USER_ID
      }
    };
    
    this.kvManager = distributedData.createKVManager(config);
    this.kvStore = await this.kvManager.getKVStore('test_control', {
      createIfMissing: true,
      autoSync: true,
      kvStoreType: distributedData.KVStoreType.SINGLE_VERSION
    });
    
    this.registerDeviceWatcher();
  }
  
  private initSoftBus() {
    softBus.createSession('softbus_test_session', {
      onMessage: this.handleSessionMessage.bind(this),
      onConnect: this.handleDeviceConnect.bind(this),
      onDisconnect: this.handleDeviceDisconnect.bind(this)
    });
  }
  
  async startReliabilityTest(testCase: TestCase): Promise<TestResult> {
    // 1. 分发测试用例
    await this.kvStore.put('current_test', testCase);
    
    // 2. 通过软总线发送测试数据包
    const packet = this.generateTestPacket(testCase);
    await this.broadcastPacket(packet);
    
    // 3. 收集测试结果
    return this.collectResults(testCase.timeout || 5000);
  }
  
  private broadcastPacket(packet: TestPacket): Promise<void> {
    const promises = this.deviceList.map(device => {
      return softBus.sendMessage('softbus_test_session', device.deviceId, packet);
    });
    return Promise.all(promises).then(() => {});
  }
  
  private async collectResults(timeout: number): Promise<TestResult> {
    return new Promise((resolve) => {
      const timer = setInterval(async () => {
        const results = await this.kvStore.get('test_results');
        if (results && results.length === this.deviceList.length) {
          clearInterval(timer);
          resolve(this.analyzeResults(results));
        }
      }, 500);
      
      setTimeout(() => {
        clearInterval(timer);
        resolve(this.analyzeResults(await this.kvStore.get('test_results') || []));
      }, timeout);
    });
  }
  
  private analyzeResults(rawResults: any[]): TestResult {
    // 实现可靠性分析算法
    const successCount = rawResults.filter(r => r.success).length;
    return {
      successRate: successCount / this.deviceList.length,
      avgLatency: this.calculateAvg(rawResults.map(r => r.latency)),
      packetLoss: this.calculatePacketLoss(rawResults)
    };
  }
}

2. 被测设备端实现

// TestDevice.ets
@Component
struct TestDevice {
  @State currentTest: TestCase | null = null;
  @State testStatus: 'idle' | 'running' | 'completed' = 'idle';
  private controller = TestController.getInstance();
  private receivedPackets: TestPacket[] = [];
  
  aboutToAppear() {
    this.registerTestHandler();
    this.joinTestSession();
  }
  
  build() {
    Column() {
      if (this.currentTest) {
        this.renderTestStatus()
      }
      Button('模拟网络波动')
        .onClick(this.simulateNetworkIssue)
    }
  }
  
  @Builder
  private renderTestStatus() {
    Column() {
      Text(`测试用例: ${this.currentTest?.name}`)
      Text(`状态: ${this.testStatus.toUpperCase()}`)
      Progress({
        value: this.receivedPackets.length,
        total: this.currentTest?.packetCount || 0
      })
    }
  }
  
  private joinTestSession() {
    softBus.joinSession('softbus_test_session', {
      onMessage: this.handleTestPacket.bind(this),
      onError: this.handleSessionError.bind(this)
    });
  }
  
  private async handleTestPacket(packet: TestPacket) {
    if (this.testStatus === 'idle') {
      this.testStatus = 'running';
    }
    
    // 记录接收时间和包序号
    this.receivedPackets.push({
      ...packet,
      receiveTime: Date.now()
    });
    
    // 返回ACK
    await this.sendAck(packet.seq);
    
    // 检查测试是否完成
    if (this.receivedPackets.length >= this.currentTest?.packetCount) {
      await this.submitTestResult();
    }
  }
  
  private async sendAck(seq: number): Promise<void> {
    const ackPacket: AckPacket = {
      type: 'ack',
      seq,
      sendTime: Date.now(),
      deviceId: await this.getDeviceId()
    };
    
    return softBus.sendMessage('softbus_test_session', this.controller.getDeviceId(), ackPacket);
  }
  
  private async submitTestResult() {
    const result: DeviceTestResult = {
      deviceId: await this.getDeviceId(),
      received: this.receivedPackets.length,
      expected: this.currentTest?.packetCount || 0,
      latency: this.calculateAvgLatency(),
      success: this.receivedPackets.length > 0
    };
    
    await this.controller.submitResult(result);
    this.testStatus = 'completed';
  }
  
  private simulateNetworkIssue() {
    // 模拟网络问题（丢包/延迟）
    softBus.simulateNetworkCondition({
      lossRate: 0.3, // 30%丢包
      delay: 500 // 500ms延迟
    });
  }
}

3. 测试用例定义

// TestCases.ets
interface TestCase {
  id: string;
  name: string;
  type: 'latency' | 'reliability' | 'throughput';
  packetCount: number;
  packetSize: number; // bytes
  timeout?: number;
}

interface TestPacket {
  seq: number;
  sendTime: number;
  payload: Uint8Array;
}

interface DeviceTestResult {
  deviceId: string;
  received: number;
  expected: number;
  latency: number;
  success: boolean;
}

interface TestResult {
  successRate: number;
  avgLatency: number;
  packetLoss: number;
}

const StandardTestCases: TestCase[] = [
  {
    id: 'basic-latency',
    name: '基础延迟测试',
    type: 'latency',
    packetCount: 100,
    packetSize: 512
  },
  {
    id: 'reliability-1',
    name: '可靠性测试-小包',
    type: 'reliability',
    packetCount: 500,
    packetSize: 128
  },
  {
    id: 'throughput-1',
    name: '吞吐量测试',
    type: 'throughput',
    packetCount: 1000,
    packetSize: 1024,
    timeout: 10000
  }
];

三、可靠性测试关键实现

1. 网络模拟模块

// NetworkSimulator.ets
class NetworkSimulator {
  private static instance: NetworkSimulator;
  private lossRate: number = 0;
  private delay: number = 0;
  
  static getInstance(): NetworkSimulator {
    if (!NetworkSimulator.instance) {
      NetworkSimulator.instance = new NetworkSimulator();
    }
    return NetworkSimulator.instance;
  }
  
  setup(condition: NetworkCondition) {
    this.lossRate = condition.lossRate;
    this.delay = condition.delay;
  }
  
  async sendWithSimulation(packet: any): Promise<boolean> {
    // 模拟丢包
    if (Math.random() < this.lossRate) {
      return false;
    }
    
    // 模拟延迟
    if (this.delay > 0) {
      await new Promise(resolve => setTimeout(resolve, this.delay));
    }
    
    return true;
  }
}

interface NetworkCondition {
  lossRate: number; // 0-1
  delay: number; // ms
}

2. 测试执行引擎

// TestEngine.ets
class TestEngine {
  private controller = TestController.getInstance();
  private networkSimulator = NetworkSimulator.getInstance();
  
  async runTestSuite() {
    const report: TestReport = {
      startTime: Date.now(),
      deviceCount: this.controller.getDeviceCount(),
      results: []
    };
    
    for (const testCase of StandardTestCases) {
      // 设置不同的网络条件
      this.setupNetworkCondition(testCase);
      
      const result = await this.controller.startReliabilityTest(testCase);
      report.results.push({
        testCase,
        result
      });
      
      // 重置网络条件
      this.networkSimulator.setup({ lossRate: 0, delay: 0 });
    }
    
    report.endTime = Date.now();
    return report;
  }
  
  private setupNetworkCondition(testCase: TestCase) {
    let condition: NetworkCondition = { lossRate: 0, delay: 0 };
    
    switch(testCase.type) {
      case 'reliability':
        condition.lossRate = 0.2; // 20%丢包
        break;
      case 'latency':
        condition.delay = 100; // 100ms延迟
        break;
      case 'throughput':
        condition = { lossRate: 0.1, delay: 50 };
        break;
    }
    
    this.networkSimulator.setup(condition);
  }
}

interface TestReport {
  startTime: number;
  endTime: number;
  deviceCount: number;
  results: {
    testCase: TestCase;
    result: TestResult;
  }[];
}

四、测试结果分析与可视化

1. 结果分析算法

// ResultAnalyzer.ets
class ResultAnalyzer {
  static analyze(report: TestReport): AnalyzedReport {
    const analyzed: AnalyzedReport = {
      summary: {
        totalTests: report.results.length,
        avgSuccessRate: 0,
        avgLatency: 0
      },
      details: []
    };
    
    let totalSuccess = 0;
    let totalLatency = 0;
    
    report.results.forEach(item => {
      totalSuccess += item.result.successRate;
      totalLatency += item.result.avgLatency;
      
      analyzed.details.push({
        testName: item.testCase.name,
        successRate: item.result.successRate,
        latency: item.result.avgLatency,
        packetLoss: item.result.packetLoss,
        score: this.calculateTestScore(item)
      });
    });
    
    analyzed.summary.avgSuccessRate = totalSuccess / report.results.length;
    analyzed.summary.avgLatency = totalLatency / report.results.length;
    
    return analyzed;
  }
  
  private static calculateTestScore(testItem: {
    testCase: TestCase;
    result: TestResult;
  }): number {
    const { testCase, result } = testItem;
    let score = 0;
    
    switch(testCase.type) {
      case 'latency':
        score = 100 - Math.min(result.avgLatency / 10, 100);
        break;
      case 'reliability':
        score = result.successRate * 100;
        break;
      case 'throughput':
        const expected = testCase.packetCount;
        const actual = expected * result.successRate;
        score = (actual / expected) * 100;
        break;
    }
    
    return Math.round(score);
  }
}

2. 可视化报告组件

// TestReportView.ets
@Component
struct TestReportView {
  @Prop report: AnalyzedReport;
  
  build() {
    Column() {
      // 摘要信息
      this.buildSummary()
      
      // 详细结果图表
      ForEach(this.report.details, item => {
        this.buildTestItem(item)
      })
    }
  }
  
  @Builder
  private buildSummary() {
    Row() {
      Column() {
        Text('平均成功率')
        Text(`${this.report.summary.avgSuccessRate.toFixed(1)}%`)
          .fontColor(this.getRateColor(this.report.summary.avgSuccessRate))
      }
      
      Column() {
        Text('平均延迟')
        Text(`${this.report.summary.avgLatency.toFixed(1)}ms`)
      }
    }
  }
  
  @Builder
  private buildTestItem(item: AnalyzedDetail) {
    Column() {
      Row() {
        Text(item.testName)
        Text(`${item.score}分`)
          .fontColor(this.getScoreColor(item.score))
      }
      
      // 成功率条形图
      Row() {
        Text('成功率:')
        Progress({
          value: item.successRate,
          total: 1,
          style: ProgressStyle.Linear
        })
      }
      
      // 延迟热力图
      Row() {
        Text('延迟:')
        HeatMap({
          value: item.latency,
          min: 0,
          max: 1000,
          colors: ['#4CAF50', '#FFC107', '#F44336']
        })
      }
    }
  }
  
  private getRateColor(rate: number): string {
    if (rate > 0.9) return '#4CAF50';
    if (rate > 0.7) return '#FFC107';
    return '#F44336';
  }
  
  private getScoreColor(score: number): string {
    if (score > 80) return '#4CAF50';
    if (score > 60) return '#FFC107';
    return '#F44336';
  }
}

五、典型测试场景示例

1. 基础可靠性测试

// BasicReliabilityTest.ets
async function runBasicReliabilityTest() {
  const controller = TestController.getInstance();
  
  const testCase: TestCase = {
    id: 'custom-reliability',
    name: '自定义可靠性测试',
    type: 'reliability',
    packetCount: 200,
    packetSize: 256
  };
  
  // 设置20%丢包率+100ms延迟
  NetworkSimulator.getInstance().setup({
    lossRate: 0.2,
    delay: 100
  });
  
  const result = await controller.startReliabilityTest(testCase);
  console.log('测试结果:', JSON.stringify(result, null, 2));
}

2. 多设备同步测试

// MultiDeviceSyncTest.ets
async function runMultiDeviceTest() {
  const engine = new TestEngine();
  const report = await engine.runTestSuite();
  
  // 显示可视化报告
  const analyzed = ResultAnalyzer.analyze(report);
  const reportView = new TestReportView();
  reportView.report = analyzed;
  
  // 保存测试报告
  ReportExporter.saveAsHtml(analyzed);
}

六、测试套件部署方案

1. 环境准备：

   # 安装测试包到所有设备
   hdc install -r com.example.softbus_test
   hdc shell aa start -p com.example.softbus_test
   

2. 执行测试：

   // 主控设备执行
   const testRunner = new TestRunner();
   testRunner.start();
   
   // 被测设备执行
   const testDevice = new TestDevice();
   testDevice.start();
   

3. 结果收集：

   hdc file recv /data/log/softbus_test_report.html
   

七、结论与优化建议

测试数据分析

优化建议

1. 协议层优化：

   // 增加重传机制
   class ReliableSender {
     async sendWithRetry(packet: TestPacket, maxRetry = 3): Promise<boolean> {
       for (let i = 0; i < maxRetry; i++) {
         if (await this.sendPacket(packet)) {
           return true;
         }
       }
       return false;
     }
   }
   

2. 传输策略优化：
   • 小包合并减少协议开销

   • 动态调整包大小适应网络状况

   • 重要数据优先传输

3. 设备协同优化：

   // 基于设备能力选择传输策略
   function selectTransportStrategy(device: TestDevice) {
     if (device.networkType === 'wifi') {
       return new HighThroughputStrategy();
     } else {
       return new ReliableStrategy();
     }
   }
   ``