单元测试框架使用指导

import { describe, expect, it, Level, Size, TestType } from '@ohos/hypium';
import { abilityDelegatorRegistry } from '@kit.TestKit';
import { UIAbility, Want } from '@kit.AbilityKit';

const delegator = abilityDelegatorRegistry.getAbilityDelegator();

function sleep(time: number) {
  return new Promise<void>((resolve: Function) => setTimeout(resolve, time));
}

export default function abilityTest() {
  describe('ActsAbilityTest', () => {
    // 测试套名称为ActsAbilityTest
    // 可根据此处设置的用例类型、用例规模、用例级别进行用例筛选
    it('testExample', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => {
      // 测试用例名称为testExample
      await sleep(500);
      const bundleName = abilityDelegatorRegistry.getArguments().bundleName;
      // 启动被测试Ability
      const want: Want = {
        bundleName: bundleName,
        abilityName: 'EntryAbility'
      }
      await delegator.startAbility(want);
      await sleep(500);
      // 获取设备上前台显示的页面并断言检查
      const ability: UIAbility = await delegator.getCurrentTopAbility();
      expect(ability.context.abilityInfo.name).assertEqual('EntryAbility');
      done();
    })
  })
}

BasicExample.test.ets

import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, Level } from '@ohos/hypium';

export default function exampleTest() {

  describe('order1_sample', () => {
    let testNumA: number = 1;
    let testNumB: number = 1;

    beforeAll(() => {
      testNumA++;
    })

    beforeEach(() => {
      testNumA++;
      testNumB++;
    })

    afterEach(() => {
      testNumA++;
    })

    afterAll(() => {
      let expectValue: number = 5;
      expect(testNumA).assertEqual(expectValue);
    })

    it('testExampleA', Level.LEVEL1, async (done: Function) => {
      let expectA: number = 3;
      let expectB: number = 2;
      expect(testNumA).assertEqual(expectA);
      expect(testNumB).assertEqual(expectB);
      done();
    })

    it('testExampleB', Level.LEVEL1, async (done: Function) => {
      let expectA: number = 5;
      let expectB: number = 3;
      expect(testNumA).assertEqual(expectA);
      expect(testNumB).assertEqual(expectB);
      done();
    })
  })
}

ExecuteOrder1.test.ets

import { afterItSpecified, beforeItSpecified, describe, expect, it, Level } from '@ohos/hypium';

export default function exampleTest() {

  describe('order2_sample', () => {
    let testNumA: number = 1;
    let testNumB: number = 1;

    beforeItSpecified(['testExampleB'], () => {
      testNumB++;
    })
    afterItSpecified(['testExampleA'], () => {
      testNumA++;
    })

    it('testExampleA', Level.LEVEL1, async (done: Function) => {
      expect(testNumA).assertEqual(1);
      expect(testNumB).assertEqual(1);
      done();
    })

    it('testExampleB', Level.LEVEL1, async (done: Function) => {
      expect(testNumA).assertEqual(2);
      expect(testNumB).assertEqual(2);
      done();
    })
  })
}

ExecuteOrder2.test.ets

import { describe, it, Level, xit } from '@ohos/hypium';

export default function describeExampleTest() {

  describe('order3_sample', () => {
    xit('testExampleA', Level.LEVEL1, async (done: Function) => {
      done();
    })

    it('testExampleB', Level.LEVEL1, async (done: Function) => {
      done();
    })
  })
}

ExecuteOrder3.test.ets

import { describe, beforeEach, afterEach, beforeEachIt, afterEachIt, it, expect } from '@ohos/hypium';
let str = "";
export default function test() {
  describe('test0', () => {
    beforeEach(async () => {
      str += "A"
    })
    beforeEachIt(async () => {
      str += "B"
    })
    afterEach(async () => {
      str += "C"
    })
    afterEachIt(async () => {
      str += "D"
    })
    it('test0000', 0, () => {
      expect(str).assertEqual("BA");
    })
    describe('test1', () => {
      beforeEach(async () => {
        str += "E"
      })
      beforeEachIt(async () => {
        str += "F"
      })
      it('test1111', 0, async () => {
        expect(str).assertEqual("BACDBFE");
      })
    })
  })
}

ExecuteOrder4.test.ets

import { describe, expect, it, Level } from '@ohos/hypium';

export default function exampleTest() {
  describe('ExampleTest', () => {
    it('assertCloseTest', Level.LEVEL1, () => {
      let a: number = 100;
      let b: number = 0.1;
      let c: number = 99;
      expect(a).assertClose(c, b);
    })

    it('assertContain_1', Level.LEVEL1, () => {
      let a = 'abc';
      expect(a).assertContain('b');
    })

    it('assertContain_2', Level.LEVEL1, () => {
      let a = [1, 2, 3];
      expect(a).assertContain(1);
    })

    it('assertEqualTest', Level.LEVEL1, () => {
      expect(3).assertEqual(3);
    })

    it('assertFailTest', Level.LEVEL1, () => {
      expect().assertFail(); // 用例失败
    })

    it('assertFalseTest', Level.LEVEL1, () => {
      expect(false).assertFalse();
    })

    it('assertTrueTest', Level.LEVEL1, () => {
      expect(true).assertTrue();
    })

    it('assertInstanceOfTest', Level.LEVEL1, () => {
      let a: string = 'strTest';
      expect(a).assertInstanceOf('String');
    })

    it('assertLargerTest', Level.LEVEL1, () => {
      expect(3).assertLarger(2);
    })

    it('assertLessTest', Level.LEVEL1, () => {
      expect(2).assertLess(3);
    })

    it('assertNullTest', Level.LEVEL1, () => {
      expect(null).assertNull();
    })

    it('assertThrowErrorTest', Level.LEVEL1, () => {
      expect(() => {
        throw new Error('test');
      }).assertThrowError('test');
    })

    it('assertUndefinedTest', Level.LEVEL1, () => {
      expect(undefined).assertUndefined();
    })

    it('assertLargerOrEqualTest', Level.LEVEL1, () => {
      expect(3).assertLargerOrEqual(3);
    })

    it('assertLessOrEqualTest', Level.LEVEL1, () => {
      expect(3).assertLessOrEqual(3);
    })

    it('assertNaNTest', Level.LEVEL1, () => {
      expect(Number.NaN).assertNaN(); // true
    })

    it('assertNegUnlimitedTest', Level.LEVEL1, () => {
      expect(Number.NEGATIVE_INFINITY).assertNegUnlimited(); // true
    })

    it('assertPosUnlimitedTest', Level.LEVEL1, () => {
      expect(Number.POSITIVE_INFINITY).assertPosUnlimited(); // true
    })

    it('deepEquals_null_true', Level.LEVEL1, () => {
      expect(null).assertDeepEquals(null);
    })

    it('deepEquals_array_not_have_true', Level.LEVEL1, () => {
      const a: Array<number> = [];
      const b: Array<number> = [];
      expect(a).assertDeepEquals(b);
    })

    it('deepEquals_map_equal_length_success', Level.LEVEL1, () => {
      const a: Map<number, number> = new Map();
      const b: Map<number, number> = new Map();
      a.set(1, 100);
      a.set(2, 200);
      b.set(1, 100);
      b.set(2, 200);
      expect(a).assertDeepEquals(b);
    })

    it('deepEquals_obj_success_1', Level.LEVEL1, () => {
      const a: SampleTest = { x: 1 };
      const b: SampleTest = { x: 1 };
      expect(a).assertDeepEquals(b);
    })

    it('deepEquals_regExp_success_0', Level.LEVEL1, () => {
      const a: RegExp = new RegExp('/test/');
      const b: RegExp = new RegExp('/test/');
      expect(a).assertDeepEquals(b);
    })

    it('assertPromiseIsPendingTest', Level.LEVEL1, async () => {
      let p: Promise<void> = new Promise<void>(() => {
      });
      await expect(p).assertPromiseIsPending();
    })

    it('assertPromiseIsRejectedTest', Level.LEVEL1, async () => {
      let info: PromiseInfo = { res: 'no' };
      let p: Promise<PromiseInfo> = Promise.reject(info);
      await expect(p).assertPromiseIsRejected();
    })

    it('assertPromiseIsRejectedWithTest', Level.LEVEL1, async () => {
      let info: PromiseInfo = { res: 'reject value' };
      let p: Promise<PromiseInfo> = Promise.reject(info);
      await expect(p).assertPromiseIsRejectedWith(info);
    })

    it('assertPromiseIsRejectedWithErrorTest', Level.LEVEL1, async () => {
      let p1: Promise<TypeError> = Promise.reject(new TypeError('number'));
      await expect(p1).assertPromiseIsRejectedWithError(TypeError);
    })

    it('assertPromiseIsResolvedTest', Level.LEVEL1, async () => {
      let info: PromiseInfo = { res: 'result value' };
      let p: Promise<PromiseInfo> = Promise.resolve(info);
      await expect(p).assertPromiseIsResolved();
    })

    it('assertPromiseIsResolvedWithTest', Level.LEVEL1, async () => {
      let info: PromiseInfo = { res: 'result value' };
      let p: Promise<PromiseInfo> = Promise.resolve(info);
      await expect(p).assertPromiseIsResolvedWith(info);
    })

    it('test_message', Level.LEVEL1, () => {
      expect(1).message('1 is not equal 2!').assertEqual(2); // fail
    })
  })
}

interface SampleTest {
  x: number;
}

interface PromiseInfo {
  res: string;
}

AssertExample.test.ets

import { describe, expect, it, MockKit, when } from '@ohos/hypium';

class ClassName {
  constructor() {
  }

  method_1(arg: string) {
    return '888888';
  }
}

export default function afterReturnTest() {
  describe('afterReturn_sample', () => {
    it('afterReturnTest', 0, () => {
      // 创建一个Mock能力的对象MockKit
      let mocker: MockKit = new MockKit();
      // 初始化ClassName的对象claser，作为被Mock的对象实例
      let claser: ClassName = new ClassName();
      // 进行Mock操作，对ClassName类的method_1函数进行Mock
      let mockfunc: Function = mocker.mockFunc(claser, claser.method_1);
      // 期望claser.method_1函数被Mock后, 以'testA'为入参时调用函数返回结果'1',以'testB''为入参时调用函数返回结果undefined
      when(mockfunc)('testA').afterReturn('1');
      when(mockfunc)('testB').afterReturnNothing();
      // 对Mock后的函数进行断言，看是否符合预期。分别传入参数'testA'和'testB'时，应该返回自定义的预期结果1和undefined
      expect(claser.method_1('testA')).assertEqual('1'); // 断言执行通过
      expect(claser.method_1('testB')).assertUndefined(); // 断言执行通过
    })
  })
}

AfterReturn.test.ets

import { ArgumentMatchers, describe, expect, it, MockKit, when } from '@ohos/hypium';

class ClassName {
  constructor() {
  }

  method_1(arg: string) {
    return '888888';
  }
}

export default function argumentMatchersAnyTest() {
  describe('argumentMatchersForAny_sample', () => {
    it('testMockfunc', 0, () => {
      // 创建一个Mock能力的对象MockKit
      let mocker: MockKit = new MockKit();
      // 初始化ClassName的对象claser
      let claser: ClassName = new ClassName();
      // 进行Mock操作，对ClassName类的method_1函数进行Mock
      let mockfunc: Function = mocker.mockFunc(claser, claser.method_1);
      // 期望claser.method_1函数被Mock后, 参数为任一类型在被调用时均返回结果'1'
      when(mockfunc)(ArgumentMatchers.any).afterReturn('1');
      // 传入不同参数验证是否符合预期
      expect(claser.method_1('test')).assertEqual('1'); // 断言执行通过
      expect(claser.method_1('123')).assertEqual('1'); // 断言执行通过
      expect(claser.method_1('true')).assertEqual('1'); // 断言执行通过
    })
  })
}

ArgumentMatchersForAny.test.ets

import { ArgumentMatchers, describe, expect, it, MockKit, when } from '@ohos/hypium';

class ClassName {
  constructor() {
  }

  method_1(arg: string) {
    return '888888';
  }
}

export default function argumentMatchersTest() {
  describe('argumentMatchersForString_sample', () => {
    it('testMockfunc', 0, () => {
      // 创建一个Mock能力的对象MockKit
      let mocker: MockKit = new MockKit();
      // 初始化ClassName的对象claser
      let claser: ClassName = new ClassName();
      // 进行Mock操作,对ClassName类的method_1函数进行Mock
      let mockfunc: Function = mocker.mockFunc(claser, claser.method_1);
      // 期望claser.method_1函数被Mock后, 以任何string类型为参数调用函数时返回结果'1'
      when(mockfunc)(ArgumentMatchers.anyString).afterReturn('1');
      // 传入不同string类型参数，验证是否符合预期
      expect(claser.method_1('test')).assertEqual('1'); // 断言执行通过
      expect(claser.method_1('abc')).assertEqual('1'); // 断言执行通过
    })
  })
}

ArgumentMatchersForString.test.ets

import { ArgumentMatchers, describe, expect, it, MockKit, when } from '@ohos/hypium';

class ClassName {
  constructor() {
  }

  method_1(arg: string) {
    return '888888';
  }
}

export default function matchRegexsTest() {
  describe('argumentMatchersForRegex_sample', () => {
    it('testMockfunc', 0, () => {
      // 创建一个Mock能力的对象MockKit
      let mocker: MockKit = new MockKit();
      // 初始化ClassName的对象claser
      let claser: ClassName = new ClassName();
      // 进行Mock操作，对ClassName类的method_1函数进行Mock
      let mockfunc: Function = mocker.mockFunc(claser, claser.method_1);
      // 期望claser.method_1函数被Mock后, 以"test"为入参调用函数时返回结果'1'
      when(mockfunc)(ArgumentMatchers.matchRegexs(new RegExp("test"))).afterReturn('1');
      // 传入test参数后验证是否符合预期
      expect(claser.method_1('test')).assertEqual('1'); // 断言执行通过
    })
  })
}

ArgumentMatchersForRegex.test.ets

import { describe, it, MockKit } from '@ohos/hypium';

class ClassName {
  constructor() {
  }

  method_1(...arg: string[]) {
    return '888888';
  }

  method_2(...arg: string[]) {
    return '999999';
  }
}

export default function verifyTest() {
  describe('verify_sample', () => {
    it('testMockfunc', 0, () => {
      // 创建一个Mock能力的对象MockKit
      let mocker: MockKit = new MockKit();
      // 初始化ClassName的对象claser
      let claser: ClassName = new ClassName();
      // 进行Mock操作，对ClassName类的method_1和method_2两个函数进行Mock
      mocker.mockFunc(claser, claser.method_1);
      mocker.mockFunc(claser, claser.method_2);
      // 函数调用
      claser.method_1('abc', 'ppp');
      claser.method_1('abc');
      claser.method_1('xyz');
      claser.method_1();
      claser.method_1('abc', 'xxx', 'yyy');
      claser.method_1();
      claser.method_2('111');
      claser.method_2('111', '222');
      // 对Mock后的两个函数进行验证，验证method_2,参数仅为'111'时执行过一次
      mocker.verify('method_2', ['111']).once(); // 断言执行通过
    })
  })
}

Vertify.test.ets

import { ArgumentMatchers, describe, expect, it, MockKit, when } from '@ohos/hypium';

class ClassName {
  constructor() {
  }

  method_1(...arg: number[]) {
    return '888888';
  }

  method_2(...arg: number[]) {
    return '999999';
  }
}

export default function ignoreMockTest() {
  describe('ignoreMock_sample', () => {
    it('testMockfunc', 0, () => {
      // 创建一个Mock能力的对象MockKit
      let mocker: MockKit = new MockKit();
      // 初始化ClassName的对象claser
      let claser: ClassName = new ClassName();
      // 进行Mock操作，对ClassName类的method_1和method_2两个函数进行Mock
      let func_1: Function = mocker.mockFunc(claser, claser.method_1);
      let func_2: Function = mocker.mockFunc(claser, claser.method_2);
      // 期望claser.method_1函数被Mock后, 以number类型为入参时调用函数返回结果'4'
      when(func_1)(ArgumentMatchers.anyNumber).afterReturn('4');
      // 期望claser.method_2函数被Mock后, 以number类型为入参时调用函数返回结果'5'
      when(func_2)(ArgumentMatchers.anyNumber).afterReturn('5');
      // 函数调用
      expect(claser.method_1(123)).assertEqual("4");
      expect(claser.method_2(456)).assertEqual("5");
      // 现在对Mock后的两个函数的其中一个函数method_1进行还原处理
      mocker.ignoreMock(claser, claser.method_1);
      // 调用claser.method_1函数
      expect(claser.method_1(123)).assertEqual('888888'); // 断言执行通过
    })
  })
}

IgnoreMock.test.ets

import { ArgumentMatchers, describe, expect, it, MockKit, when } from '@ohos/hypium';

class ClassName {
  constructor() {
  }

  method_1(...arg: number[]) {
    return '888888';
  }

  method_2(...arg: number[]) {
    return '999999';
  }
}

export default function clearTest() {
  describe('clearMock_sample', () => {
    it('testMockfunc', 0, () => {
      // 创建一个Mock能力的对象MockKit
      let mocker: MockKit = new MockKit();
      // 初始化ClassName的对象claser
      let claser: ClassName = new ClassName();
      // 进行Mock操作，对ClassName类的method_1和method_2两个函数进行Mock
      let func_1: Function = mocker.mockFunc(claser, claser.method_1);
      let func_2: Function = mocker.mockFunc(claser, claser.method_2);
      // 期望claser.method_1函数被Mock后, 以任何number类型为参数调用函数时返回结果'4'
      when(func_1)(ArgumentMatchers.anyNumber).afterReturn('4');
      // 期望claser.method_2函数被Mock后, 以任何number类型为参数调用函数时返回结果'5'
      when(func_2)(ArgumentMatchers.anyNumber).afterReturn('5');
      // 函数调用
      expect(claser.method_1(123)).assertEqual('4');
      expect(claser.method_2(123)).assertEqual('5');
      // 还原obj上所有的Mock能力
      mocker.clear(claser);
      // 调用claser.method_1,claser.method_2函数，测试结果
      expect(claser.method_1(123)).assertEqual('888888'); // 断言执行通过
      expect(claser.method_2(123)).assertEqual('999999'); // 断言执行通过
    })
  })
}

ClearMock.test.ets

import { describe, expect, it, MockKit, when } from '@ohos/hypium';

class ClassName {
  constructor() {
  }

  method_1(arg: string) {
    return '888888';
  }
}

export default function afterThrowTest() {
  describe('afterThrow_sample', () => {
    it('testMockfunc', 0, () => {
      // 创建一个Mock能力的对象MockKit
      let mocker: MockKit = new MockKit();
      // 初始化ClassName的对象claser
      let claser: ClassName = new ClassName();
      // 进行Mock操作,对ClassName类的method_1函数进行Mock
      let mockfunc: Function = mocker.mockFunc(claser, claser.method_1);
      // 期望claser.method_1函数被Mock后, 以'test'为参数调用函数时抛出error xxx异常
      when(mockfunc)('test').afterThrow('error xxx');
      // 执行Mock后的函数，捕捉异常并使用assertEqual对比msg否符合预期
      try {
        claser.method_1('test');
      } catch (e) {
        expect(e).assertEqual('error xxx'); // 断言执行通过
      }
    })
  })
}

AfterThrow.test.ets

import { describe, expect, it, MockKit, when } from '@ohos/hypium';

class ClassName {
  constructor() {
  }

  async method_1(arg: string) {
    return new Promise<string>((resolve: Function, reject: Function) => {
      setTimeout(() => {
        resolve('Data conversion');
      }, 2000);
    });
  }
}

export default function mockPromiseTest() {
  describe('returnPromise_sample', () => {
    it('testMockfunc', 0, async (done: Function) => {
      // 创建一个Mock能力的对象MockKit
      let mocker: MockKit = new MockKit();
      // 初始化ClassName的对象claser
      let claser: ClassName = new ClassName();
      // 进行Mock操作对ClassName类的method_1函数进行Mock
      let mockfunc: Function = mocker.mockFunc(claser, claser.method_1);
      // 期望claser.method_1函数被Mock后, 以'test'为参数调用函数时返回一个Promise对象
      when(mockfunc)('test').afterReturn(new Promise<string>((resolve: Function, reject: Function) => {
        resolve('success something');
      }));
      // 执行Mock后的函数，即对定义的Promise进行后续执行
      let result = await claser.method_1('test');
      expect(result).assertEqual('success something'); // 断言执行通过
      done();
    })
  })
}

ReturnPromise.test.ets

import { describe, it, MockKit, when } from '@ohos/hypium';

class ClassName {
  constructor() {
  }

  method_1(...arg: string[]) {
    return '888888';
  }
}

export default function verifyTimesTest() {
  describe('verifyTimes_sample', () => {
    it('test_verify_times', 0, () => {
      // 创建一个Mock能力的对象MockKit
      let mocker: MockKit = new MockKit();
      // 初始化ClassName的对象claser
      let claser: ClassName = new ClassName();
      // 进行Mock操作对ClassName类的method_1函数进行Mock
      let func_1: Function = mocker.mockFunc(claser, claser.method_1);
      // 期望被Mock后的函数返回结果'4'
      when(func_1)('123').afterReturn('4');
      // 函数调用
      claser.method_1('123', 'ppp');
      claser.method_1('abc');
      claser.method_1('xyz');
      claser.method_1();
      claser.method_1('abc', 'xxx', 'yyy');
      claser.method_1('abc');
      claser.method_1();
      // 验证函数method_1且参数为'abc'时，执行过的次数是否为2
      mocker.verify('method_1', ['abc']).times(2); // 断言执行通过
      // 验证函数method_1且参数为空时，是否至少执行过2次
      mocker.verify('method_1', []).atLeast(2); // 断言执行通过
    })
  })
}

VertifyTimes.test.ets

import { ArgumentMatchers, describe, expect, it, MockKit, when } from '@ohos/hypium';

class ClassName {
  constructor() {
  }

  static method_1() {
    return 'ClassName_method_1_call';
  }
}

export default function staticTest() {
  describe('mockStatic_sample', () => {
    it('staticTest_001', 0, () => {
      let really_result = ClassName.method_1();
      expect(really_result).assertEqual('ClassName_method_1_call');
      // 创建MockKit对象
      let mocker: MockKit = new MockKit();
      // Mock类ClassName对象的某个函数method_1
      let func_1: Function = mocker.mockFunc(ClassName, ClassName.method_1);
      // 期望被mock后的函数返回结果'mock_data'
      when(func_1)(ArgumentMatchers.any).afterReturn('mock_data');
      let mock_result = ClassName.method_1();
      expect(mock_result).assertEqual('mock_data'); // 断言执行通过
      // 清除Mock能力
      mocker.clear(ClassName);
      let really_result1 = ClassName.method_1();
      expect(really_result1).assertEqual('ClassName_method_1_call'); // 断言执行通过
    })
  })
}

MockStatic.test.ets

import { describe, it, expect, MockKit, when, ArgumentMatchers } from '@ohos/hypium';

class ClassName {
  constructor() {
  }
  method(arg: number):number {
    return this.method_1(arg);
  }
  private method_1(arg: number) {
    return arg;
  }
}

export default function staticTest() {
  describe('privateTest', () => {
    it('private_001', 0, () => {
      let claser: ClassName = new ClassName(); 
      let really_result = claser.method(123);
      expect(really_result).assertEqual(123);
      // 1.创建MockKit对象
      let mocker: MockKit = new MockKit();
      // 2.Mock类ClassName对象的私有方法，比如method_1
      let func_1: Function = mocker.mockPrivateFunc(claser, "method_1");
      // 3.期望被Mock后的函数返回结果为456
      when(func_1)(ArgumentMatchers.any).afterReturn(456);
      let mock_result = claser.method(123);
      expect(mock_result).assertEqual(456);
      // 清除Mock能力
      mocker.clear(claser);
      let really_result1 = claser.method(123);
      expect(really_result1).assertEqual(123);
    })
  })
}

MockPrivateFunc.test.ets

import { describe, it, expect, MockKit, when, ArgumentMatchers } from '@ohos/hypium';

class ClassName {
  constructor() {
  }
  data = 1;
  private priData = 2;
  method() {
    return this.priData;
  }
}

export default function staticTest() {
  describe('propertyTest', () => {
    it('property_001', 0, () => {
      let claser: ClassName = new ClassName(); 
      let data = claser.data;
      expect(data).assertEqual(1);
      let priData = claser.method();
      expect(priData).assertEqual(2);
      // 1.创建MockKit对象
      let mocker: MockKit = new MockKit();
      // 2.Mock类ClassName对象的成员变量data
      mocker.mockProperty(claser, "data", 3);
      mocker.mockProperty(claser, "priData", 4);
      // 3.期望被Mock后的成员和私有成员的值分别为3，4
      let mock_result = claser.data;
      let mock_private_result = claser.method();
      expect(mock_result).assertEqual(3);
      expect(mock_private_result).assertEqual(4);
      // 清除Mock能力
      mocker.ignoreMock(claser, "data");
      mocker.ignoreMock(claser, "priData");
      let really_result = claser.data;
      expect(really_result).assertEqual(1);
      let really_private_result = claser.method();
      expect(really_private_result).assertEqual(2);
    })
  })
}

MockProperty.test.ets

import { AbilityConstant, UIAbility, Want } from '@kit.AbilityKit';
import { abilityDelegatorRegistry } from '@kit.TestKit';
import { Hypium } from '@ohos/hypium';
import testsuite from '../test/List.test';
import data from '../test/data.json';
import Logger from '../util/Logger';
import { window } from '@kit.ArkUI';

const TAG = 'testTag';

export default class TestAbility extends UIAbility {
  onCreate(want: Want, launchParam: AbilityConstant.LaunchParam) {
    Logger.info(TAG, 'TestAbility onCreate');
    Logger.info(TAG, 'want param:' + JSON.stringify(want));
    Logger.info(TAG, 'launchParam:' + JSON.stringify(launchParam));
    let abilityDelegator = abilityDelegatorRegistry.getAbilityDelegator();
    let abilityDelegatorArguments = abilityDelegatorRegistry.getArguments();
    Logger.info(TAG, 'start run testcase!!!');
    // 设置数据
    Hypium.setData(data);
    Hypium.hypiumTest(abilityDelegator, abilityDelegatorArguments, testsuite);
  }

TestAbility.ets

import { describe, it } from '@ohos/hypium';

export default function abilityTest() {
  describe('AbilityTest', () => {
    it('testDataDriverAsync', 0, async (done: Function, data: ParamObj) => {
      done();
    });

    it('testDataDriver', 0, () => {
    });
  })
}

interface ParamObj {
  name: string,
  value: string
}

DataDriver.test.ets