From 57695262784bd44dd7803da8815bc6cd1b5ecc47 Mon Sep 17 00:00:00 2001 From: liu-ganlin Date: Wed, 27 Jul 2022 11:26:17 +0800 Subject: [PATCH] Description add buffer XTS Tests Related issue #I5J49M:add buffer XTS Tests Signed-off-by: liu-ganlin --- commonlibrary/ets_utils/BUILD.gn | 1 + .../ets_utils/buffer_lib_standard/BUILD.gn | 39 + .../ets_utils/buffer_lib_standard/Test.json | 18 + .../signature/openharmony_sx.p7b | Bin 0 -> 3437 bytes .../buffer_lib_standard/src/main/config.json | 62 + .../src/main/js/default/app.js | 22 + .../src/main/js/default/i18n/en-US.json | 6 + .../src/main/js/default/i18n/zh-CN.json | 6 + .../src/main/js/default/pages/index/index.css | 44 + .../src/main/js/default/pages/index/index.hml | 5 + .../src/main/js/default/pages/index/index.js | 38 + .../src/main/js/test/Buffer.test.js | 2220 +++++++++++++++++ .../src/main/js/test/Main.test.js | 17 + .../main/resources/base/element/string.json | 12 + .../src/main/resources/base/media/icon.png | Bin 0 -> 6790 bytes 15 files changed, 2490 insertions(+) create mode 100644 commonlibrary/ets_utils/buffer_lib_standard/BUILD.gn create mode 100644 commonlibrary/ets_utils/buffer_lib_standard/Test.json create mode 100644 commonlibrary/ets_utils/buffer_lib_standard/signature/openharmony_sx.p7b create mode 100644 commonlibrary/ets_utils/buffer_lib_standard/src/main/config.json create mode 100644 commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/app.js create mode 100644 commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/i18n/en-US.json create mode 100644 commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/i18n/zh-CN.json create mode 100644 commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/pages/index/index.css create mode 100644 commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/pages/index/index.hml create mode 100644 commonlibrary/ets_utils/buffer_lib_standard/src/main/js/default/pages/index/index.js create mode 100644 commonlibrary/ets_utils/buffer_lib_standard/src/main/js/test/Buffer.test.js create mode 100644 commonlibrary/ets_utils/buffer_lib_standard/src/main/js/test/Main.test.js create mode 100644 commonlibrary/ets_utils/buffer_lib_standard/src/main/resources/base/element/string.json create mode 100644 commonlibrary/ets_utils/buffer_lib_standard/src/main/resources/base/media/icon.png diff --git a/commonlibrary/ets_utils/BUILD.gn b/commonlibrary/ets_utils/BUILD.gn index 14b969ade..4311c8c74 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 000000000..9a5e1d510 --- /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 000000000..5cd5efaf2 --- /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 GIT binary patch literal 3437 zcmcgvX>b$g8MY4FF(5FQyMT=#m||qU)nQ9cId-MBB-<-lvSdq&snM}IENNF>t+bK| zgowuF2vC|SxSZxNN5eHhV%(WPpbeB9Fc3;JDMtzMBv1-XAc2N~c2_tCXW&OCGw6qQ z-s9VS-tT?h=bI0tMS+~WDXqHJyCPmLzdbE-fV8Nd&*MRZfG8(#POFZG3xs@Lb{0ry z=R8j3wWo!5g=yjKx#BoZMFS)uA)H}cTp@-^K`9VV?RC3J59@}eik*>n|pRKOLZ zxdn7G!Yv@9O#y<&eUy{)vMXb;fQR)ffVAADQsEMXm;IBMDLfLD0w^U;6%HVo-0Q_5 zCHEa?DBuauNpZzoF+tK27w#n~?u%toS-DhR4k@Q*{7x^8Q=D6&kd^_~J#VVG2LXkL zaAy=}U*?Jto)9hx5MGjdp9hcQAu@tfk_;l!PeyxPY<8b&+&D!CyaBh9=8BSVKLpk4 z4Ml3yY|&Th)vyK4cpC{!uU8v2YBlVV`d~(nz&<@{G1oe*DHub1z7~J5*;s2bX<)_* zV_GbsPQg`(&rpxRb_*Od7}++3+liSw-$!1 zs5*g}EHWhI3i|!-FcfzYL0`SL-rq>LENC;PMl)G(0(1U2%Va|smp0UFx0xd@soZA* zD5LYc4OlbE7@ARt#h}rr3>K@bf%B#^-c+xz8Hr)0D5ExIFltezN@Hn8>o5d~bSfYtkc+_Z&kI#-N5_GhCg*V-^TSO=!G~ z(fXy{n2XV+k}6w_W`dTOP2a4u0ly;ANZ>4OxSKAzFB!yBzdo`gX zO?o|H@WiAw$y6l?=^3jA_Hy0S)nTYs12;4hKE&ekQ|>?|ZLJ}#F`2BczC7kdE4@xV zZBD_)Otwjhz+NSaz?d45!;FsGSu-#qh#hStD%B}f!mCT!KqzSo>I`NGH_9Dea$1Qi zg29Ydt!~lQVR99_T7#Hije~(12drl-P)SV?QR*9sus`8th-8^OQ7@xI$(Yp|^;bL1 zR50O$mDXw6P>i7B(TJ)ciPzTE>XY%X6HAa)b#OBRXv&~%Bw|J#Y><i4=e%95bjtw|cJp=#P#Pf#*luqI_wR;fISDCJhAqSG6R%xItn%~QtZ@m%&u zjGGLX;t6Ls62eQvNmf@v+}J%54^CygxRZ`?8X#r|wkev7(s;Ou4T#y1XNNf)h;o7z z8a^Lfq<1uH`E{G9E z*(=)Css_LSk=>E9jr)s5^2-!+MN=Ds}>1hRma4`uCIz9%p3O77839E{xf z4c_I?**|1`K2tg4!Hvyrou4BsJQuv*UfF)<%CelYIS>D^o?X)3+MK%la6kooW8&G@BU)Y0hT`+mOm$Z_%rB=a%o>I z!2c6lHyKQN)VjiFwa!eE^p8jc$sy$vB+8i25lI~6KPFFh$!o$avA~rj#L6xvR|Z83 z*WD6T9e+5Pyy=F+)pNTf{ny3cy>7Rkd3o*TS?TZJ`NS^NF2%HMkyS{?uJ$`!P4_L^ z1`NFDUbNyg_qREifgktnp1_v{Jbb`7m}2PTyUdOmtJj~m z9bB=ecw4_^rw1IW=of+>nrW5=d3k`3qHCxsIN_F{T1A545};;+fsyC&qChi+YV zr~M63H8ZLCPYmsjY>ls9cL%I)F|JIW-#+48$+lD4k*(P*kDM%zx_fvu4u5ZYUnI}5 zdrycFq>xFU)&X3p@pP2u%$o}}YcRn(MhJ&B2o?KS@cIVz>Ye%o^xV?CB{_Qhu z;}_q1bvO^g{8<3!gYbo4Di{8qzV+(9 zdlmksohQmRTs@qB;(Wo?dER_ux6XQb@q$tQPW?CMu6GVQd;R=iR;-S{Kr%Zks7>b1 zNs{|-+jhObYE}NR&`TGGr^h^4bjh%c>R#@=8nM&Md>_a+zVulsl;){flFekV1t9ob z+SqfV_Pv3$2f)bQ8%Ul2>fdYR^1zs0BQF~olsOj5AodC&Q_7SMFzsz2 z9newxE&jodk~tNHwl%LBMMDbrk=(^b literal 0 HcmV?d00001 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 000000000..6e207ebf9 --- /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 000000000..ff2c11965 --- /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 000000000..e63c70d97 --- /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 000000000..de6ee5748 --- /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 000000000..2b1965821 --- /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 000000000..20a4e40d9 --- /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 000000000..3d5d7b311 --- /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 000000000..4b220b877 --- /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 000000000..a270aae4a --- /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 000000000..0bae6bd40 --- /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 GIT binary patch literal 6790 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