unittest/pasteboardapi/PasteBoardPromiseJsunit.test.js

/*
 * Copyright (C) 2022-2023 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the 'License');
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an 'AS IS' BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
// @ts-nocheck
import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index';
import pasteboard from '@ohos.pasteboard';
import image from '@ohos.multimedia.image';

describe('PasteBoardJSTest', function () {
  beforeAll(async function () {
    console.info('beforeAll');
  });

  afterAll(async function () {
    console.info('afterAll');
  });

  /**
   * @tc.name      pasteboard_promise_test1
   * @tc.desc      Adds PlainTextData
   * @tc.type      Function
   * @tc.require   AR000H5HVI
   */
  it('pasteboard_promise_test1', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData1 = 'Hello World!';
    const pasteData = pasteboard.createPlainTextData(textData1);
    await systemPasteboard.setPasteData(pasteData);
    const res = await systemPasteboard.hasPasteData();
    expect(res).assertEqual(true);
    const types = pasteData.getMimeTypes();
    expect('text/plain').assertEqual(types[0]);
    systemPasteboard.getPasteData().then((data) => {
      const pasteData1 = data;
      expect(pasteData1.getRecordCount()).assertEqual(1);
      const primaryText = pasteData1.getPrimaryText();
      expect(primaryText).assertEqual(textData1);
      expect(pasteboard.MAX_RECORD_NUM).assertEqual(512);
      expect(pasteData1.getPrimaryMimeType()).assertEqual(pasteboard.MIMETYPE_TEXT_PLAIN);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test2
   * @tc.desc      Adds PlainTextData = ''
   * @tc.type      Function
   * @tc.require   AR000H5HVI
   */
  it('pasteboard_promise_test2', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData2 = '';
    const pasteData = pasteboard.createPlainTextData(textData2);
    await systemPasteboard.setPasteData(pasteData);
    const res2 = await systemPasteboard.hasPasteData();
    expect(res2).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      const recordCount2 = data.getRecordCount();
      expect(recordCount2).assertEqual(1);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test3
   * @tc.desc      Adds PlainTextData = 'Hello 中国!@#$%^&*()_+{}\?.'
   * @tc.type      Function
   * @tc.require   AR000H5HVI
   */
  it('pasteboard_promise_test3', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData3 = 'Hello 中国!@#$%^&*()_+{}?.';
    const pasteData = pasteboard.createPlainTextData(textData3);
    await systemPasteboard.setPasteData(pasteData);
    const res3 = await systemPasteboard.hasPasteData();
    expect(res3).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      const pasteData3 = data;
      expect(pasteData3.getRecordCount()).assertEqual(1);
      const primaryText = pasteData3.getPrimaryText();
      expect(primaryText).assertEqual(textData3);
      expect(pasteData3.hasMimeType(pasteboard.MIMETYPE_TEXT_PLAIN)).assertEqual(true);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test4
   * @tc.desc      Adds 300K PlainTextData
   * @tc.type      Function
   * @tc.require   AR000H5HVI
   */
  it('pasteboard_promise_test4', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    let textData4 = '';
    for (let i = 0; i < 300; i++) {
      textData4 = textData4 + 'A';
    }
    const pasteData = pasteboard.createPlainTextData(textData4);
    await systemPasteboard.setPasteData(pasteData);
    const res4 = await systemPasteboard.hasPasteData();
    expect(res4).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      const pasteData4 = data;
      expect(pasteData4.getRecordCount()).assertEqual(1);
      const primaryText = pasteData4.getPrimaryText();
      expect(primaryText).assertEqual(textData4);
      expect(pasteData4.hasMimeType(pasteboard.MIMETYPE_TEXT_PLAIN)).assertEqual(true);
      expect(pasteData4.getPrimaryMimeType()).assertEqual(pasteboard.MIMETYPE_TEXT_PLAIN);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test5
   * @tc.desc      Adds htmlText
   * @tc.type      Function
   * @tc.require   AR000H5HVI
   */
  it('pasteboard_promise_test5', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const htmlText5 = '<html><head></head><body>Hello World!</body></html>';
    const pasteData = pasteboard.createHtmlData(htmlText5);
    await systemPasteboard.setPasteData(pasteData);
    const res5 = await systemPasteboard.hasPasteData();
    expect(res5).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      const pasteData5 = data;
      expect(pasteData5.getRecordCount()).assertEqual(1);
      const primaryHtml6 = pasteData5.getPrimaryHtml();
      expect(primaryHtml6).assertEqual(htmlText5);
      expect(pasteData5.hasMimeType(pasteboard.MIMETYPE_TEXT_HTML)).assertEqual(true);
      expect(pasteData5.getPrimaryMimeType()).assertEqual(pasteboard.MIMETYPE_TEXT_HTML);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test6
   * @tc.desc      Adds htmlText = ''
   * @tc.type      Function
   * @tc.require   AR000H5HVI
   */
  it('pasteboard_promise_test6', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const htmlText6 = '';
    const pasteData = pasteboard.createHtmlData(htmlText6);
    await systemPasteboard.setPasteData(pasteData);
    const res6 = await systemPasteboard.hasPasteData();
    expect(res6).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      expect(data.getRecordCount()).assertEqual(1);
      const primaryHtml6 = data.getPrimaryHtml();
      expect(primaryHtml6).assertEqual(htmlText6);
      expect(data.hasMimeType(pasteboard.MIMETYPE_TEXT_HTML)).assertEqual(true);
      expect(data.getPrimaryMimeType()).assertEqual(pasteboard.MIMETYPE_TEXT_HTML);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test7
   * @tc.desc      Adds htmlText = 'Hello 中国!@#$%^&*()_+{}\?.'
   * @tc.type      Function
   * @tc.require   AR000H5HVI
   */
  it('pasteboard_promise_test7', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const htmlText = 'Hello 中国!@#$%^&*()_+{}?.';
    const pasteData = pasteboard.createHtmlData(htmlText);
    await systemPasteboard.setPasteData(pasteData);
    const res = await systemPasteboard.hasPasteData();
    expect(res).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      expect(data.getRecordCount()).assertEqual(1);
      expect(data.hasMimeType(pasteboard.MIMETYPE_TEXT_HTML)).assertEqual(true);
      expect(data.getPrimaryMimeType()).assertEqual(pasteboard.MIMETYPE_TEXT_HTML);
      expect(data.getPrimaryHtml()).assertEqual(htmlText);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test8
   * @tc.desc      Adds uriText
   * @tc.type      Function
   * @tc.require   AR000H5HVI
   */
  it('pasteboard_promise_test8', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const uriText8 = 'https://www.baidu.com/';
    const pasteData = pasteboard.createUriData(uriText8);
    await systemPasteboard.setPasteData(pasteData);
    const res8 = await systemPasteboard.hasPasteData();
    expect(res8).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      expect(data.getRecordCount()).assertEqual(1);
      const primaryUri8 = data.getPrimaryUri();
      expect(primaryUri8).assertEqual(uriText8);
      expect(data.hasMimeType(pasteboard.MIMETYPE_TEXT_URI)).assertEqual(true);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test9
   * @tc.desc      Adds uriText = ''
   * @tc.type      Function
   * @tc.require   AR000H5HVI
   */
  it('pasteboard_promise_test9', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const uriText9 = '';
    const pasteData = pasteboard.createUriData(uriText9);
    await systemPasteboard.setPasteData(pasteData);
    const res9 = await systemPasteboard.hasPasteData();
    expect(res9).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      expect(data.getRecordCount()).assertEqual(1);
      expect(data.getPrimaryUri()).assertEqual(uriText9);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test10
   * @tc.desc      Set uriText = 'Hello //'
   * @tc.type      Function
   * @tc.require   AR000H5HVI
   */
  it('pasteboard_promise_test10', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const uriText10 = 'Hello//';
    const pasteData = pasteboard.createUriData(uriText10);
    await systemPasteboard.setPasteData(pasteData);
    const res10 = await systemPasteboard.hasPasteData();
    expect(res10).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      expect(data.getRecordCount()).assertEqual(1);
      expect(data.hasMimeType(pasteboard.MIMETYPE_TEXT_URI)).assertEqual(true);
      expect(data.getPrimaryUri()).assertEqual(uriText10);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test11
   * @tc.desc      Adds want
   * @tc.type      Function
   * @tc.require   AR000H5HVI
   */
  it('pasteboard_promise_test11', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const want11 = {
      bundleName: 'com.example.myapplication8',
      abilityName: 'com.example.myapplication8.MainAbility',
    };
    const pasteData = pasteboard.createWantData(want11);
    await systemPasteboard.setPasteData(pasteData);
    const res11 = await systemPasteboard.hasPasteData();
    expect(res11).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      expect(data.getRecordCount()).assertEqual(1);
      const primaryWant = data.getPrimaryWant();
      expect(want11.bundleName).assertEqual(primaryWant.bundleName);
      expect(want11.abilityName).assertEqual(primaryWant.abilityName);
      expect(data.hasMimeType(pasteboard.MIMETYPE_TEXT_WANT)).assertEqual(true);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test12
   * @tc.desc      Adds one record(s)
   * @tc.type      Function
   * @tc.require   AR000H5HVI
   */
  it('pasteboard_promise_test12', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData12 = 'Hello World!';
    const pasteData = pasteboard.createPlainTextData(textData12);
    await systemPasteboard.setPasteData(pasteData);
    const res12 = await systemPasteboard.hasPasteData();
    expect(res12).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      expect(data.getRecordCount()).assertEqual(1);
      let recordText12 = data.getRecordAt(0).plainText;
      expect(recordText12).assertEqual(textData12);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test13
   * @tc.desc      Adds 2 record(s)
   * @tc.type      Function
   * @tc.require   AR000H5HVI
   */
  it('pasteboard_promise_test13', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData130 = 'Hello World!';
    const pasteData = pasteboard.createPlainTextData(textData130);
    const textData131 = 'Hello World1';
    pasteData.addTextRecord(textData131);
    await systemPasteboard.setPasteData(pasteData);
    const res13 = await systemPasteboard.hasPasteData();
    expect(res13).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      expect(data.getRecordCount()).assertEqual(2);
      const dataRecord130 = data.getRecordAt(0);
      const dataRecord131 = data.getRecordAt(1);
      expect(dataRecord130.plainText).assertEqual(textData131);
      expect(dataRecord131.plainText).assertEqual(textData130);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test14
   * @tc.desc      Adds 15 record(s)
   * @tc.type      Function
   * @tc.require   AR000H5HVI
   */
  it('pasteboard_promise_test14', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData140 = 'Hello World!';
    const pasteData = pasteboard.createPlainTextData(textData140);
    let textData14 = '';
    for (let i = 1; i < 15; i++) {
      textData14 = 'Hello World';
      textData14 = textData14 + i;
      pasteData.addTextRecord(textData14);
    }
    await systemPasteboard.setPasteData(pasteData);
    const res14 = await systemPasteboard.hasPasteData();
    expect(res14).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      expect(data.getRecordCount()).assertEqual(15);
      const dataRecord14 = data.getRecordAt(14);
      expect(dataRecord14.plainText).assertEqual(textData140);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test15
   * @tc.desc      Adds 30 record(s)
   * @tc.type      Function
   * @tc.require   AR000H5HVI
   */
  it('pasteboard_promise_test15', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData150 = 'Hello World!';
    const pasteData = pasteboard.createPlainTextData(textData150);
    let textData15 = '';
    for (let i = 1; i < 30; i++) {
      textData15 = 'Hello World';
      textData15 = textData15 + i;
      pasteData.addTextRecord(textData15);
    }
    await systemPasteboard.setPasteData(pasteData);
    const res15 = await systemPasteboard.hasPasteData();
    expect(res15).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      expect(data.getRecordCount()).assertEqual(30);
      const dataRecord15 = data.getRecordAt(0);
      expect(dataRecord15.plainText).assertEqual('Hello World29');
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test16
   * @tc.desc      Adds 31 record(s)
   * @tc.type      Function
   * @tc.require   AR000H5HVI
   */
  it('pasteboard_promise_test16', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData160 = 'Hello World!';
    const pasteData = pasteboard.createPlainTextData(textData160);
    let textData16 = '';
    for (let i = 1; i < 31; i++) {
      textData16 = 'Hello World';
      textData16 = textData16 + i;
      pasteData.addTextRecord(textData16);
    }
    await systemPasteboard.setPasteData(pasteData);
    const res16 = await systemPasteboard.hasPasteData();
    expect(res16).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      const recordCount16 = data.getRecordCount();
      expect(recordCount16).assertEqual(31);
      const dataRecord16 = data.getRecordAt(0);
      expect(dataRecord16.plainText).assertEqual('Hello World30');
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test17
   * @tc.desc      Adds PlainText,HtmlText,UriText
   * @tc.type      Function
   * @tc.require   AR000H5HVI
   */
  it('pasteboard_promise_test17', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData17 = 'Hello World!';
    const pasteData = pasteboard.createPlainTextData(textData17);
    const htmlText17 = '<html><head></head><body>Hello World!</body></html>';
    pasteData.addHtmlRecord(htmlText17);
    const uriText17 = 'https://www.baidu.com/';
    pasteData.addUriRecord(uriText17);
    const want17 = {
      bundleName: 'com.example.myapplication8',
      abilityName: 'com.example.myapplication8.MainAbility',
    };
    pasteData.addWantRecord(want17);
    await systemPasteboard.setPasteData(pasteData);
    const res17 = await systemPasteboard.hasPasteData();
    expect(res17).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      expect(data.getRecordCount()).assertEqual(4);
      const wantRecord17 = data.getPrimaryWant();
      expect(wantRecord17.bundleName).assertEqual(want17.bundleName);
      expect(wantRecord17.abilityName).assertEqual(want17.abilityName);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test18
   * @tc.desc      Delete one PlainTextData
   * @tc.type      Function
   * @tc.require   AR000H5HVI
   */
  it('pasteboard_promise_test18', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData18 = 'Hello World!';
    const pasteData = pasteboard.createPlainTextData(textData18);
    await systemPasteboard.setPasteData(pasteData);
    const res18 = await systemPasteboard.hasPasteData();
    expect(res18).assertEqual(true);
    const pasteData18 = await systemPasteboard.getPasteData();
    expect(pasteData18.getRecordCount()).assertEqual(1);
    expect(pasteData18.removeRecordAt(0)).assertEqual(true);
    await systemPasteboard.setPasteData(pasteData18);
    systemPasteboard.getPasteData().then((data) => {
      const recordCount18 = data.getRecordCount();
      expect(recordCount18).assertEqual(0);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test19
   * @tc.desc      Delete one htmlText
   * @tc.type      Function
   * @tc.require   AR000H5HVI
   */
  it('pasteboard_promise_test19', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const htmlText19 = '<html><head></head><body>Hello World!</body></html>';
    const pasteData = pasteboard.createHtmlData(htmlText19);
    await systemPasteboard.setPasteData(pasteData);
    const res19 = await systemPasteboard.hasPasteData();
    expect(res19).assertEqual(true);
    const pasteData19 = await systemPasteboard.getPasteData();
    expect(pasteData19.getRecordCount()).assertEqual(1);
    expect(pasteData19.removeRecordAt(0)).assertEqual(true);
    await systemPasteboard.setPasteData(pasteData19);
    systemPasteboard.getPasteData().then((data) => {
      const recordCount19 = data.getRecordCount();
      expect(recordCount19).assertEqual(0);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test20
   * @tc.desc      Delete one uriText
   * @tc.type      Function
   * @tc.require   AR000H5HVI
   */
  it('pasteboard_promise_test20', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const uriText20 = 'https://www.baidu.com/';
    const pasteData = pasteboard.createUriData(uriText20);
    await systemPasteboard.setPasteData(pasteData);
    const res20 = await systemPasteboard.hasPasteData();
    expect(res20).assertEqual(true);
    const pasteData20 = await systemPasteboard.getPasteData();
    expect(pasteData20.getRecordCount()).assertEqual(1);
    expect(pasteData20.removeRecordAt(0)).assertEqual(true);
    await systemPasteboard.setPasteData(pasteData20);
    systemPasteboard.getPasteData().then((data) => {
      const recordCount20 = data.getRecordCount();
      expect(recordCount20).assertEqual(0);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test21
   * @tc.desc      Delete one want
   * @tc.type      Function
   * @tc.require   AR000H5I1D
   */
  it('pasteboard_promise_test21', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const want21 = {
      bundleName: 'com.example.myapplication8',
      abilityName: 'com.example.myapplication8.MainAbility',
    };
    const pasteData = pasteboard.createWantData(want21);
    await systemPasteboard.setPasteData(pasteData);
    const res21 = await systemPasteboard.hasPasteData();
    expect(res21).assertEqual(true);
    const pasteData21 = await systemPasteboard.getPasteData();
    expect(pasteData21.getRecordCount()).assertEqual(1);
    expect(pasteData21.removeRecordAt(0)).assertEqual(true);
    await systemPasteboard.setPasteData(pasteData21);
    systemPasteboard.getPasteData().then((data) => {
      const recordCount21 = data.getRecordCount();
      expect(recordCount21).assertEqual(0);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test22
   * @tc.desc      Deletes 300K PlainTextData
   * @tc.type      Function
   * @tc.require   AR000H5I1D
   */
  it('pasteboard_promise_test22', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    let textData22 = '';
    for (let i = 0; i < 300; i++) {
      textData22 = textData22 + 'A';
    }
    const pasteData = pasteboard.createPlainTextData(textData22);
    await systemPasteboard.setPasteData(pasteData);
    const res22 = await systemPasteboard.hasPasteData();
    expect(res22).assertEqual(true);
    const pasteData22 = await systemPasteboard.getPasteData();
    expect(pasteData22.getRecordCount()).assertEqual(1);
    expect(pasteData22.removeRecordAt(0)).assertEqual(true);
    await systemPasteboard.setPasteData(pasteData22);
    systemPasteboard.getPasteData().then((data) => {
      const recordCount22 = data.getRecordCount();
      expect(recordCount22).assertEqual(0);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test23
   * @tc.desc      Deletes 30 record(s)
   * @tc.type      Function
   * @tc.require   AR000H5I1D
   */
  it('pasteboard_promise_test23', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData230 = 'Hello World';
    const pasteData = pasteboard.createPlainTextData(textData230);
    let textData23 = '';
    for (let i = 1; i < 30; i++) {
      textData23 = 'Hello World';
      textData23 = textData23 + i;
      pasteData.addTextRecord(textData23);
    }
    await systemPasteboard.setPasteData(pasteData);
    const res23 = await systemPasteboard.hasPasteData();
    expect(res23).assertEqual(true);
    const pasteData23 = await systemPasteboard.getPasteData();
    expect(pasteData23.getRecordCount()).assertEqual(30);
    for (let i = 0; i < 30; i++) {
      expect(pasteData23.removeRecordAt(0)).assertEqual(true);
    }
    expect(pasteData23.getRecordCount()).assertEqual(0);
    systemPasteboard.setPasteData(pasteData23).then(() => {
      systemPasteboard.getPasteData().then((data) => {
        let recordCount23 = data.getRecordCount();
        expect(recordCount23).assertEqual(0);
        done();
      });
    });
  });

  /**
   * @tc.name      pasteboard_promise_test24
   * @tc.desc      Deletes replaced record
   * @tc.type      Function
   * @tc.require   AR000H5I1D
   */
  it('pasteboard_promise_test24', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData24 = 'Hello World!';
    const pasteData = pasteboard.createPlainTextData(textData24);
    await systemPasteboard.setPasteData(pasteData);
    const res24 = await systemPasteboard.hasPasteData();
    expect(res24).assertEqual(true);
    const pasteData24 = await systemPasteboard.getPasteData();
    expect(pasteData24.getRecordCount()).assertEqual(1);
    const textData241 = 'Hello World1';
    const pasteDataRecord = pasteboard.createPlainTextRecord(textData241);
    const replace = pasteData24.replaceRecordAt(0, pasteDataRecord);
    expect(replace).assertEqual(true);
    const primaryText = pasteData24.getPrimaryText();
    expect(primaryText).assertEqual(textData241);
    expect(pasteData24.hasMimeType(pasteboard.MIMETYPE_TEXT_PLAIN)).assertEqual(true);
    const dataRecord = pasteData24.getRecordAt(0);
    expect(dataRecord.plainText).assertEqual(textData241);
    expect(pasteData24.removeRecordAt(0)).assertEqual(true);
    systemPasteboard.setPasteData(pasteData24).then(() => {
      systemPasteboard.getPasteData().then((data) => {
        const recordCount24 = data.getRecordCount();
        expect(recordCount24).assertEqual(0);
        done();
      });
    });
  });

  /**
   * @tc.name      pasteboard_promise_test25
   * @tc.desc      Deletes 文本、uri、html
   * @tc.type      Function
   * @tc.require   AR000H5I1D
   */
  it('pasteboard_promise_test25', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData25 = 'Hello World!';
    const pasteData = pasteboard.createPlainTextData(textData25);
    const htmlText25 = '<html><head></head><body>Hello World!</body></html>';
    pasteData.addHtmlRecord(htmlText25);
    const uriText25 = 'https://www.baidu.com/';
    pasteData.addUriRecord(uriText25);
    await systemPasteboard.setPasteData(pasteData);
    const res25 = await systemPasteboard.hasPasteData();
    expect(res25).assertEqual(true);
    const pasteData25 = await systemPasteboard.getPasteData();
    expect(pasteData25.getRecordCount()).assertEqual(3);
    expect(pasteData25.removeRecordAt(0)).assertEqual(true);
    expect(pasteData25.removeRecordAt(0)).assertEqual(true);
    expect(pasteData25.removeRecordAt(0)).assertEqual(true);
    systemPasteboard.setPasteData(pasteData25).then(() => {
      systemPasteboard.getPasteData().then((data) => {
        const recordCount25 = data.getRecordCount();
        expect(recordCount25).assertEqual(0);
        done();
      });
    });
  });

  /**
   * @tc.name      pasteboard_promise_test26
   * @tc.desc      Replaces 文本 record
   * @tc.type      Function
   * @tc.require   AR000H5I1D
   */
  it('pasteboard_promise_test26', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData26 = 'Hello World!';
    const pasteData = pasteboard.createPlainTextData(textData26);
    await systemPasteboard.setPasteData(pasteData);
    const res26 = await systemPasteboard.hasPasteData();
    expect(res26).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      const pasteData26 = data;
      expect(pasteData26.getRecordCount()).assertEqual(1);
      const textData261 = 'Hello World1';
      const pasteDataRecord = pasteboard.createPlainTextRecord(textData261);
      const replace26 = pasteData26.replaceRecordAt(0, pasteDataRecord);
      expect(replace26).assertEqual(true);
      const primaryText26 = pasteData26.getPrimaryText();
      expect(primaryText26).assertEqual(textData261);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test27
   * @tc.desc      Replaces htmlText record
   * @tc.type      Function
   * @tc.require   AR000H5I1D
   */
  it('pasteboard_promise_test27', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const htmlText27 = '<html><head></head><body>Hello World!</body></html>';
    const pasteData = pasteboard.createHtmlData(htmlText27);
    await systemPasteboard.setPasteData(pasteData);
    const res27 = await systemPasteboard.hasPasteData();
    expect(res27).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      const pasteData27 = data;
      expect(pasteData27.getRecordCount()).assertEqual(1);
      const htmlText27 = '<html><head></head><body>Hello World 1</body></html>';
      const pasteDataRecord = pasteboard.createHtmlTextRecord(htmlText27);
      const replace27 = pasteData27.replaceRecordAt(0, pasteDataRecord);
      expect(replace27).assertEqual(true);
      const primaryHtml271 = pasteData27.getPrimaryHtml();
      expect(primaryHtml271).assertEqual(htmlText27);
      expect(pasteData27.hasMimeType(pasteboard.MIMETYPE_TEXT_HTML)).assertEqual(true);
      const primaryHtml272 = pasteData27.getPrimaryHtml();
      expect(primaryHtml272).assertEqual(htmlText27);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test28
   * @tc.desc      Replaces uri record
   * @tc.type      Function
   * @tc.require   AR000H5I1D
   */
  it('pasteboard_promise_test28', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const uriText28 = 'https://www.baidu.com/';
    const pasteData = pasteboard.createUriData(uriText28);
    await systemPasteboard.setPasteData(pasteData);
    const res28 = await systemPasteboard.hasPasteData();
    expect(res28).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      const pasteData28 = data;
      expect(pasteData28.getRecordCount()).assertEqual(1);
      const uriText281 = 'https://www.baidu.com/1';
      const pasteDataRecord = pasteboard.createUriRecord(uriText281);
      const replace28 = pasteData28.replaceRecordAt(0, pasteDataRecord);
      expect(replace28).assertEqual(true);
      const primaryUri1 = pasteData28.getPrimaryUri();
      expect(primaryUri1).assertEqual(uriText281);
      expect(pasteData28.hasMimeType(pasteboard.MIMETYPE_TEXT_URI)).assertEqual(true);
      const primaryUri2 = pasteData28.getPrimaryUri();
      expect(primaryUri2).assertEqual(uriText281);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test29
   * @tc.desc      Replaces want record
   * @tc.type      Function
   * @tc.require   AR000H5I1D
   */
  it('pasteboard_promise_test29', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const wantText29 = {
      bundleName: 'com.example.myapplication3',
      abilityName: 'com.example.myapplication3.MainAbility',
    };
    const pasteData = pasteboard.createData(pasteboard.MIMETYPE_TEXT_WANT, wantText29);
    await systemPasteboard.setPasteData(pasteData);
    const res29 = await systemPasteboard.hasPasteData();
    expect(res29).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      const pasteData29 = data;
      expect(pasteData29.getRecordCount()).assertEqual(1);
      const wantText291 = {
        bundleName: 'com.example.myapplication30',
        abilityName: 'com.example.myapplication30.MainAbility',
      };
      const pasteDataRecord = pasteboard.createRecord(pasteboard.MIMETYPE_TEXT_WANT, wantText291);
      const replace29 = pasteData29.replaceRecordAt(0, pasteDataRecord);
      expect(replace29).assertEqual(true);
      const primaryWant29 = pasteData29.getPrimaryWant();
      expect(primaryWant29.bundleName).assertEqual(wantText291.bundleName);
      expect(primaryWant29.abilityName).assertEqual(wantText291.abilityName);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test30
   * @tc.desc      Replaces 300k文本 record
   * @tc.type      Function
   * @tc.require   AR000H5I1D
   */
  it('pasteboard_promise_test30', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    let textData30 = '';
    for (let i = 0; i < 300; i++) {
      textData30 = textData30 + 'A';
    }
    const pasteData = pasteboard.createPlainTextData(textData30);
    await systemPasteboard.setPasteData(pasteData);
    const res30 = await systemPasteboard.hasPasteData();
    expect(res30).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      const pasteData30 = data;
      expect(pasteData30.getRecordCount()).assertEqual(1);
      const textData301 = 'Hello World1';
      const pasteDataRecord = pasteboard.createPlainTextRecord(textData301);
      const replace = pasteData30.replaceRecordAt(0, pasteDataRecord);
      expect(replace).assertEqual(true);
      const primaryText = pasteData30.getPrimaryText();
      expect(primaryText).assertEqual(textData301);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test31
   * @tc.desc      Clears pasteBoard, gets record count
   * @tc.type      Function
   * @tc.require   AR000H5I1D
   */
  it('pasteboard_promise_test31', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData31 = 'Hello World!';
    const pasteData = pasteboard.createPlainTextData(textData31);
    await systemPasteboard.setPasteData(pasteData);
    const res31 = await systemPasteboard.hasPasteData();
    expect(res31).assertEqual(true);
    const pasteData31 = await systemPasteboard.getPasteData();
    expect(pasteData31.getRecordCount()).assertEqual(1);
    await systemPasteboard.clearData();
    systemPasteboard.getPasteData().then((data) => {
      const pasteData2 = data;
      const recordCount = pasteData2.getRecordCount();
      expect(recordCount).assertEqual(0);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test32
   * @tc.desc      Adds Property
   * @tc.type      Function
   * @tc.require   AR000H5I1D
   */
  it('pasteboard_promise_test32', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData32 = 'Hello World!';
    const pasteData = pasteboard.createPlainTextData(textData32);
    await systemPasteboard.setPasteData(pasteData);
    const res32 = await systemPasteboard.hasPasteData();
    expect(res32).assertEqual(true);
    const pasteData32 = await systemPasteboard.getPasteData();
    expect(pasteData32.getRecordCount()).assertEqual(1);
    const pasteDataProperty = pasteData32.getProperty();
    expect(pasteDataProperty.shareOption).assertEqual(pasteboard.ShareOption.CrossDevice);
    pasteDataProperty.shareOption = pasteboard.ShareOption.InApp;
    pasteData32.setProperty(pasteDataProperty);
    expect(pasteData32.getProperty().shareOption).assertEqual(pasteboard.ShareOption.InApp);
    done();
  });

  /**
   * @tc.name      pasteboard_promise_test33
   * @tc.desc      Clears pasteBoard and check property
   * @tc.type      Function
   * @tc.require   AR000H5I1D
   */
  it('pasteboard_promise_test33', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData33 = 'Hello World!';
    const pasteData = pasteboard.createPlainTextData(textData33);
    await systemPasteboard.setPasteData(pasteData);
    const res33 = await systemPasteboard.hasPasteData();
    expect(res33).assertEqual(true);
    systemPasteboard.getPasteData().then(async (data) => {
      expect(data.getRecordCount()).assertEqual(1);
      await systemPasteboard.clearData();
      const newPasteData = await systemPasteboard.getPasteData();
      expect(newPasteData.getProperty().shareOption).assertEqual(pasteboard.ShareOption.CrossDevice);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test34
   * @tc.desc      打开内容变化通知功能
   * @tc.type      Function
   * @tc.require   AR000H5I1D
   */
  it('pasteboard_promise_test34', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    systemPasteboard.on('update', contentChanges);
    const textData34 = 'Hello World!';
    const pasteData = pasteboard.createPlainTextData(textData34);
    await systemPasteboard.setPasteData(pasteData);
    const res34 = await systemPasteboard.hasPasteData();
    expect(res34).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      expect(data.getRecordCount()).assertEqual(1);
      expect(data.removeRecordAt(0)).assertEqual(true);
      expect(data.getRecordCount()).assertEqual(0);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test35
   * @tc.desc      清除剪切板内的文本数据项
   * @tc.type      Function
   * @tc.require   AR000H5I1D
   */
  it('pasteboard_promise_test35', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData35 = 'Hello World!';
    const pasteData = pasteboard.createPlainTextData(textData35);
    await systemPasteboard.setPasteData(pasteData);
    const res35 = await systemPasteboard.hasPasteData();
    expect(res35).assertEqual(true);
    const pasteData35 = await systemPasteboard.getPasteData();
    expect(pasteData35.getRecordCount()).assertEqual(1);
    await systemPasteboard.clearData();
    systemPasteboard.getPasteData().then((data) => {
      const recordCount35 = data.getRecordCount();
      expect(recordCount35).assertEqual(0);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test36
   * @tc.desc      清除剪切板内的uri数据项
   * @tc.type      Function
   * @tc.require   AR000H5I1D
   */
  it('pasteboard_promise_test36', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const uriText36 = 'https://www.baidu.com/';
    const pasteData = pasteboard.createUriData(uriText36);
    await systemPasteboard.setPasteData(pasteData);
    const res36 = await systemPasteboard.hasPasteData();
    expect(res36).assertEqual(true);
    const pasteData36 = await systemPasteboard.getPasteData();
    expect(pasteData36.getRecordCount()).assertEqual(1);
    await systemPasteboard.clearData();
    systemPasteboard.getPasteData().then((data) => {
      const recordCount36 = data.getRecordCount();
      expect(recordCount36).assertEqual(0);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test37
   * @tc.desc      清除剪切板内的html数据项
   * @tc.type      Function
   * @tc.require   AR000H5I1D
   */
  it('pasteboard_promise_test37', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const htmlText37 = '<html><head></head><body>Hello World!</body></html>';
    const pasteData = pasteboard.createHtmlData(htmlText37);
    await systemPasteboard.setPasteData(pasteData);
    const res37 = await systemPasteboard.hasPasteData();
    expect(res37).assertEqual(true);
    const pasteData37 = await systemPasteboard.getPasteData();
    expect(pasteData37.getRecordCount()).assertEqual(1);
    await systemPasteboard.clearData();
    systemPasteboard.getPasteData().then((data) => {
      const recordCount37 = data.getRecordCount();
      expect(recordCount37).assertEqual(0);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test38
   * @tc.desc      清除剪切板内的want数据项
   * @tc.type      Function
   * @tc.require   AR000H5I1D
   */
  it('pasteboard_promise_test38', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const myWant38 = {
      bundleName: 'com.example.myapplication55',
      abilityName: 'com.example.myapplication55.MainAbility',
    };
    const pasteData381 = pasteboard.createWantData(myWant38);
    await systemPasteboard.setPasteData(pasteData381);
    const res38 = await systemPasteboard.hasPasteData();
    expect(res38).assertEqual(true);
    const pasteData38 = await systemPasteboard.getPasteData();
    expect(pasteData38.getRecordCount()).assertEqual(1);
    await systemPasteboard.clearData();
    systemPasteboard.getPasteData().then((data) => {
      const recordCount38 = data.getRecordCount();
      expect(recordCount38).assertEqual(0);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test39
   * @tc.desc      向剪切板内增加30条数据项，然后清除
   * @tc.type      Function
   * @tc.require   AR000H5I1D
   */
  it('pasteboard_promise_test39', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData390 = 'Hello World!';
    const pasteData = pasteboard.createPlainTextData(textData390);
    let textData39 = '';
    for (let i = 1; i < 30; i++) {
      textData39 = 'Hello World';
      textData39 = textData39 + i;
      pasteData.addTextRecord(textData39);
    }
    await systemPasteboard.setPasteData(pasteData);
    const res39 = await systemPasteboard.hasPasteData();
    expect(res39).assertEqual(true);
    const pasteData39 = await systemPasteboard.getPasteData();
    expect(pasteData39.getRecordCount()).assertEqual(30);
    await systemPasteboard.clearData();
    systemPasteboard.getPasteData().then((data) => {
      const recordCount39 = data.getRecordCount();
      expect(recordCount39).assertEqual(0);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test40
   * @tc.desc      向剪贴板数据各增加5条文本、uri、html数据，然后清除
   * @tc.type      Function
   * @tc.require   AR000H5I1D
   */
  it('pasteboard_promise_test40', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData400 = 'Hello World0';
    const pasteData = pasteboard.createPlainTextData(textData400);
    let textData40 = '';
    for (let i = 1; i < 5; i++) {
      textData40 = 'Hello World';
      textData40 = textData40 + i;
      pasteData.addTextRecord(textData40);
    }
    let htmlText40 = '';
    for (let i = 0; i < 5; i++) {
      htmlText40 = '<html><head></head><body>Hello World!</body></html>';
      htmlText40 = htmlText40 + i;
      pasteData.addHtmlRecord(htmlText40);
    }
    let uriText40 = '';
    for (let i = 0; i < 5; i++) {
      uriText40 = 'https://www.baidu.com/';
      uriText40 = uriText40 + i;
      pasteData.addUriRecord(uriText40);
    }
    await systemPasteboard.setPasteData(pasteData);
    const res40 = await systemPasteboard.hasPasteData();
    expect(res40).assertEqual(true);
    const data40 = await systemPasteboard.getPasteData();
    expect(data40.getRecordCount()).assertEqual(15);
    await systemPasteboard.clearData();
    systemPasteboard.getPasteData().then((data) => {
      const recordCount40 = data.getRecordCount();
      expect(recordCount40).assertEqual(0);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test41
   * @tc.desc      更新剪贴板数据，查询剪贴板存在剪贴板数据
   * @tc.type      Function
   * @tc.require   AR000HEECD
   */
  it('pasteboard_promise_test41', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData41 = 'Hello World!';
    const pasteData = pasteboard.createPlainTextData(textData41);
    await systemPasteboard.setPasteData(pasteData);
    const res41 = await systemPasteboard.hasPasteData();
    expect(res41).assertEqual(true);
    const pasteData41 = await systemPasteboard.getPasteData();
    expect(pasteData41.getRecordCount()).assertEqual(1);
    const textData411 = 'Hello World1';
    const pasteDataRecord = pasteboard.createPlainTextRecord(textData411);
    const replace41 = pasteData41.replaceRecordAt(0, pasteDataRecord);
    expect(replace41).assertEqual(true);
    await systemPasteboard.setPasteData(pasteData41);
    systemPasteboard.hasPasteData().then(async (data) => {
      expect(data).assertEqual(true);
      const newData41 = await systemPasteboard.getPasteData();
      expect(newData41.getPrimaryText()).assertEqual(textData411);
      const newPasteDataRecord = newData41.getRecordAt(0);
      expect(newPasteDataRecord.plainText).assertEqual(textData411);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test42
   * @tc.desc      删除所有的剪贴板数据，查询剪贴板不存在剪贴板数据
   * @tc.type      Function
   * @tc.require   AR000HEECD
   */
  it('pasteboard_promise_test42', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData42 = 'Hello World!';
    const data42 = pasteboard.createPlainTextData(textData42);
    await systemPasteboard.setPasteData(data42);
    const res42 = await systemPasteboard.hasPasteData();
    expect(res42).assertEqual(true);
    const pasteData42 = await systemPasteboard.getPasteData();
    const recordCount = pasteData42.getRecordCount();
    expect(recordCount).assertEqual(1);
    expect(pasteData42.removeRecordAt(0)).assertEqual(true);
    expect(pasteData42.getRecordCount()).assertEqual(0);
    const newData42 = await systemPasteboard.getPasteData();
    expect(newData42.getRecordCount()).assertEqual(1);
    done();
  });

  /**
   * @tc.name      pasteboard_promise_test43
   * @tc.desc      将文本数据强制转换为文本
   * @tc.type      Function
   * @tc.require   AR000HEECD
   */
  it('pasteboard_promise_test43', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData43 = 'Hello World!';
    const pasteData = pasteboard.createPlainTextData(textData43);
    await systemPasteboard.setPasteData(pasteData);
    const res43 = await systemPasteboard.hasPasteData();
    expect(res43).assertEqual(true);
    systemPasteboard.getPasteData().then(async (data) => {
      const pasteData143 = data;
      expect(pasteData143.getRecordCount()).assertEqual(1);
      const pasteDataRecord = pasteData143.getRecordAt(0);
      const text43 = await pasteDataRecord.convertToText();
      expect(text43).assertEqual(textData43);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test44
   * @tc.desc      将一条含有特殊字符、中英混杂的文本数据强制转换为文本
   * @tc.type      Function
   * @tc.require   AR000HEECD
   */
  it('pasteboard_promise_test44', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData44 = 'Hello 中国!@#$%^&*()_+{}?.';
    const pasteData = pasteboard.createPlainTextData(textData44);
    await systemPasteboard.setPasteData(pasteData);
    const res44 = await systemPasteboard.hasPasteData();
    expect(res44).assertEqual(true);
    const pasteData44 = await systemPasteboard.getPasteData();
    expect(pasteData44.getRecordCount()).assertEqual(1);
    const pasteDataRecord = pasteData44.getRecordAt(0);
    pasteDataRecord.convertToText((err, text) => {
      if (err) {
        console.info('f_test44 pasteDataRecord.convertToText error: ' + error);
      } else {
        expect(textData44).assertEqual(text);
        done();
      }
    });
  });

  /**
   * @tc.name      pasteboard_promise_test45
   * @tc.desc      将一条超长文本数据 (大小为301K)强制转换为文本
   * @tc.type      Function
   * @tc.require   AR000HEECD
   */
  it('pasteboard_promise_test45', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    let textData45 = '';
    for (let i = 0; i < 301; i++) {
      textData45 = textData45 + 'A';
    }
    const pasteData = pasteboard.createPlainTextData(textData45);
    await systemPasteboard.setPasteData(pasteData);
    const res45 = await systemPasteboard.hasPasteData();
    expect(res45).assertEqual(true);
    const pasteData45 = await systemPasteboard.getPasteData();
    expect(pasteData45.getRecordCount()).assertEqual(1);
    const pasteDataRecord = pasteData45.getRecordAt(0);
    pasteDataRecord.convertToText((err, text) => {
      if (err) {
        console.info('f_test45 pasteDataRecord.convertToText error: ' + error);
      } else {
        expect(textData45).assertEqual(text);
        done();
      }
    });
  });

  /**
   * @tc.name      pasteboard_promise_test46
   * @tc.desc      将uri数据强制转换为文本
   * @tc.type      Function
   * @tc.require   AR000HEECD
   */
  it('pasteboard_promise_test46', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const uriText46 = 'https://www.baidu.com/';
    const pasteData = pasteboard.createUriData(uriText46);
    await systemPasteboard.setPasteData(pasteData);
    const res46 = await systemPasteboard.hasPasteData();
    expect(res46).assertEqual(true);
    let pasteData46 = await systemPasteboard.getPasteData();
    expect(pasteData46.getRecordCount()).assertEqual(1);
    let pasteDataRecord = pasteData46.getRecordAt(0);
    pasteDataRecord
      .convertToText()
      .then((text) => {
        expect(uriText46).assertEqual(text);
        done();
      })
      .catch((error) => {
        console.info('f_test46 pasteDataRecord.convertToText error: ' + error);
      });
  });

  /**
   * @tc.name      pasteboard_promise_test47
   * @tc.desc      复制文本、uri格式
   * @tc.type      Function
   * @tc.require   AR000HEECD
   */
  it('pasteboard_promise_test47', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const textData470 = 'Hello World0';
    const pasteData = pasteboard.createPlainTextData(textData470);
    const uriText47 = pasteboard.createUriRecord('https://www.baidu.com/');
    pasteData.addRecord(uriText47);
    await systemPasteboard.setPasteData(pasteData);
    const res47 = await systemPasteboard.hasPasteData();
    expect(res47).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      const recordCount47 = data.getRecordCount();
      expect(recordCount47).assertEqual(2);
      const pasteDataRecord1 = data.getRecordAt(0);
      const pasteDataRecord2 = data.getRecordAt(1);
      expect(pasteDataRecord1.uri).assertEqual(uriText47.uri);
      expect(pasteDataRecord2.plainText).assertEqual(textData470);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test48
   * @tc.desc      关闭内容变化通知功能：向剪贴板数据增加、删除等html数据项
   * @tc.type      Function
   * @tc.require   AR000HEECD
   */
  it('pasteboard_promise_test48', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    systemPasteboard.off('update', contentChanges);
    const htmlText48 = '<html><head></head><body>Hello World!</body></html>';
    const pasteData = pasteboard.createHtmlData(htmlText48);
    await systemPasteboard.setPasteData(pasteData);
    const res48 = await systemPasteboard.hasPasteData();
    expect(res48).assertEqual(true);
    systemPasteboard.getPasteData().then((data) => {
      expect(data.getRecordCount()).assertEqual(1);
      expect(data.removeRecordAt(0)).assertEqual(true);
      expect(data.getRecordCount()).assertEqual(0);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test49
   * @tc.desc      创建pixelMap
   * @tc.type      Function
   * @tc.require   AR000HEECD
   */
  it('pasteboard_promise_test49', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const buffer49 = new ArrayBuffer(128);
    const opt49 = {
      size: { height: 5, width: 5 },
      pixelFormat: 3,
      editable: true,
      alphaType: 1,
      scaleMode: 1,
    };
    const pixelMap = await image.createPixelMap(buffer49, opt49);
    expect(pixelMap.getPixelBytesNumber()).assertEqual(100);
    const pasteData49 = pasteboard.createData(pasteboard.MIMETYPE_PIXELMAP, pixelMap);
    await systemPasteboard.setPasteData(pasteData49);
    const res49 = await systemPasteboard.hasPasteData();
    expect(res49).assertEqual(true);
    systemPasteboard.getPasteData().then(async (newPasteData) => {
      const recordCount49 = newPasteData.getRecordCount();
      expect(recordCount49).assertEqual(1);
      const newPixelMap49 = newPasteData.getPrimaryPixelMap();
      const PixelMapBytesNumber = newPixelMap49.getPixelBytesNumber();
      expect(PixelMapBytesNumber).assertEqual(100);
      const imageInfo = await newPixelMap49.getImageInfo();
      expect(imageInfo.size.height === 5 && imageInfo.size.width === 5).assertEqual(true);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test50
   * @tc.desc      创建kv Record
   * @tc.type      Function
   * @tc.require   AR000HEECD
   */
  it('pasteboard_promise_test50', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const dataXml50 = new ArrayBuffer(512);
    let int32view50 = new Int32Array(dataXml50);
    for (let i = 0; i < int32view50.length; i++) {
      int32view50[i] = 65535 + i;
    }
    const pasteDataRecord = pasteboard.createRecord('app/xml', dataXml50);
    const dataJpg50 = new ArrayBuffer(256);
    pasteDataRecord.data['image/ipg'] = dataJpg50;
    const pasteData50 = pasteboard.createHtmlData('application/xml');
    const replace = pasteData50.replaceRecordAt(0, pasteDataRecord);
    expect(replace).assertEqual(true);
    await systemPasteboard.setPasteData(pasteData50);
    const res50 = await systemPasteboard.hasPasteData();
    expect(res50).assertEqual(true);
    systemPasteboard.getPasteData().then((newPasteData) => {
      const recordCount50 = newPasteData.getRecordCount();
      expect(recordCount50).assertEqual(1);
      let newPasteDataRecord = newPasteData.getRecordAt(0);
      let newAppXml50 = newPasteDataRecord.data['app/xml'];
      let newImageIpg50 = newPasteDataRecord.data['image/ipg'];
      expect(newAppXml50.byteLength === 512 && newImageIpg50.byteLength === 256).assertEqual(true);
      let newAppXmlView50 = new Int32Array(newAppXml50);
      let newImageIpgView50 = new Int32Array(newImageIpg50);
      for (let i = 0; i < newAppXmlView50.length; i++) {
        console.info('newAppXml[' + i + '] = ' + newAppXmlView50[i]);
      }
      for (let i = 0; i < newImageIpgView50.length; i++) {
        console.info('newImageIpg[' + i + '] = ' + newImageIpg50[i]);
      }
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test51
   * @tc.desc      测试addPixelMapRecord
   * @tc.type      Function
   * @tc.require   AR000HEECD
   */
  it('pasteboard_promise_test51', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const buffer51 = new ArrayBuffer(128);
    const opt51 = {
      size: { height: 5, width: 5 },
      pixelFormat: 3,
      editable: true,
      alphaType: 1,
      scaleMode: 1,
    };
    const pasteData51 = pasteboard.createHtmlData('application/xml');
    const pixelMap = await image.createPixelMap(buffer51, opt51);
    expect(pixelMap.getPixelBytesNumber() === 100).assertEqual(true);
    pasteData51.addRecord(pasteboard.MIMETYPE_PIXELMAP, pixelMap);
    await systemPasteboard.setPasteData(pasteData51);
    const res51 = await systemPasteboard.hasPasteData();
    expect(res51).assertEqual(true);
    systemPasteboard.getPasteData().then(async (newPasteData) => {
      const recordCount51 = newPasteData.getRecordCount();
      expect(recordCount51).assertEqual(2);
      const newPixelMap51 = newPasteData.getPrimaryPixelMap();
      const PixelMapBytesNumber51 = newPixelMap51.getPixelBytesNumber();
      expect(PixelMapBytesNumber51).assertEqual(100);
      const newHtmlData51 = newPasteData.getRecordAt(1);
      expect(newHtmlData51.htmlText).assertEqual('application/xml');
      const imageInfo51 = await newPixelMap51.getImageInfo();
      expect(imageInfo51.size.height === 5 && imageInfo51.size.width === 5).assertEqual(true);
      done();
    });
  });

  /**
   * @tc.name      pasteboard_promise_test52
   * @tc.desc      支持512个record
   * @tc.type      Function
   * @tc.require   AR000HEECB
   */
  it('pasteboard_promise_test52', 0, async function (done) {
    const systemPasteboard = pasteboard.getSystemPasteboard();
    await systemPasteboard.clearData();
    const dataHtml52 = new ArrayBuffer(256);
    const htmlText52 = '<html><head></head><body>Hello!</body></html>';
    const uriText52 = 'https://www.baidu.com/';
    const wantText52 = {
      bundleName: 'com.example.myapplication3',
      abilityName: 'com.example.myapplication3.MainAbility',
    };
    const plainText52 = '';
    const pasteData52 = pasteboard.createData('x'.repeat(1024), dataHtml52);
    const record52 = pasteData52.getRecordAt(0);
    record52.htmlText = htmlText52;
    record52.plainText = plainText52;
    record52.uri = uriText52;
    record52.want = wantText52;
    const buffer52 = new ArrayBuffer(128);
    const opt52 = {
      size: { height: 5, width: 5 },
      pixelFormat: 3,
      editable: true,
      alphaType: 1,
      scaleMode: 1,
    };
    const pixelMap = await image.createPixelMap(buffer52, opt52);
    record52.pixelMap = pixelMap;
    pasteData52.replaceRecordAt(0, record52);
    for (let i = 0; i < 511; i++) {
      pasteData52.addRecord(record52);
    }
    await systemPasteboard.setPasteData(pasteData52);
    const res52 = await systemPasteboard.hasPasteData();
    expect(res52).assertTrue();
    systemPasteboard.getPasteData().then((data) => {
      expect(data.getRecordCount()).assertEqual(512);
      expect(data.getRecordAt(0).mimeType).assertEqual('x'.repeat(1024));
      expect(data.getPrimaryWant().bundleName).assertEqual(wantText52.bundleName);
      expect(data.getRecordAt(253).htmlText).assertEqual(htmlText52);
      expect(data.getRecordAt(511).plainText).assertEqual(plainText52);
      done();
    });
  });

  /**
   *  The callback function is used for pasteboard content changes
   */
  function contentChanges() {
    console.info('#EVENT: The content is changed in the pasteboard');
  }
});