JsUnit User Guide

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', () => {
    // The test suite name is ActsAbilityTest.
    // You can filter test cases based on the type, size, and level.
    it('testExample', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => {
      // The test case name is testExample.
      await sleep(500);
      const bundleName = abilityDelegatorRegistry.getArguments().bundleName;
      // Start the ability to be tested.
      const want: Want = {
        bundleName: bundleName,
        abilityName: 'EntryAbility'
      }
      await delegator.startAbility(want);
      await sleep(500);
      // Obtain the page displayed in the foreground on the device and assert the check.
      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(); // The test case fails.
    })

    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, () => {
      // Create a MockKit object.
      let mocker: MockKit = new MockKit();
      // Initialize the ClassName object claser as the instance of the object to be mocked.
      let claser: ClassName = new ClassName();
      // Mock method_1 of the ClassName class.
      let mockfunc: Function = mocker.mockFunc(claser, claser.method_1);
      // It is expected that, after the claser.method_1 function is mocked, the result '1' is returned when the function is called with 'testA' passed in, and the result undefined is returned when the function is called with 'testB' passed in.
      when(mockfunc)('testA').afterReturn('1');
      when(mockfunc)('testB').afterReturnNothing();
      // Assert the mocked function to check whether the expected result is returned. If the function is called with 'testA' passed in, 1 should be returned. If called with 'testB' passed in, undefined should be returned.
      expect(claser.method_1('testA')).assertEqual('1'); // The assertion is successful.
      expect(claser.method_1('testB')).assertUndefined(); // The assertion is successful.
    })
  })
}

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, () => {
      // Create a MockKit object.
      let mocker: MockKit = new MockKit();
      // Initialize the ClassName object claser.
      let claser: ClassName = new ClassName();
      // Mock method_1 of the ClassName class.
      let mockfunc: Function = mocker.mockFunc(claser, claser.method_1);
      // It is expected that, after the claser.method_1 function is mocked, '1' is returned when the function is called with any parameter type.
      when(mockfunc)(ArgumentMatchers.any).afterReturn('1');
      // Pass different parameters to check whether the expected result is returned.
      expect(claser.method_1('test')).assertEqual('1'); // The assertion is successful.
      expect(claser.method_1('123')).assertEqual('1'); // The assertion is successful.
      expect(claser.method_1('true')).assertEqual('1'); // The assertion is successful.
    })
  })
}

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, () => {
      // Create a MockKit object.
      let mocker: MockKit = new MockKit();
      // Initialize the ClassName object claser.
      let claser: ClassName = new ClassName();
      // Mock method_1 of the ClassName class.
      let mockfunc: Function = mocker.mockFunc(claser, claser.method_1);
      // It is expected that, after the claser.method_1 function is mocked, '1' is returned when the function is called with any string type.
      when(mockfunc)(ArgumentMatchers.anyString).afterReturn('1');
      // Pass different string parameters to check whether the expected result is returned.
      expect(claser.method_1('test')).assertEqual('1'); // The assertion is successful.
      expect(claser.method_1('abc')).assertEqual('1'); // The assertion is successful.
    })
  })
}

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, () => {
      // Create a MockKit object.
      let mocker: MockKit = new MockKit();
      // Initialize the ClassName object claser.
      let claser: ClassName = new ClassName();
      // Mock method_1 of the ClassName class.
      let mockfunc: Function = mocker.mockFunc(claser, claser.method_1);
      // It is expected that, after the claser.method_1 function is mocked, '1' is returned when the function is called with "test" passed in.
      when(mockfunc)(ArgumentMatchers.matchRegexs(new RegExp("test"))).afterReturn('1');
      // Pass the test parameter and check whether the expected result is returned.
      expect(claser.method_1('test')).assertEqual('1'); // The assertion is successful.
    })
  })
}

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, () => {
      // Create a MockKit object.
      let mocker: MockKit = new MockKit();
      // Initialize the ClassName object claser.
      let claser: ClassName = new ClassName();
      // Mock method_1 and method_2 of the ClassName class.
      mocker.mockFunc(claser, claser.method_1);
      mocker.mockFunc(claser, claser.method_2);
      // Call the functions.
      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');
      // Verify that method_2 is executed only once when the parameter is '111'.
      mocker.verify('method_2', ['111']).once(); // The assertion is successful.
    })
  })
}

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, () => {
      // Create a MockKit object.
      let mocker: MockKit = new MockKit();
      // Initialize the ClassName object claser.
      let claser: ClassName = new ClassName();
      // Mock method_1 and method_2 of the ClassName class.
      let func_1: Function = mocker.mockFunc(claser, claser.method_1);
      let func_2: Function = mocker.mockFunc(claser, claser.method_2);
      // It is expected that, after the claser.method_1 function is mocked, '4' is returned when the function is called with the number parameter passed in.
      when(func_1)(ArgumentMatchers.anyNumber).afterReturn('4');
      // It is expected that, after the claser.method_2 function is mocked, '5' is returned when the function is called with the number parameter passed in.
      when(func_2)(ArgumentMatchers.anyNumber).afterReturn('5');
      // Call the functions.
      expect(claser.method_1(123)).assertEqual("4");
      expect(claser.method_2(456)).assertEqual("5");
      // Restore method_1.
      mocker.ignoreMock(claser, claser.method_1);
      // Call the claser.method_1 function.
      expect(claser.method_1(123)).assertEqual('888888'); // The assertion is successful.
    })
  })
}

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, () => {
      // Create a MockKit object.
      let mocker: MockKit = new MockKit();
      // Initialize the ClassName object claser.
      let claser: ClassName = new ClassName();
      // Mock method_1 and method_2 of the ClassName class.
      let func_1: Function = mocker.mockFunc(claser, claser.method_1);
      let func_2: Function = mocker.mockFunc(claser, claser.method_2);
      // It is expected that, after the claser.method_1 function is mocked, '4' is returned when the function is called with the number parameter passed in.
      when(func_1)(ArgumentMatchers.anyNumber).afterReturn('4');
      // It is expected that, after the claser.method_2 function is mocked, '5' is returned when the function is called with the number parameter passed in.
      when(func_2)(ArgumentMatchers.anyNumber).afterReturn('5');
      // Call the functions.
      expect(claser.method_1(123)).assertEqual('4');
      expect(claser.method_2(123)).assertEqual('5');
      // Restore all mock capabilities of the object.
      mocker.clear(claser);
      // Call the claser.method_1 and claser.method_2 functions and test the result.
      expect(claser.method_1(123)).assertEqual('888888'); // The assertion is successful.
      expect(claser.method_2(123)).assertEqual('999999'); // The assertion is successful.
    })
  })
}

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, () => {
      // Create a MockKit object.
      let mocker: MockKit = new MockKit();
      // Initialize the ClassName object claser.
      let claser: ClassName = new ClassName();
      // Mock method_1 of the ClassName class.
      let mockfunc: Function = mocker.mockFunc(claser, claser.method_1);
      // It is expected that, after the claser.method_1 function is mocked, error xxx is thrown when the function is called with the test parameter passed in.
      when(mockfunc)('test').afterThrow('error xxx');
      // Execute the mocked function, capture the exception, and use assertEqual() to check whether message meets the expectation.
      try {
        claser.method_1('test');
      } catch (e) {
        expect(e).assertEqual('error xxx'); // The assertion is successful.
      }
    })
  })
}

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) => {
      // Create a MockKit object.
      let mocker: MockKit = new MockKit();
      // Initialize the ClassName object claser.
      let claser: ClassName = new ClassName();
      // Mock method_1 of the ClassName class.
      let mockfunc: Function = mocker.mockFunc(claser, claser.method_1);
      // It is expected that, after the claser.method_1 function is mocked, a Promise object will be returned when the function is called with test as the parameter.
      when(mockfunc)('test').afterReturn(new Promise<string>((resolve: Function, reject: Function) => {
        resolve('success something');
      }));
      // Execute the mocked function, that is, execute the defined promise.
      let result = await claser.method_1('test');
      expect(result).assertEqual('success something'); // The assertion is successful.
      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, () => {
      // Create a MockKit object.
      let mocker: MockKit = new MockKit();
      // Initialize the ClassName object claser.
      let claser: ClassName = new ClassName();
      // Mock method_1 of the ClassName class.
      let func_1: Function = mocker.mockFunc(claser, claser.method_1);
      // It is expected that '4' is returned after the function is mocked.
      when(func_1)('123').afterReturn('4');
      // Call the functions.
      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();
      // Check whether method_1 with the parameter of 'abc' was executed twice.
      mocker.verify('method_1', ['abc']).times(2); // The assertion is successful.
      // Check whether method_1 with an empty value was executed at least twice.
      mocker.verify('method_1', []).atLeast(2); // The assertion is successful.
    })
  })
}

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');
      // Create a MockKit object.
      let mocker: MockKit = new MockKit();
      // Mock method_1 of the ClassName object.
      let func_1: Function = mocker.mockFunc(ClassName, ClassName.method_1);
      // It is expected that 'mock_data' is returned after the function is mocked.
      when(func_1)(ArgumentMatchers.any).afterReturn('mock_data');
      let mock_result = ClassName.method_1();
      expect(mock_result).assertEqual('mock_data'); // The assertion is successful.
      // Clear the mock capability.
      mocker.clear(ClassName);
      let really_result1 = ClassName.method_1();
      expect(really_result1).assertEqual('ClassName_method_1_call'); // The assertion is successful.
    })
  })
}

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. Create a MockKit object.
      let mocker: MockKit = new MockKit();
      // 2. Mock the private method of the ClassName object, for example, method_1.
      let func_1: Function = mocker.mockPrivateFunc(claser, "method_1");
      // 3. The expected result returned by the mocked function is 456.
      when(func_1)(ArgumentMatchers.any).afterReturn(456);
      let mock_result = claser.method(123);
      expect(mock_result).assertEqual(456);
      // Clear the mock capability.
      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. Create a MockKit object.
      let mocker: MockKit = new MockKit();
      // 2. Mock the member variable data of the ClassName object.
      mocker.mockProperty(claser, "data", 3);
      mocker.mockProperty(claser, "priData", 4);
      // 3. The expected values of the mocked member and private member are 3 and 4 respectively.
      let mock_result = claser.data;
      let mock_private_result = claser.method();
      expect(mock_result).assertEqual(3);
      expect(mock_private_result).assertEqual(4);
      // Clear the mock capability.
      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!!!');
    // Set data.
    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