diff --git a/commonlibrary/ets_utils/BUILD.gn b/commonlibrary/ets_utils/BUILD.gn index 14b969ade684d1c15f56fb8c8dbd0564e2e9abaf..4311c8c74af313cbf85c1e546722eb29f765531f 100644 --- a/commonlibrary/ets_utils/BUILD.gn +++ b/commonlibrary/ets_utils/BUILD.gn @@ -17,6 +17,7 @@ group("ets_utils") { if (is_standard_system) { deps = [ "atomics_lib_standard:atomics_js_hap", + "buffer_lib_standard:buffer_js_test", "containerLine_lib_standard:containerLine_js_test", "containerRelation_lib_standard:containerRelation_js_test", "convertxml_lib_standard:convertxml_js_test", diff --git a/commonlibrary/ets_utils/buffer_lib_standard/BUILD.gn b/commonlibrary/ets_utils/buffer_lib_standard/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..9a5e1d5102c2153db1314fcea3e79a98e47596c1 --- /dev/null +++ b/commonlibrary/ets_utils/buffer_lib_standard/BUILD.gn @@ -0,0 +1,39 @@ +# Copyright (C) 2022 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. + +import("//test/xts/tools/build/suite.gni") +ohos_js_hap_suite("buffer_js_test") { + hap_profile = "./src/main/config.json" + js2abc = true + deps = [ + ":buffer_js_assets", + ":buffer_resources", + ] + + # shared_libraries = [ + # "//third_party/giflib:libgif", + # "//third_party/libpng:libpng", + # ] + certificate_profile = "./signature/openharmony_sx.p7b" + hap_name = "ActsBufferJsTest" + + # part_name = "prebuilt_hap" + # subsystem_name = "xts" +} +ohos_js_assets("buffer_js_assets") { + source_dir = "./src/main/js/default" +} +ohos_resources("buffer_resources") { + sources = [ "./src/main/resources" ] + hap_profile = "./src/main/config.json" +} diff --git a/commonlibrary/ets_utils/buffer_lib_standard/Test.json b/commonlibrary/ets_utils/buffer_lib_standard/Test.json new file mode 100644 index 0000000000000000000000000000000000000000..5cd5efaf286cbef30f9ef34bcb718eaeddb833d8 --- /dev/null +++ b/commonlibrary/ets_utils/buffer_lib_standard/Test.json @@ -0,0 +1,18 @@ +{ + "description": "Configuration for startup buffer js api Tests", + "driver": { + "type": "JSUnitTest", + "test-timeout": "800000", + "package": "com.example.buffer", + "shell-timeout": "90000" + }, + "kits": [ + { + "test-file-name": [ + "ActsBufferJsTest.hap" + ], + "type": "AppInstallKit", + "cleanup-apps": true + } + ] +} \ No newline at end of file diff --git a/commonlibrary/ets_utils/buffer_lib_standard/signature/openharmony_sx.p7b b/commonlibrary/ets_utils/buffer_lib_standard/signature/openharmony_sx.p7b new file mode 100644 index 0000000000000000000000000000000000000000..9be1e98fa4c0c28ca997ed660112fa16b194f0f5 Binary files /dev/null and b/commonlibrary/ets_utils/buffer_lib_standard/signature/openharmony_sx.p7b differ diff --git a/commonlibrary/ets_utils/buffer_lib_standard/src/main/config.json b/commonlibrary/ets_utils/buffer_lib_standard/src/main/config.json new file mode 100644 index 0000000000000000000000000000000000000000..6e207ebf96eed8f43c1a0e5f3ebbade5d9c78a55 --- /dev/null +++ b/commonlibrary/ets_utils/buffer_lib_standard/src/main/config.json @@ -0,0 +1,62 @@ +{ + "app": { + "bundleName": "com.example.buffer", + "vendor": "example", + "version": { + "code": 1000000, + "name": "1.0.0" + }, + "apiVersion": { + "compatible": 4, + "target": 5 + } + }, + "deviceConfig": {}, + "module": { + "package": "com.example.buffer", + "name": ".MyApplication", + "mainAbility": "com.example.buffer.MainAbility", + "deviceType": [ + "phone" + ], + "distro": { + "deliveryWithInstall": true, + "moduleName": "entry", + "moduleType": "entry", + "installationFree": false + }, + "abilities": [ + { + "skills": [ + { + "entities": [ + "entity.system.home" + ], + "actions": [ + "action.system.home" + ] + } + ], + "visible": true, + "name": "com.example.buffer.MainAbility", + "icon": "$media:icon", + "description": "$string:mainability_description", + "label": "$string:entry_MainAbility", + "type": "page", + "launchType": "standard" + } + ], + "js": [ + { + "pages": [ + "pages/index/index" + ], + "name": "default", + "window": { + "designWidth": 720, + "autoDesignWidth": true + } + } + ] + } +} \ No newline at end of file diff --git a/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/app.js b/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/app.js new file mode 100644 index 0000000000000000000000000000000000000000..ff2c11965e08dd2df603562158980963c00e7a25 --- /dev/null +++ b/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/app.js @@ -0,0 +1,22 @@ +/* + * Copyright (C) 2022 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. + */ +export default { + onCreate() { + console.info('AceApplication onCreate'); + }, + onDestroy() { + console.info('AceApplication onDestroy'); + } +}; diff --git a/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/i18n/en-US.json b/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/i18n/en-US.json new file mode 100644 index 0000000000000000000000000000000000000000..e63c70d978a3a53be988388c87182f81785e170c --- /dev/null +++ b/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/i18n/en-US.json @@ -0,0 +1,6 @@ +{ + "strings": { + "hello": "Hello", + "world": "World" + } +} \ No newline at end of file diff --git a/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/i18n/zh-CN.json b/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/i18n/zh-CN.json new file mode 100644 index 0000000000000000000000000000000000000000..de6ee5748322f44942c1b003319d8e66c837675f --- /dev/null +++ b/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/i18n/zh-CN.json @@ -0,0 +1,6 @@ +{ + "strings": { + "hello": "您好", + "world": "世界" + } +} \ No newline at end of file diff --git a/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/pages/index/index.css b/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/pages/index/index.css new file mode 100644 index 0000000000000000000000000000000000000000..2b1965821483f4f8c8b97c86ef07fe87ea767d01 --- /dev/null +++ b/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/pages/index/index.css @@ -0,0 +1,44 @@ +.container { + flex-direction: column; + justify-content: center; + align-items: center; +} + +.title { + font-size: 40px; + color: #000000; + opacity: 0.9; +} + +@media screen and (device-type: tablet) and (orientation: landscape) { + .title { + font-size: 100px; + } +} + +@media screen and (device-type: wearable) { + .title { + font-size: 28px; + color: #FFFFFF; + } +} + +@media screen and (device-type: tv) { + .container { + background-image: url("../../common/images/Wallpaper.png"); + background-size: cover; + background-repeat: no-repeat; + background-position: center; + } + + .title { + font-size: 100px; + color: #FFFFFF; + } +} + +@media screen and (device-type: phone) and (orientation: landscape) { + .title { + font-size: 60px; + } +} diff --git a/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/pages/index/index.hml b/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/pages/index/index.hml new file mode 100644 index 0000000000000000000000000000000000000000..20a4e40d9a4ee698bf8e485840457dd43233a376 --- /dev/null +++ b/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/pages/index/index.hml @@ -0,0 +1,5 @@ +
+ + {{ $t('strings.hello') }} {{title}} + +
\ No newline at end of file diff --git a/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/pages/index/index.js b/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/pages/index/index.js new file mode 100644 index 0000000000000000000000000000000000000000..3d5d7b311b2f22194d35b58420c4c2e376df4ad4 --- /dev/null +++ b/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/pages/index/index.js @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2022 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. + */ + +import file from '@system.file' +import app from '@system.app' +import device from '@system.device' +import router from '@system.router' +import {Core} from 'deccjsunit/index' + +export default { + data: { + title: "" + }, + onInit() { + this.title = this.$t('strings.world'); + }, + onShow() { + console.info('onShow finish') + const core = Core.getInstance() + core.init() + require('../../../test/Main.test') + core.execute() + }, + onReady() { + }, +} \ No newline at end of file diff --git a/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/test/Buffer.test.js b/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/test/Buffer.test.js new file mode 100644 index 0000000000000000000000000000000000000000..4b220b877240708aad6995cf8ea45e995b957577 --- /dev/null +++ b/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/test/Buffer.test.js @@ -0,0 +1,2220 @@ +/* + * Copyright (C) 2022 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. + */ +import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'; +import buffer from "@ohos.buffer"; + +describe("BufferTest", function () { + + /** + * @tc.name: testAlloc0010 + * @tc.desc: Allocates a new Buffer for a fixed size bytes. If fill is undefined, the Buffer will be zero-filled. + * @tc.author: liuganlin + */ + it("testAlloc0010", 0, function () { + let buf = buffer.alloc(10); + expect(buf.length).assertEqual(10); + let offset = buf.writeInt32BE(0x12345678, 0); + expect(offset).assertEqual(4); + let str = buf.readInt32BE(); + expect(str).assertEqual(305419896); + }); + + /** + * @tc.name: testAllocUninitializedFromPool0020 + * @tc.desc: Allocates a new un-pooled Buffer for a fixed size bytes. The Buffer will not be initially filled. + * For example: buffer.allocUninitializedFromPool(10); + * @tc.author: liuganlin + */ + it("testAllocUninitializedFromPool0020", 0, function () { + let buf = buffer.allocUninitializedFromPool(10); + expect(buf.length).assertEqual(10); + }); + + /** + * @tc.name: testByteLength0030 + * @tc.desc: Returns the byte length of a string when encoded using `encoding`. + * This is not the same as [`String.prototype.length`], which does not account + * for the encoding that is used to convert the string into bytes. + * For example: buffer.byteLength("abcd"); + * @tc.author: liuganlin + */ + it("testByteLength0030", 0, function () { + let byteLen = buffer.byteLength("abcd"); + expect(byteLen).assertEqual(4); + }); + + /** + * @tc.name: testIsBuffer0040 + * @tc.desc: Returns true if obj is a Buffer, false otherwise + * For example: buffer.isBuffer(buf); + * @tc.author: liuganlin + */ + it("testIsBuffer0040", 0, function () { + let buf = buffer.alloc(1); + let flag = buffer.isBuffer(buf); + expect(flag).assertEqual(true); + }); + + /** + * @tc.name: testIsEncoding0050 + * @tc.desc: Returns true if encoding is the name of a supported character encoding, or false otherwise. + * For example: buffer.isEncoding("utf8"); + * @tc.author: liuganlin + */ + it("testIsEncoding0050", 0, function () { + let flag = buffer.isEncoding("utf8"); + expect(flag).assertEqual(true); + }); + + /** + * @tc.name: testStaticCompare0060 + * @tc.desc: Compares buf1 to buf2. + * For example: let buf1 = buffer.from("1236"); + * let buf2 = buffer.from("1235"); + * let res = buffer.compare(buf1, buf2); + * @tc.author: liuganlin + */ + it("testStaticCompare0060", 0, function () { + let buf1 = buffer.from("1236"); + let buf2 = buffer.from("1235"); + let res = buffer.compare(buf1, buf2); + expect(res).assertEqual(1); + }); + + /** + * @tc.name: testConcat0070 + * @tc.desc: Returns a new `Buffer` which is the result of concatenating + * all the `Buffer`instances in the `list` together. + * For example: let buf1 = buffer.from("1236"); + * let buf2 = buffer.from("1235"); + * let buf = buffer.concat([buf1, buf2]); + * @tc.author: liuganlin + */ + it("testConcat0070", 0, function () { + let buf1 = buffer.from("1236"); + let buf2 = buffer.from("1235"); + let buf = buffer.concat([buf1, buf2]); + let str = buf.toString(); + expect(str).assertEqual("12361235"); + }); + + /** + * @tc.name: testTranscode0080 + * @tc.desc: Re-encodes the given Buffer or Uint8Array instance from one character encoding to another. + * For example: buffer.transcode(buf1, "ascii", "ucs2"); + * @tc.author: liuganlin + */ + it("testTranscode0080", 0, function () { + let buf1 = buffer.from("1236"); + let buf = buffer.transcode(buf1, "ascii", "ucs2"); + let str = buf.toString("ucs2") + expect(str).assertEqual("1236"); + }); + + /** + * @tc.name: testFill0090 + * @tc.desc: Fills buf with the specified value. If the offset and end are not given, the entire buf will be filled. + * For example: buffer.alloc(3).fill("abc"); + * @tc.author: liuganlin + */ + it("testFill0090", 0, function () { + let buf = buffer.alloc(3).fill("abc"); + let str = buf.toString(); + expect(str).assertEqual("abc"); + }); + + /** + * @tc.name: testFill0091 + * @tc.desc: Fills buf with the specified value. If the offset and end are not given, the entire buf will be filled. + * For example: buffer.alloc(10).fill('F1刘FG', 0, 10, 'hex'); + * @tc.author: liuganlin + */ + it("testFill0091", 0, function () { + const buf1 = buffer.alloc(10).fill('F1刘FG', 0, 10, 'hex'); + let str = buf1.toString('hex'); + expect(str).assertEqual("f1f1f1f1f1f1f1f1f1f1"); + + let buf2 = buffer.alloc(10).fill('F1刘FG', 0, 10, 'ascii'); + str = buf2.toString("hex"); + expect(str).assertEqual("46311846474631184647"); + + let buf3 = buffer.alloc(10).fill('F1FG', 0, 10, 'base64'); + str = buf3.toString("hex"); + expect(str).assertEqual("17514617514617514617"); + + let buf4 = buffer.alloc(10).fill('F1刘FG', 0, 10, 'binary'); + str = buf4.toString("hex"); + expect(str).assertEqual("46311846474631184647"); + + let buf5 = buffer.alloc(10).fill('F1刘FG', 0, 10, 'latin1'); + str = buf5.toString("hex"); + expect(str).assertEqual("46311846474631184647"); + + let buf6 = buffer.alloc(10).fill('F1刘FG', 0, 10, 'ucs2'); + str = buf6.toString("hex"); + expect(str).assertEqual("46003100185246004700"); + + let buf7 = buffer.alloc(10).fill('F1刘FG', 0, 10, 'utf8'); + str = buf7.toString("hex"); + expect(str).assertEqual("4631e5889846474631e5"); + }); + + /** + * @tc.name: testWrite0100 + * @tc.desc: Writes string to buf at offset according to the character encoding in encoding. + * For example: buf.write("abcde", "latin1"); + * @tc.author: liuganlin + */ + it("testWrite0100", 0, function () { + let buf = buffer.alloc(5); + let offset = buf.write("abcde", "latin1"); + expect(offset).assertEqual(5); + let str = buf.toString(); + expect(str).assertEqual("abcde"); + }); + + /** + * @tc.name: testCompare0110 + * @tc.desc: Compares buf with target and returns a number indicating whether buf comes before, after, + * or is the same as target in sort order. Comparison is based on the actual sequence of + * bytes in each Buffer. + * For example: buf1.compare(buf2); + * @tc.author: liuganlin + */ + it("testCompare0110", 0, function () { + let buf1 = buffer.from("1236"); + let buf2 = buffer.from("1235"); + let res = buf1.compare(buf2); + expect(res).assertEqual(1); + }); + + /** + * @tc.name: testEquals0120 + * @tc.desc: Returns true if both buf and otherBuffer have exactly the same bytes, false otherwise. + * For example: buf1.equals(buf2); + * @tc.author: liuganlin + */ + it("testEquals0120", 0, function () { + let buf1 = buffer.from("1236"); + let buf2 = buffer.from("1235"); + let res = buf1.equals(buf2); + expect(res).assertEqual(false); + }); + + /** + * @tc.name: testSubarray0130 + * @tc.desc: Returns a new Buffer that references the same memory as the original, + * but offset and cropped by the start and end indices. + * For example: buf1.subarray(0, 3); + * @tc.author: liuganlin + */ + it("testSubarray0130", 0, function () { + let buf1 = buffer.from("1236"); + let buf = buf1.subarray(0, 3); + let str = buf.toString(); + expect(str).assertEqual("123"); + }); + + /** + * @tc.name: testCopy0140 + * @tc.desc: Copies data from a region of buf to a region in target, + * even if the target memory region overlaps with buf. + * If sourceEnd is greater than the length of the target, the length of the target shall prevail, + * and the extra part will not be overwritten. + * For example: buf1.copy(buf2); + * @tc.author: liuganlin + */ + it("testCopy0140", 0, function () { + let buf1 = buffer.from("1236"); + let buf2 = buffer.from("1235"); + let num = buf1.copy(buf2); + expect(num).assertEqual(4); + let str = buf2.toString(); + expect(str).assertEqual("1236"); + }); + + /** + * @tc.name: testToString0150 + * @tc.desc: Decodes buf to a string according to the specified character encoding in encoding. + * For example: buf1.toString(); + * @tc.author: liuganlin + */ + it("testToString0150", 0, function () { + let buf1 = buffer.from("1236"); + let str = buf1.toString(); + expect(str).assertEqual("1236"); + }); + + /** + * @tc.name: testToString0151 + * @tc.desc: Decodes buf to a string according to the specified character encoding in encoding. + * For example: buf1.toString(); + * @tc.author: liuganlin + */ + it("testToString0151", 0, function () { + let buf1 = buffer.from("张三"); + let str = buf1.toString(); + expect(str).assertEqual("张三"); + }); + + /** + * @tc.name: testToString0152 + * @tc.desc: Decodes buf to a string according to the specified character encoding in encoding. + * For example: buf1.toString("binary"); + * @tc.author: liuganlin + */ + it("testToString0152", 0, function () { + let buf1 = buffer.from("abc"); + let str = buf1.toString("binary"); + expect(str).assertEqual("abc"); + }); + + /** + * @tc.name: testToString0153 + * @tc.desc: Decodes buf to a string according to the specified character encoding in encoding. + * For example: buf1.toString("binary"); + * @tc.author: liuganlin + */ + it("testToString0153", 0, function () { + let buf1 = buffer.from("abc"); + let str = buf1.toString("ascii"); + expect(str).assertEqual("abc"); + }); + + /** + * @tc.name: testToString0154 + * @tc.desc: Decodes buf to a string according to the specified character encoding in encoding. + * For example: buf1.toString("base64"); + * @tc.author: liuganlin + */ + it("testToString0154", 0, function () { + let buf1 = buffer.from("abc"); + let str = buf1.toString("base64"); + expect(str).assertEqual("YWJj"); + }); + + /** + * @tc.name: testToString0155 + * @tc.desc: Decodes buf to a string according to the specified character encoding in encoding. + * For example: buf1.toString("hex"); + * @tc.author: liuganlin + */ + it("testToString0155", 0, function () { + let buf1 = buffer.from("abc"); + let str = buf1.toString("hex"); + expect(str).assertEqual("616263"); + }); + + /** + * @tc.name: testToString0156 + * @tc.desc: Decodes buf to a string according to the specified character encoding in encoding. + * For example: buf1.toString("latin1"); + * @tc.author: liuganlin + */ + it("testToString0156", 0, function () { + let buf1 = buffer.from("abc"); + let str = buf1.toString("latin1"); + expect(str).assertEqual("abc"); + }); + + /** + * @tc.name: testToString0157 + * @tc.desc: Decodes buf to a string according to the specified character encoding in encoding. + * For example: buf1.toString("ucs2"); + * @tc.author: liuganlin + */ + it("testToString0157", 0, function () { + let buf1 = buffer.from("abc"); + let str = buf1.toString("ucs2"); + expect(str).assertEqual("扡"); + }); + + /** + * @tc.name: testToString0158 + * @tc.desc: Decodes buf to a string according to the specified character encoding in encoding. + * For example: buf1.toString("utf16le"); + * @tc.author: liuganlin + */ + it("testToString0158", 0, function () { + let buf1 = buffer.from("abc"); + let str = buf1.toString("utf16le"); + expect(str).assertEqual("扡"); + }); + + /** + * @tc.name: testToJSON0160 + * @tc.desc: Returns a JSON representation of buf. + * For example: buf1.toJSON(); + * @tc.author: liuganlin + */ + it("testToJSON0160", 0, function () { + let buf1 = buffer.from("1236"); + let obj = buf1.toJSON(); + expect(obj.data.join("")).assertEqual("49505154"); + }); + + /** + * @tc.name: testIndexOf0170 + * @tc.desc: The index of the first occurrence of value in buf. + * For example: let buf1 = buffer.from("13236"); buf1.indexOf("3"); + * @tc.author: liuganlin + */ + it("testIndexOf0170", 0, function () { + let buf1 = buffer.from("13236"); + let index = buf1.indexOf("3"); + expect(index).assertEqual(1); + }); + + /** + * @tc.name: testLastIndexOf0180 + * @tc.desc: The index of the last occurrence of value in buf. + * For example: let buf1 = buffer.from("13236"); buf1.lastIndexOf("3"); + * @tc.author: liuganlin + */ + it("testLastIndexOf0180", 0, function () { + let buf1 = buffer.from("13236"); + let index = buf1.lastIndexOf("3"); + expect(index).assertEqual(3); + }); + + /** + * @tc.name: testIncludes0190 + * @tc.desc: Returns true if value was found in buf, false otherwise. + * For example: let buf1 = buffer.from("13236"); buf1.includes("3"); + * @tc.author: liuganlin + */ + it("testIncludes0190", 0, function () { + let buf1 = buffer.from("13236"); + let flag = buf1.includes("3"); + expect(flag).assertEqual(true); + }); + + /** + * @tc.name: testSwap160200 + * @tc.desc: Interprets buf as an array of unsigned 16-bit integers and swaps the byte order in-place. + * For example: buf1.swap16(); + * @tc.author: liuganlin + */ + it("testSwap160200", 0, function () { + let buf1 = buffer.from("1323"); + buf1.swap16(); + let str = buf1.toString("hex"); + expect(str).assertEqual("33313332"); + }); + + /** + * @tc.name: testSwap320210 + * @tc.desc: Interprets buf as an array of unsigned 32-bit integers and swaps the byte order in-place. + * For example: buf1.swap32(); + * @tc.author: liuganlin + */ + it("testSwap320210", 0, function () { + let buf1 = buffer.from("1234"); + buf1.swap32(); + let str = buf1.toString(); + expect(str).assertEqual("4321"); + }); + + /** + * @tc.name: testSwap640220 + * @tc.desc: Interprets buf as an array of unsigned 64-bit integers and swaps the byte order in-place. + * For example: buf1.swap64(); + * @tc.author: liuganlin + */ + it("testSwap640220", 0, function () { + let buf1 = buffer.from("12345678"); + buf1.swap64(); + let str = buf1.toString(); + expect(str).assertEqual("87654321"); + }); + + /** + * @tc.name: testKeys0230 + * @tc.desc: Creates and returns an iterator of buf keys (indices). + * For example: buf1.keys(); + * @tc.author: liuganlin + */ + it("testKeys0230", 0, function () { + let buf1 = buffer.from("1234"); + let keys = buf1.keys(); + let index = 0; + for (const key of keys) { + expect(key).assertEqual(index); + index++; + } + }); + + /** + * @tc.name: testValues0240 + * @tc.desc: Creates and returns an iterator for buf values (bytes). + * For example: buf1.values(); + * @tc.author: liuganlin + */ + it("testValues0240", 0, function () { + let buf1 = buffer.from("1234"); + let keys = buf1.values(); + let va = 49; + for (const value of keys) { + expect(value).assertEqual(va); + va++; + } + }); + + /** + * @tc.name: testEntries0250 + * @tc.desc: Creates and returns an iterator of [index, byte] pairs from the contents of buf. + * For example: buf1.entries(); + * @tc.author: liuganlin + */ + it("testEntries0250", 0, function () { + let buf1 = buffer.from("1234"); + let entries = buf1.entries(); + let va = 49, index = 0; + for (const [key, value] of entries) { + expect(key).assertEqual(index); + expect(value).assertEqual(va); + va++; + index++; + } + }); + + /** + * @tc.name: testfrom0260 + * @tc.desc: Copies the passed buffer data onto a new Buffer instance. + * For example: buffer.from(uint8Array); + * @tc.author: liuganlin + */ + it("testfrom0260", 0, function () { + let uarr = new Uint8Array(3); + uarr[0] = 0x12; + uarr[1] = 0x34; + uarr[2] = 0x56; + let buf = buffer.from(uarr); + let str = buf.toString("hex"); + expect(str).assertEqual("123456"); + }); + + /** + * @tc.name: testfrom0261 + * @tc.desc: Allocates a new Buffer using an array of bytes in the range 0 – 255. + * Array entries outside that range will be truncated to fit into it. + * For example: buffer.from(array); + * @tc.author: liuganlin + */ + it("testfrom0261", 0, function () { + const buf = buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]); + let str = buf.toString("hex"); + expect(str).assertEqual("627566666572"); + }); + + /** + * @tc.name: testfrom0262 + * @tc.desc: This creates a view of the ArrayBuffer without copying the underlying memory. + * For example: buffer.from(arrayBuffer); + * @tc.author: liuganlin + */ + it("testfrom0262", 0, function () { + const arr = new Uint8Array(2); + arr[0] = 97; + arr[1] = 98; + const buf = buffer.from(arr.buffer); + arr[0] = 99 + buf[1] = 100 + let str = buf.toString("hex"); + expect(str).assertEqual("6364"); + expect(arr[1]).assertEqual(100); + }); + + /** + * @tc.name: testfrom0263 + * @tc.desc: This creates a view of the ArrayBuffer without copying the underlying memory. + * For example: buffer.from(arrayBuffer, byteOffset); + * @tc.author: liuganlin + */ + it("testfrom0263", 0, function () { + const arr = new Uint8Array(2); + arr[0] = 97; + arr[1] = 98; + const buf = buffer.from(arr.buffer, 1); + arr[0] = 99 + buf[1] = 100 + let str = buf.toString("hex"); + expect(str).assertEqual("62"); + expect(arr[1]).assertEqual(98); + }); + + /** + * @tc.name: testfrom0264 + * @tc.desc: Copies the passed buffer data onto a new Buffer instance. + * For example: buffer2.from(buffer1); + * @tc.author: liuganlin + */ + it("testfrom0264", 0, function () { + const buf1 = buffer.from('buffer'); + const buf2 = buffer.from(buf1); + buf1[0] = 0x61; + let str = buf1.toString(); + expect(str).assertEqual("auffer"); + str = buf2.toString(); + expect(str).assertEqual("buffer"); + }); + + /** + * @tc.name: testfrom0265 + * @tc.desc: Creates a new Buffer containing string. The encoding parameter identifies the character encoding + * to be used when converting string into bytes. + * For example: buffer.from(string); + * @tc.author: liuganlin + */ + it("testfrom0265", 0, function () { + const buf1 = buffer.from('this is a test'); + let str = buf1.toString(); + expect(str).assertEqual("this is a test"); + }); + + /** + * @tc.name: testfrom0266 + * @tc.desc: Creates a new Buffer containing string. The encoding parameter identifies the character encoding + * to be used when converting string into bytes. + * For example: buffer.from(string, encoding); + * @tc.author: liuganlin + */ + it("testfrom0266", 0, function () { + const buf1 = buffer.from('F1刘FG', 'hex'); + let str = buf1.toString('hex'); + expect(str).assertEqual("f1"); + + let buf2 = buffer.from("F1FG刘", "ascii") + str = buf2.toString("ascii"); + expect(str).assertEqual("F1FGe"); + + let buf3 = buffer.from("F1FG刘", "base64") + str = buf3.toString("base64"); + expect(str).assertEqual("F1FG"); + + let buf4 = buffer.from("F1FG刘", "binary") + str = buf4.toString("binary"); + expect(str).assertEqual("F1FGå"); + + let buf5 = buffer.from("F1FG刘", "latin1") + str = buf5.toString("latin1"); + expect(str).assertEqual("F1FGe"); + + let buf6 = buffer.from("F1FG刘", "ucs2") + str = buf6.toString("ucs2"); + expect(str).assertEqual("F1FG刘"); + + let buf7 = buffer.from("F1FG刘", "utf-8") + str = buf7.toString("utf-8"); + expect(str).assertEqual("F1FG刘"); + }); + + /** + * @tc.name: testfrom0267 + * @tc.desc: For the object whose value returned by valueof() function is strictly equal to object + * or supports symbol To primitive object, a new buffer instance is created. + * For example: buffer.from(object); + * @tc.author: liuganlin + */ + it("testfrom0267", 0, function () { + const buf = buffer.from(new String('this is a test')); + let str = buf.toString(); + expect(str).assertEqual("this is a test"); + }); + + /** + * @tc.name: testfrom0268 + * @tc.desc: For the object whose value returned by valueof() function is strictly equal to object + * or supports symbol To primitive object, a new buffer instance is created. + * For example: buffer.from(object); + * @tc.author: liuganlin + */ + it("testfrom0268", 0, function () { + console.log("fromObject 027_6_1"); + class Foo { + [Symbol.toPrimitive]() { + return 'this is a test'; + } + } + const buf = buffer.from(new Foo(), 'utf8'); + let str = buf.toString(); + expect(str).assertEqual("this is a test"); + }); + + /** + * @tc.name: testBlobConstructor0270 + * @tc.desc: Creates a new Blob object containing a concatenation of the given sources. + * For example: let blob2 = new buffer.Blob(["a", "b", "c"], { type: "new type", endings: "transparent" }); + * @tc.author: liuganlin + */ + it("testBlobConstructor0270", 0, async function () { + let blob2 = new buffer.Blob(["a", "b", "c"], { type: "new type", endings: "transparent" }); + let promise = blob2.text(); + promise.then((value) => { + expect(value).assertEqual("abc"); + }); + }); + + /** + * @tc.name: testBlobConstructor0271 + * @tc.desc: Creates a new Blob object containing a concatenation of the given sources. + * For example: let blob2 = new buffer.Blob([arrBuf], { type: "new type", endings: "transparent" }); + * @tc.author: liuganlin + */ + it("testBlobConstructor0271", 0, async function () { + let arrBuf = new ArrayBuffer(3); + let uint8arr = new Uint8Array(arrBuf); + uint8arr[0] = 97; + uint8arr[1] = 98; + uint8arr[2] = 99; + let blob2 = new buffer.Blob([arrBuf], { type: "new type", endings: "transparent" }); + blob2.text().then((value) => { + expect(value).assertEqual("abc"); + }); + }); + + /** + * @tc.name: testBlobConstructor0272 + * @tc.desc: Creates a new Blob object containing a concatenation of the given sources. + * For example: let blob2 = new buffer.Blob([uint8arr], { type: "new type", endings: "transparent" }) + * @tc.author: liuganlin + */ + it("testBlobConstructor0272", 0, async function () { + let uint8arr = new Uint8Array(3); + uint8arr[0] = 97; + uint8arr[1] = 98; + uint8arr[2] = 99; + let blob2 = new buffer.Blob([uint8arr], { type: "new type", endings: "transparent" }); + blob2.text().then((value) => { + expect(value).assertEqual("abc"); + }); + }); + + /** + * @tc.name: testBlobConstructor0273 + * @tc.desc: Creates a new Blob object containing a concatenation of the given sources. + * For example: let blob2 = new buffer.Blob([view], { type: "new type", endings: "transparent" }) + * @tc.author: liuganlin + */ + it("testBlobConstructor0273", 0, async function () { + let arrBuf = new ArrayBuffer(3); + let uint8arr = new Uint8Array(arrBuf); + uint8arr[0] = 97; + uint8arr[1] = 98; + uint8arr[2] = 99; + let view = new DataView(arrBuf); + let blob2 = new buffer.Blob([view], { type: "new type", endings: "transparent" }); + blob2.text().then((value) => { + expect(value).assertEqual("abc"); + }); + }); + + /** + * @tc.name: testBlobConstructor0274 + * @tc.desc: Creates a new Blob object containing a concatenation of the given sources. + * For example: let blob2 = new buffer.Blob(["a", "b", "c"], { type: "new type", endings: "transparent" }); + * let blob = new buffer.Blob([blob2]); + * @tc.author: liuganlin + */ + it("testBlobConstructor0274", 0, async function () { + let blob2 = new buffer.Blob(["a", "b", "c"], { type: "new type", endings: "transparent" }); + let blob = new buffer.Blob([blob2]); + blob.text().then((value) => { + expect(value).assertEqual("abc"); + }); + }); + + /** + * @tc.name: testBlobArrayBuffer0280 + * @tc.desc: Returns a promise that fulfills with an containing a copy of the Blob data. + * For example: let blob2 = new buffer.Blob(["a", "b", "c"], { type: "new type", endings: "transparent" }); + * @tc.author: liuganlin + */ + it("testBlobArrayBuffer0280", 0, async function () { + let blob2 = new buffer.Blob(["a", "b", "c"], { type: "new type", endings: "transparent" }); + console.log(blob2.size) + blob2.arrayBuffer().then((value) => { + let arr = new Uint8Array(value) + for (let i = 0, len = arr.length; i < len; i++) { + expect(arr[i]).assertEqual(97 + i); + } + }); + }); + + /** + * @tc.name: testBlobText0290 + * @tc.desc: Returns a promise that fulfills with the contents of the Blob decoded as a UTF-8 string. + * For example: let blob2 = new buffer.Blob(["a", "b", "c"], { type: "new type", endings: "transparent" }); + * @tc.author: liuganlin + */ + it("testBlobText0290", 0, async function () { + let blob2 = new buffer.Blob(["a", "b", "c"], { type: "new type", endings: "transparent" }); + console.log(blob2.size) + blob2.text().then((value) => { + expect(value).assertEqual("abc"); + }); + }); + + /** + * @tc.name: testBlobSlice0300 + * @tc.desc: Creates and returns a new Blob containing a subset of this Blob objects data. + * The original Blob is not altered. + * For example: let blob2 = new buffer.Blob(["a", "b", "c"], { type: "new type", endings: "transparent" }); + * let blob = blob2.slice(0, 1); + * @tc.author: liuganlin + */ + it("testBlobSlice0300", 0, async function () { + let blob2 = new buffer.Blob(["a", "b", "c"], { type: "new type", endings: "transparent" }); + let blob = blob2.slice(0, 1); + blob.arrayBuffer().then((value) => { + let arr = new Uint8Array(value) + expect(arr[0]).assertEqual(97); + expect(arr[1]).assertEqual(98); + expect(arr[2]).assertEqual(99); + }); + }); + + /** + * @tc.name: testWriteInt32BE0310 + * @tc.desc: Writes value to buf at the specified offset as big-endian. + * The value must be a valid signed 32-bit integer. + * For example: let ref = buf.writeInt32BE(0x12345678, 0); + * @tc.author: liuganlin + */ + it("testWriteInt32BE0310", 0, function () { + let buf = buffer.alloc(4); + let ref = buf.writeInt32BE(0x12345678, 0); + expect(ref).assertEqual(4); + + }); + + /** + * @tc.name: testWriteInt32BE0311 + * @tc.desc: Writes value to buf at the specified offset as big-endian. + * The value must be a valid signed 32-bit integer. + * For example: + * @tc.author: liuganlin + */ + it("testWriteInt32BE0311", 0, function () { + let buf = buffer.alloc(4); + try { + let ref = buf.writeInt32BE(0x12345678, -1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + + }); + + /** + * @tc.name: testWriteInt32BE0312 + * @tc.desc: Writes value to buf at the specified offset as big-endian. + * The value must be a valid signed 32-bit integer. + * For example: + * @tc.author: liuganlin + */ + it("testWriteInt32BE0312", 0, function () { + let buf = buffer.alloc(4); + try { + let ref = buf.writeInt32BE(0x123456789, 0); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "value" is out of range'); + } + }); + + /** + * @tc.name: testWriteInt32LE0320 + * @tc.desc: Writes value to buf at the specified offset as little-endian. + * The value must be a valid signed 32-bit integer. + * For example: let ref = buf.writeInt32LE(0x12345678, 0); + * @tc.author: liuganlin + */ + it("testWriteInt32LE0320", 0, function () { + let buf = buffer.alloc(4); + let ref = buf.writeInt32LE(0x12345678, 0); + expect(ref).assertEqual(4); + + }); + + /** + * @tc.name: testWriteInt32LE0321 + * @tc.desc: Writes value to buf at the specified offset as little-endian. + * The value must be a valid signed 32-bit integer. + * For example: let ref = buf.writeInt32LE(0x12345678, 0); + * @tc.author: liuganlin + */ + it("testWriteInt32LE0321", 0, function () { + let buf = buffer.alloc(4); + try { + let ref = buf.writeInt32LE(0x12345678, -1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testWriteInt32LE0322 + * @tc.desc: Writes value to buf at the specified offset as little-endian. + * The value must be a valid signed 32-bit integer. + * For example: let ref = buf.writeInt32LE(0x12345678, 0); + * @tc.author: liuganlin + */ + it("testWriteInt32LE0322", 0, function () { + let buf = buffer.alloc(4); + try { + let ref = buf.writeInt32LE(0x123456789, 0); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "value" is out of range'); + } + }); + + /** + * @tc.name: testWriteInt16BE0330 + * @tc.desc: Writes value to buf at the specified offset as big-endian. + * The value must be a valid signed 16-bit integer. + * For example: let ref = buf.writeInt32LE(0x12345678, 0); + * @tc.author: liuganlin + */ + it("testWriteInt16BE0330", 0, function () { + let buf = buffer.alloc(2); + let ref = buf.writeInt16BE(0x7bca, 0); + expect(ref).assertEqual(2); + }); + + /** + * @tc.name: testWriteInt16BE0331 + * @tc.desc: Writes value to buf at the specified offset as big-endian. + * The value must be a valid signed 16-bit integer. + * For example: + * @tc.author: liuganlin + */ + it("testWriteInt16BE0331", 0, function () { + let buf = buffer.alloc(2); + try { + let ref = buf.writeInt16BE(0x7bca, -1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testWriteInt16BE0332 + * @tc.desc: Writes value to buf at the specified offset as big-endian. + * The value must be a valid signed 16-bit integer. + * For example: + * @tc.author: liuganlin + */ + it("testWriteInt16BE0332", 0, function () { + let buf = buffer.alloc(2); + try { + let ref = buf.writeInt16BE(0x123456, 0); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "value" is out of range'); + } + }); + + /** + * @tc.name: testWriteInt16LE0340 + * @tc.desc: Writes value to buf at the specified offset as little-endian. + * The value must be a valid signed 16-bit integer. + * For example: let ref = buf.writeInt16LE(0x1234, 0); + * @tc.author: liuganlin + */ + it("testWriteInt16LE0340", 0, function () { + let buf = buffer.alloc(2); + let ref = buf.writeInt16LE(0x1234, 0); + expect(ref).assertEqual(2); + + }); + + /** + * @tc.name: testWriteInt16LE0341 + * @tc.desc: Writes value to buf at the specified offset as little-endian. + * The value must be a valid signed 16-bit integer. + * For example: + * @tc.author: liuganlin + */ + it("testWriteInt16LE0341", 0, function () { + let buf = buffer.alloc(2); + try { + let ref = buf.writeInt16LE(0x7bca, -1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testWriteInt16LE0342 + * @tc.desc: Writes value to buf at the specified offset as little-endian. + * The value must be a valid signed 16-bit integer. + * For example: + * @tc.author: liuganlin + */ + it("testWriteInt16LE0342", 0, function () { + let buf = buffer.alloc(2); + try { + let ref = buf.writeInt16LE(0x123456, 0); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "value" is out of range'); + } + }); + + /** + * @tc.name: testWriteInt80350 + * @tc.desc: Writes value to buf at the specified offset. + * value must be a valid signed 8-bit integer. + * For example: + * @tc.author: liuganlin + */ + it("testWriteInt80350", 0, function () { + let buf = buffer.allocUninitializedFromPool(2); + let ref = buf.writeInt8(2, 0); + expect(ref).assertEqual(1); + }); + + /** + * @tc.name: testWriteInt80351 + * @tc.desc: Writes value to buf at the specified offset. + * value must be a valid signed 8-bit integer. + * For example: + * @tc.author: liuganlin + */ + it("testWriteInt80351", 0, function () { + let buf = buffer.allocUninitializedFromPool(2); + try { + let ref = buf.writeInt8(2, -1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testWriteInt80352 + * @tc.desc: Writes value to buf at the specified offset.value must be a valid signed 8-bit integer. + * For example: + * @tc.author: liuganlin + */ + it("testWriteInt80352", 0, function () { + let buf = buffer.allocUninitializedFromPool(2); + try { + let ref = buf.writeInt8(0x13245, 0); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "value" is out of range'); + } + }); + + /** + * @tc.name: testWriteUInt16BE0360 + * @tc.desc: Writes value to buf at the specified offset as big-endian. + * The value must be a valid unsigned 16-bit integer. + * For example: + * @tc.author: liuganlin + */ + it("testWriteUInt16BE0360", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + let ref = buf.writeUInt16BE(0xdead, 0); + expect(ref).assertEqual(2); + }); + + /** + * @tc.name: testWriteUInt16BE0361 + * @tc.desc: Writes value to buf at the specified offset as big-endian. + * The value must be a valid unsigned 16-bit integer. + * For example: + * @tc.author: liuganlin + */ + it("testWriteUInt16BE0361", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + try { + let ref = buf.writeUInt16BE(0xdeadfc, 0); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "value" is out of range'); + } + }); + + /** + * @tc.name: testWriteUInt16BE0362 + * @tc.desc: Writes value to buf at the specified offset as big-endian. + * The value must be a valid unsigned 16-bit integer. + * For example: + * @tc.author: liuganlin + */ + it("testWriteUInt16BE0362", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + try { + let ref = buf.writeUInt16BE(0xdead, -1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testWriteUInt16LE0370 + * @tc.desc: Writes value to buf at the specified offset as little-endian. + * The value must be a valid unsigned 16-bit integer. + * For example: let ref = buf.writeUInt16LE(0xdead, 0); + * @tc.author: liuganlin + */ + it("testWriteUInt16LE0370", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + let ref = buf.writeUInt16LE(0xdead, 0); + expect(ref).assertEqual(2); + }); + + /** + * @tc.name: testWriteUInt16LE0371 + * @tc.desc: Writes value to buf at the specified offset as little-endian. + * The value must be a valid unsigned 16-bit integer. + * For example: + * @tc.author: liuganlin + */ + it("testWriteUInt16LE0371", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + try { + let ref = buf.writeUInt16LE(0xdeadfc, 0); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "value" is out of range'); + } + }); + + /** + * @tc.name: testWriteUInt16LE0372 + * @tc.desc: Writes value to buf at the specified offset as little-endian. + * The value must be a valid unsigned 16-bit integer. + * For example: + * @tc.author: liuganlin + */ + it("testWriteUInt16LE0372", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + try { + let ref = buf.writeUInt16LE(0xdead, -1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testWriteUInt32BE0380 + * @tc.desc: Writes value to buf at the specified offset as big-endian. + * The value must be a valid unsigned 32-bit integer. + * For example: let ref = buf.writeUInt32BE(0xfeedface, 0); + * @tc.author: liuganlin + */ + it("testWriteUInt32BE0380", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + let ref = buf.writeUInt32BE(0xfeedface, 0); + expect(ref).assertEqual(4); + }); + + /** + * @tc.name: testWriteUInt32BE0381 + * @tc.desc: Writes value to buf at the specified offset as big-endian. + * The value must be a valid unsigned 32-bit integer. + * For example: + * @tc.author: liuganlin + */ + it("testWriteUInt32BE0381", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + try { + let ref = buf.writeUInt32BE(0xfeedface, -1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testWriteUInt32LE0390 + * @tc.desc: Writes value to buf at the specified offset as little-endian. + * The value must be a valid unsigned 32-bit integer. + * For example: let ref = buf.writeUInt32LE(0xfeedface, 0); + * @tc.author: liuganlin + */ + it("testWriteUInt32LE0390", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + let ref = buf.writeUInt32LE(0xfeedface, 0); + expect(ref).assertEqual(4); + }); + + /** + * @tc.name: testWriteUInt32LE0391 + * @tc.desc: Writes value to buf at the specified offset as little-endian. + * The value must be a valid unsigned 32-bit integer. + * For example: + * @tc.author: liuganlin + */ + it("testWriteUInt32LE0391", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + try { + let ref = buf.writeUInt32LE(0xfeedface, -1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testWriteUInt80400 + * @tc.desc: Writes value to buf at the specified offset. value must be a valid unsigned 8-bit integer. + * For example: let ref = buf.writeUInt8(0x42, 3); + * @tc.author: liuganlin + */ + it("testWriteUInt80400", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + let ref = buf.writeUInt8(0x42, 3); + expect(ref).assertEqual(4); + }); + + /** + * @tc.name: testWriteUInt80401 + * @tc.desc: Writes value to buf at the specified offset. value must be a valid unsigned 8-bit integer. + * For example: let ref = buf.writeUInt8(0x42, 3); + * @tc.author: liuganlin + */ + it("testWriteUInt80401", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + try { + let ref = buf.writeUInt8(0x42, -1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testWriteUIntBE0410 + * @tc.desc: Writes byteLength bytes of value to buf at the specified offset as big-endian. + * For example: let ref = buf.writeUInt8(0x42, 3); + * @tc.author: liuganlin + */ + it("testWriteUIntBE0410", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + let ref = buf.writeUIntBE(0x13141516, 0, 4); + expect(ref).assertEqual(4); + }); + + /** + * @tc.name: testWriteUIntBE0411 + * @tc.desc: Writes byteLength bytes of value to buf at the specified offset as big-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteUIntBE0411", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + try { + let ref = buf.writeUIntBE(0x13141516, 0, 1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "value" is out of range'); + } + }); + + /** + * @tc.name: testWriteUIntBE0412 + * @tc.desc: Writes byteLength bytes of value to buf at the specified offset as big-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteUIntBE0412", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + try { + let ref = buf.writeUIntBE(0x13141516, 1, 4); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testWriteUIntLE0420 + * @tc.desc: Writes byteLength bytes of value to buf at the specified offset as little-endian. + * For example: let ref = buf.writeUIntLE(0x13141516, 0, 4); + * @tc.author: liuganlin + */ + it("testWriteUIntLE0420", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + let ref = buf.writeUIntLE(0x13141516, 0, 4); + expect(ref).assertEqual(4); + }); + + /** + * @tc.name: testWriteUIntLE0421 + * @tc.desc: Writes byteLength bytes of value to buf at the specified offset as little-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteUIntLE0421", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + try { + let ref = buf.writeUIntLE(0x13141516, 0, 1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "value" is out of range'); + } + }); + + /** + * @tc.name: testWriteUIntLE0422 + * @tc.desc: Writes byteLength bytes of value to buf at the specified offset as little-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteUIntLE0422", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + try { + let ref = buf.writeUIntLE(0x13141516, 1, 4); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testWriteIntBE0430 + * @tc.desc: Writes byteLength bytes of value to buf at the specified offset as big-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteIntBE0430", 0, function () { + let buf = buffer.allocUninitializedFromPool(6); + let ref = buf.writeIntBE(0x1234567890ab, 0, 6); + expect(ref).assertEqual(6); + }); + + /** + * @tc.name: testWriteIntBE0431 + * @tc.desc: Writes byteLength bytes of value to buf at the specified offset as big-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteIntBE0431", 0, function () { + let buf = buffer.allocUninitializedFromPool(6); + try { + let ref = buf.writeIntBE(0x1234567890ab, 1, 6); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testWriteIntLE0440 + * @tc.desc: Writes byteLength bytes of value to buf at the specified offset as little-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteIntLE0440", 0, function () { + let buf = buffer.allocUninitializedFromPool(6); + let ref = buf.writeIntLE(0x1234567890ab, 0, 6); + expect(ref).assertEqual(6); + }); + + /** + * @tc.name: testWriteIntLE0441 + * @tc.desc: Writes byteLength bytes of value to buf at the specified offset as little-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteIntLE0441", 0, function () { + let buf = buffer.allocUninitializedFromPool(6); + try { + let ref = buf.writeIntLE(0x1234567890ab, 1, 6); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testWriteDoubleBE0450 + * @tc.desc: Writes value to buf at the specified offset as big-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteDoubleBE0450", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + let ref = buf.writeDoubleBE(123.456, 0); + expect(ref).assertEqual(8); + }); + + /** + * @tc.name: testWriteDoubleBE0451 + * @tc.desc: Writes value to buf at the specified offset as big-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteDoubleBE0451", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + try { + let ref = buf.writeDoubleBE(123.456, 1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testWriteDoubleLE0460 + * @tc.desc: Writes value to buf at the specified offset as little-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteDoubleLE0460", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + let ref = buf.writeDoubleLE(123.456, 0); + expect(ref).assertEqual(8); + }); + + /** + * @tc.name: testWriteDoubleLE0461 + * @tc.desc: Writes value to buf at the specified offset as little-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteDoubleLE0461", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + try { + let ref = buf.writeDoubleLE(123.456, 1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testWriteFloatBE0470 + * @tc.desc: Writes value to buf at the specified offset as big-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteFloatBE0470", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + let ref = buf.writeFloatBE(0xcabcbcbc, 0); + expect(ref).assertEqual(4); + }); + + /** + * @tc.name: testWriteFloatBE0471 + * @tc.desc: Writes value to buf at the specified offset as big-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteFloatBE0471", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + try { + let ref = buf.writeFloatBE(0xcabcbcbc, 5); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testWriteFloatLE0480 + * @tc.desc: Writes value to buf at the specified offset as little-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteFloatLE0480", 0, function () { + let buf = buffer.allocUninitializedFromPool(16); + let ref = buf.writeFloatLE(0xcabcbcbc, 12); + expect(ref).assertEqual(16); + }); + + /** + * @tc.name: testWriteFloatLE0481 + * @tc.desc: Writes value to buf at the specified offset as little-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteFloatLE0481", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + try { + let ref = buf.writeFloatLE(0xcabcbcbc, 5); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testWriteBigInt64BE0490 + * @tc.desc: Writes value to buf at the specified offset as big-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteBigInt64BE0490", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + let ref = buf.writeBigInt64BE(0x0102030405060708n, 0); + expect(ref).assertEqual(8); + }); + + /** + * @tc.name: testWriteBigInt64BE0491 + * @tc.desc: Writes value to buf at the specified offset as big-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteBigInt64BE0491", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + try { + let ref = buf.writeBigInt64BE(0x0102030405060708n, 1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testWriteBigInt64LE0500 + * @tc.desc: Writes value to buf at the specified offset as little-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteBigInt64LE0500", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + let ref = buf.writeBigInt64LE(0x0102030405060708n, 0); + expect(ref).assertEqual(8); + }); + + /** + * @tc.name: testWriteBigInt64LE0501 + * @tc.desc: Writes value to buf at the specified offset as little-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteBigInt64LE0501", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + try { + let ref = buf.writeBigInt64LE(0x0102030405060708n, 1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testWriteBigUInt64BE0510 + * @tc.desc: Writes value to buf at the specified offset as big-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteBigUInt64BE0510", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + let ref = buf.writeBigUInt64BE(0xdecafafecacefaden, 0); + expect(ref).assertEqual(8); + }); + + /** + * @tc.name: testWriteBigUInt64BE0511 + * @tc.desc: Writes value to buf at the specified offset as big-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteBigUInt64BE0511", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + try { + let ref = buf.writeBigUInt64BE(0xdecafafecacefaden, 1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testWriteBigUInt64LE0520 + * @tc.desc: Writes value to buf at the specified offset as little-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteBigUInt64LE0520", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + let ref = buf.writeBigUInt64LE(0xdecafafecacefaden, 0); + expect(ref).assertEqual(8); + }); + + /** + * @tc.name: testWriteBigUInt64LE0521 + * @tc.desc: Writes value to buf at the specified offset as little-endian. + * For example: + * @tc.author: liuganlin + */ + it("testWriteBigUInt64LE0521", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + try { + let ref = buf.writeBigUInt64LE(0xdecafafecacefaden, 1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testReadInt32BE0530 + * @tc.desc: Reads a signed, big-endian 32-bit integer from buf at the specified offset. + * For example: + * @tc.author: liuganlin + */ + it("testReadInt32BE0530", 0, function () { + let buf = buffer.alloc(4); + buf.writeInt32BE(0x12345678, 0); + let ref = buf.readInt32BE(0).toString(16); + expect(ref).assertEqual("12345678"); + }); + + /** + * @tc.name: testReadInt32BE0531 + * @tc.desc: Reads a signed, big-endian 32-bit integer from buf at the specified offset. + * For example: + * @tc.author: liuganlin + */ + it("testReadInt32BE0531", 0, function () { + let buf = buffer.alloc(4); + buf.writeInt32BE(0x12345678, 0); + try { + let ref = buf.readInt32BE(1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testReadInt32LE0540 + * @tc.desc: Reads a signed, little-endian 32-bit integer from buf at the specified offset. + * For example: + * @tc.author: liuganlin + */ + it("testReadInt32LE0540", 0, function () { + let buf = buffer.alloc(4); + buf.writeInt32BE(0x12345678, 0); + let ref = buf.readInt32LE(0).toString(16); + expect(ref).assertEqual("78563412"); + }); + + /** + * @tc.name: testReadInt32LE0541 + * @tc.desc: Reads a signed, little-endian 32-bit integer from buf at the specified offset. + * For example: + * @tc.author: liuganlin + */ + it("testReadInt32LE0541", 0, function () { + let buf = buffer.alloc(4); + buf.writeInt32BE(0x12345678, 0); + try { + let ref = buf.readInt32LE(1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testReadInt16BE0550 + * @tc.desc: Reads a signed, big-endian 16-bit integer from buf at the specified offset. + * For example: + * @tc.author: liuganlin + */ + it("testReadInt16BE0550", 0, function () { + let buf = buffer.alloc(2); + buf.writeInt16BE(0x1234, 0); + let ref = buf.readInt16BE(0).toString(16); + expect(ref).assertEqual("1234"); + }); + + /** + * @tc.name: testReadInt16BE0551 + * @tc.desc: Reads a signed, big-endian 16-bit integer from buf at the specified offset. + * For example: + * @tc.author: liuganlin + */ + it("testReadInt16BE0551", 0, function () { + let buf = buffer.alloc(2); + buf.writeInt16BE(0x1234, 0); + try { + let ref = buf.readInt16BE(1).toString(16); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testReadInt16LE0560 + * @tc.desc: Reads a signed, little-endian 16-bit integer from buf at the specified offset. + * For example: + * @tc.author: liuganlin + */ + it("testReadInt16LE0560", 0, function () { + let buf = buffer.alloc(2); + buf.writeInt16BE(0x1234, 0); + let ref = buf.readInt16LE(0).toString(16); + expect(ref).assertEqual("3412"); + }); + + /** + * @tc.name: testReadInt16LE0561 + * @tc.desc: Reads a signed, little-endian 16-bit integer from buf at the specified offset. + * For example: + * @tc.author: liuganlin + */ + it("testReadInt16LE0561", 0, function () { + let buf = buffer.alloc(2); + buf.writeInt16BE(0x1234, 0); + try { + let ref = buf.readInt16LE(1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testReadInt80570 + * @tc.desc: Reads a signed 8-bit integer from buf at the specified offset. + * For example: + * @tc.author: liuganlin + */ + it("testReadInt80570", 0, function () { + let buf = buffer.allocUninitializedFromPool(2); + buf.writeInt8(0x12); + let ref = buf.readInt8(0).toString(16); + expect(ref).assertEqual("12"); + }); + + /** + * @tc.name: testReadInt80571 + * @tc.desc: Reads a signed 8-bit integer from buf at the specified offset. + * For example: + * @tc.author: liuganlin + */ + it("testReadInt80571", 0, function () { + let buf = buffer.allocUninitializedFromPool(2); + buf.writeInt8(0x12); + try { + let ref = buf.readInt8(2).toString(16); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testReadUInt16BE0580 + * @tc.desc: Reads an unsigned, big-endian 16-bit integer from buf at the specified offset. + * For example: + * @tc.author: liuganlin + */ + it("testReadUInt16BE0580", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + buf.writeUInt16BE(0x1234, 0); + let ref = buf.readUInt16BE(0).toString(16); + expect(ref).assertEqual("1234"); + }); + + /** + * @tc.name: testReadUInt16BE0581 + * @tc.desc: Reads an unsigned, big-endian 16-bit integer from buf at the specified offset. + * For example: + * @tc.author: liuganlin + */ + it("testReadUInt16BE0581", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + buf.writeUInt16BE(0x1234, 0); + try { + let ref = buf.readUInt16BE(3).toString(16); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testReadUInt16LE0590 + * @tc.desc: Reads an unsigned, little-endian 16-bit integer from buf at the specified offset. + * For example: + * @tc.author: liuganlin + */ + it("testReadUInt16LE0590", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + buf.writeUInt16LE(0x1234, 0); + let ref = buf.readUInt16LE(0).toString(16); + expect(ref).assertEqual("1234"); + }); + + /** + * @tc.name: testReadUInt16LE0591 + * @tc.desc: Reads an unsigned, little-endian 16-bit integer from buf at the specified offset. + * For example: + * @tc.author: liuganlin + */ + it("testReadUInt16LE0591", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + buf.writeUInt16LE(0x1234, 0); + try { + let ref = buf.readUInt16LE(3).toString(16); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testReadUInt32BE0600 + * @tc.desc: Reads an unsigned, big-endian 32-bit integer from buf at the specified offset. + * For example: + * @tc.author: liuganlin + */ + it("testReadUInt32BE0600", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + buf.writeUInt32BE(0x12345678, 0); + let ref = buf.readUInt32BE(0).toString(16); + expect(ref).assertEqual("12345678"); + }); + + /** + * @tc.name: testReadUInt32BE0601 + * @tc.desc: Reads an unsigned, big-endian 32-bit integer from buf at the specified offset. + * For example: + * @tc.author: liuganlin + */ + it("testReadUInt32BE0601", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + buf.writeUInt32BE(0x12345678, 0); + try { + let ref = buf.readUInt32BE(1).toString(16); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testReadUInt32LE0610 + * @tc.desc: Reads an unsigned, little-endian 32-bit integer from buf at the specified offset. + * For example: + * @tc.author: liuganlin + */ + it("testReadUInt32LE0610", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + buf.writeUInt32LE(0x12345678, 0); + let ref = buf.readUInt32LE(0).toString(16); + expect(ref).assertEqual("12345678"); + }); + + /** + * @tc.name: testReadUInt32LE0611 + * @tc.desc: Reads an unsigned, little-endian 32-bit integer from buf at the specified offset. + * For example: + * @tc.author: liuganlin + */ + it("testReadUInt32LE0611", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + buf.writeUInt32LE(0x12345678, 0); + try { + let ref = buf.readUInt32LE(1).toString(16); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testReadUInt80620 + * @tc.desc: Reads an unsigned 8-bit integer from buf at the specified offset. + * For example: + * @tc.author: liuganlin + */ + it("testReadUInt80620", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + buf.writeUInt8(0x42); + let ref = buf.readUInt8(0).toString(16); + expect(ref).assertEqual("42"); + }); + + /** + * @tc.name: testReadUInt80621 + * @tc.desc: Reads an unsigned 8-bit integer from buf at the specified offset. + * For example: + * @tc.author: liuganlin + */ + it("testReadUInt80621", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + buf.writeUInt8(0x42); + try { + let ref = buf.readUInt8(4).toString(16); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testReadUIntBE0630 + * @tc.desc: Reads an unsigned 8-bit integer from buf at the specified offset. + * For example: + * @tc.author: liuganlin + */ + it("testReadUIntBE0630", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + buf.writeUIntBE(0x13141516, 0, 4); + let ref = buf.readUIntBE(0, 3).toString(16); + expect(ref).assertEqual("131415"); + }); + + /** + * @tc.name: testReadUIntBE0631 + * @tc.desc: Reads an unsigned 8-bit integer from buf at the specified offset. + * For example: + * @tc.author: liuganlin + */ + it("testReadUIntBE0631", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + buf.writeUIntBE(0x13141516, 0, 4); + try { + let ref = buf.readUIntBE(2, 3).toString(16); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testReadUIntLE0640 + * @tc.desc: Reads byteLength number of bytes from buf at the specified offset and interprets + * the result as an unsigned, little-endian integer supporting up to 48 bits of accuracy. + * @tc.author: liuganlin + */ + it("testReadUIntLE0640", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + buf.writeUIntLE(0x13141516, 0, 4); + let ref = buf.readUIntLE(0, 3).toString(16); + expect(ref).assertEqual("141516"); + }); + + /** + * @tc.name: testReadUIntLE0641 + * @tc.desc: Reads byteLength number of bytes from buf at the specified offset and interprets + * the result as an unsigned, little-endian integer supporting up to 48 bits of accuracy. + * @tc.author: liuganlin + */ + it("testReadUIntLE0641", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + buf.writeUIntLE(0x13141516, 0, 4); + try { + let ref = buf.readUIntLE(2, 3).toString(16); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testReadIntBE0650 + * @tc.desc: Reads byteLength number of bytes from buf at the specified offset and interprets + * the result as a big-endian, two's complement signed value supporting up to 48 bits of accuracy. + * @tc.author: liuganlin + */ + it("testReadIntBE0650", 0, function () { + let buf = buffer.allocUninitializedFromPool(6); + buf.writeIntBE(0x123456789011, 0, 6); + let ref = buf.readIntBE(0, 5).toString(16); + expect(ref).assertEqual("1234567890"); + }); + + /** + * @tc.name: testReadIntBE0651 + * @tc.desc: Reads byteLength number of bytes from buf at the specified offset and interprets + * the result as a big-endian, two's complement signed value supporting up to 48 bits of accuracy. + * @tc.author: liuganlin + */ + it("testReadIntBE0651", 0, function () { + let buf = buffer.allocUninitializedFromPool(6); + buf.writeIntBE(0x123456789011, 0, 6); + try { + let ref = buf.readIntBE(2, 5).toString(16); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testReadIntLE0660 + * @tc.desc: Reads byteLength number of bytes from buf at the specified offset and interprets + * the result as a little-endian, two's complement signed value supporting up to 48 bits of accuracy. + * @tc.author: liuganlin + */ + it("testReadIntLE0660", 0, function () { + let buf = buffer.allocUninitializedFromPool(6); + buf.writeIntLE(0x123456789011, 0, 6); + let ref = buf.readIntLE(0, 5).toString(16); + expect(ref).assertEqual("3456789011"); + }); + + /** + * @tc.name: testReadIntLE0661 + * @tc.desc: Reads byteLength number of bytes from buf at the specified offset and interprets + * the result as a little-endian, two's complement signed value supporting up to 48 bits of accuracy. + * @tc.author: liuganlin + */ + it("testReadIntLE0661", 0, function () { + let buf = buffer.allocUninitializedFromPool(6); + buf.writeIntLE(0x123456789011, 0, 6); + try { + let ref = buf.readIntLE(2, 5).toString(16); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testReadDoubleBE0670 + * @tc.desc: Reads a 64-bit, big-endian double from buf at the specified offset. + * @tc.author: liuganlin + */ + it("testReadDoubleBE0670", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + buf.writeDoubleBE(123.456, 0); + let ref = buf.readDoubleBE(); + expect(ref).assertEqual(123.456); + }); + + /** + * @tc.name: testReadDoubleBE0671 + * @tc.desc: Reads a 64-bit, big-endian double from buf at the specified offset. + * @tc.author: liuganlin + */ + it("testReadDoubleBE0671", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + buf.writeDoubleBE(123.456, 0); + try { + let ref = buf.readDoubleBE(1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testReadDoubleLE0680 + * @tc.desc: Reads a 64-bit, little-endian double from buf at the specified offset. + * @tc.author: liuganlin + */ + it("testReadDoubleLE0680", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + buf.writeDoubleLE(123.456, 0); + let ref = buf.readDoubleLE(); + expect(ref).assertEqual(123.456); + }); + + /** + * @tc.name: testReadDoubleLE0681 + * @tc.desc: Reads a 64-bit, little-endian double from buf at the specified offset. + * @tc.author: liuganlin + */ + it("testReadDoubleLE0681", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + buf.writeDoubleLE(123.456, 0); + try { + let ref = buf.readDoubleLE(1); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testReadFloatBE0690 + * @tc.desc: Reads a 32-bit, big-endian float from buf at the specified offset. + * @tc.author: liuganlin + */ + it("testReadFloatBE0690", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + buf.writeFloatBE(0xcabcbcbc, 0); + let ref = buf.readFloatBE(0).toString(16); + expect(ref).assertEqual("cabcbd00"); + }); + + /** + * @tc.name: testReadFloatBE0691 + * @tc.desc: Reads a 32-bit, big-endian float from buf at the specified offset. + * @tc.author: liuganlin + */ + it("testReadFloatBE0691", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + buf.writeFloatBE(0xcabcbcbc, 0); + try { + let ref = buf.readFloatBE(1).toString(16); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testReadFloatLE0700 + * @tc.desc: Reads a 32-bit, little-endian float from buf at the specified offset. + * @tc.author: liuganlin + */ + it("testReadFloatLE0700", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + buf.writeFloatLE(0xcabcbcbc, 0); + let ref = buf.readFloatLE(0).toString(16); + expect(ref).assertEqual("cabcbd00"); + }); + + /** + * @tc.name: testReadFloatLE0701 + * @tc.desc: Reads a 32-bit, little-endian float from buf at the specified offset. + * @tc.author: liuganlin + */ + it("testReadFloatLE0701", 0, function () { + let buf = buffer.allocUninitializedFromPool(4); + buf.writeFloatLE(0xcabcbcbc, 0); + try { + let ref = buf.readFloatLE(1).toString(16); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testReadBigInt64BE0710 + * @tc.desc: Reads a signed, big-endian 64-bit integer from buf at the specified offset. + * @tc.author: liuganlin + */ + it("testReadBigInt64BE0710", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + buf.writeBigInt64BE(0x0102030405060708n, 0); + let ref = buf.readBigInt64BE(0).toString(16); + expect(ref).assertEqual("102030405060708"); + }); + + /** + * @tc.name: testReadBigInt64BE0711 + * @tc.desc: Reads a signed, big-endian 64-bit integer from buf at the specified offset. + * @tc.author: liuganlin + */ + it("testReadBigInt64BE0711", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + buf.writeBigInt64BE(0x0102030405060708n, 0); + try { + let ref = buf.readBigInt64BE(1).toString(16); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testReadBigInt64LE0720 + * @tc.desc: Reads a signed, little-endian 64-bit integer from buf at the specified offset. + * @tc.author: liuganlin + */ + it("testReadBigInt64LE0720", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + buf.writeBigInt64BE(0x0102030405060708n, 0); + let ref = buf.readBigInt64LE(0).toString(16); + expect(ref).assertEqual("807060504030201"); + }); + + /** + * @tc.name: testReadBigInt64LE0721 + * @tc.desc: Reads a signed, little-endian 64-bit integer from buf at the specified offset. + * @tc.author: liuganlin + */ + it("testReadBigInt64LE0721", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + buf.writeBigInt64BE(0x0102030405060708n, 0); + try { + let ref = buf.readBigInt64LE(1).toString(16); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testReadBigUInt64BE0730 + * @tc.desc: Reads a unsigned, big-endian 64-bit integer from buf at the specified offset. + * @tc.author: liuganlin + */ + it("testReadBigUInt64BE0730", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + buf.writeBigUInt64BE(0xdecafafecacefaden, 0); + let ref = buf.readBigUInt64BE(0).toString(16); + expect(ref).assertEqual("decafafecacefade"); + }); + + /** + * @tc.name: testReadBigUInt64BE0731 + * @tc.desc: Reads a unsigned, big-endian 64-bit integer from buf at the specified offset. + * @tc.author: liuganlin + */ + it("testReadBigUInt64BE0731", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + buf.writeBigUInt64BE(0xdecafafecacefaden, 0); + try { + let ref = buf.readBigUInt64BE(1).toString(16); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); + + /** + * @tc.name: testReadBigUInt64LE0740 + * @tc.desc: Reads a unsigned, little-endian 64-bit integer from buf at the specified offset. + * @tc.author: liuganlin + */ + it("testReadBigUInt64LE0740", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + buf.writeBigUInt64BE(0xdecafafecacefaden, 0); + let ref = buf.readBigUInt64LE(0).toString(16); + expect(ref).assertEqual("defacecafefacade"); + }); + + /** + * @tc.name: testReadBigUInt64LE0741 + * @tc.desc: Reads a unsigned, little-endian 64-bit integer from buf at the specified offset. + * @tc.author: liuganlin + */ + it("testReadBigUInt64LE0741", 0, function () { + let buf = buffer.allocUninitializedFromPool(8); + buf.writeBigUInt64BE(0xdecafafecacefaden, 0); + try { + let ref = buf.readBigUInt64LE(1).toString(16); + } catch (err) { + expect(err.name).assertEqual('RangeError'); + expect(err.message).assertEqual('The value of "offset" is out of range'); + } + }); +}); diff --git a/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/test/Main.test.js b/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/test/Main.test.js new file mode 100644 index 0000000000000000000000000000000000000000..a270aae4aa024fbd7ae4312cd1e063dd9a819a36 --- /dev/null +++ b/commonlibrary/ets_utils/buffer_lib_standard/src/main/js/test/Main.test.js @@ -0,0 +1,17 @@ +/* + * Copyright (C) 2022 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. + */ + +require('./Buffer.test.js'); + diff --git a/commonlibrary/ets_utils/buffer_lib_standard/src/main/resources/base/element/string.json b/commonlibrary/ets_utils/buffer_lib_standard/src/main/resources/base/element/string.json new file mode 100644 index 0000000000000000000000000000000000000000..0bae6bd40f7360d5d818998221b199d3ec0f69c0 --- /dev/null +++ b/commonlibrary/ets_utils/buffer_lib_standard/src/main/resources/base/element/string.json @@ -0,0 +1,12 @@ +{ + "string": [ + { + "name": "entry_MainAbility", + "value": "entry_MainAbility" + }, + { + "name": "mainability_description", + "value": "JS_Empty Ability" + } + ] +} \ No newline at end of file diff --git a/commonlibrary/ets_utils/buffer_lib_standard/src/main/resources/base/media/icon.png b/commonlibrary/ets_utils/buffer_lib_standard/src/main/resources/base/media/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..ce307a8827bd75456441ceb57d530e4c8d45d36c Binary files /dev/null and b/commonlibrary/ets_utils/buffer_lib_standard/src/main/resources/base/media/icon.png differ