Skip to content

X
Xts Acts

OpenHarmony / Xts Acts
1 年多 前同步成功

通知 9
Star 22
Fork 0
X
Xts Acts
提交 28dfabd7 编写于 作者: Y yang-qibo 提交者： 杨启博
浏览文件
操作

fixed 488e25c2 from https://gitee.com/yang-qibo/xts_acts/pulls/6533 

新增rpc中MessageSequence类接口用例
Signed-off-by: Nyang-qibo <yangqibo1@huawei.com>
上级 8a3f2c56
隐藏空白更改
内联 并排
Showing with 1553 addition and 0 deletion
communication/dsoftbus/rpc/src/main/js/test/RpcClientJsunit.test.js
浏览文件 @ 28dfabd7
......@@ -75,6 +75,13 @@ export default function actsRpcClientJsTest() {
const CODE_WRITE_REMOTEOBJECTARRAY_2 = 31;
const CODE_ONREMOTEMESSAGE_OR_ONREMOTE = 32;
const CODE_ONREMOTEMESSAGEREQUEST = 33;
const CODE_INTERFACETOKEN = 34;
const CODE_WRITE_SHORTARRAY = 35;
const CODE_WRITE_LONGARRAY = 36;
const CODE_WRITE_DOUBLEARRAY = 37;
const CODE_WRITE_BOOLEANARRAY = 38;
const CODE_WRITE_CHARARRAY = 39;
const CODE_WRITE_STRINGARRAY = 40;
function sleep(numberMillis)
{
......@@ -568,6 +575,55 @@ export default function actsRpcClientJsTest() {
let result = reply.writeString("onRemoteMessageRequest invoking")
return true
}
case 34:
{
console.info("case 34 start")
let tmp = data.readInterfaceToken()
let result = reply.writeInterfaceToken(tmp)
return true
}
case 35:
{
console.info("case 35 start")
let tmp1 = data.readShortArray()
let result = reply.writeShortArray(tmp1)
return true
}
case 36:
{
console.info("case 36 start")
let tmp1 = data.readLongArray()
let result = reply.writeLongArray(tmp1)
return true
}
case 37:
{
console.info("case 37 start")
let tmp1 = data.readDoubleArray()
let result = reply.writeDoubleArray(tmp1)
return true
}
case 38:
{
console.info("case 38 start")
let tmp1 = data.readBooleanArray()
let result = reply.writeBooleanArray(tmp1)
return true
}
case 39:
{
console.info("case 39 start")
let tmp1 = data.readCharArray()
let result = reply.writeCharArray(tmp1)
return true
}
case 40:
{
console.info("case 40 start")
let tmp1 = data.readStringArray()
let result = reply.writeStringArray(tmp1)
return true
}
default:
this.onRemoteRequest(code, data, reply, option)
}
......@@ -720,6 +776,1503 @@ export default function actsRpcClientJsTest() {
}
}
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_00100
* @tc.name Call the writeinterfacetoken interface, write the interface descriptor, and read interfacetoken
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_00100", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_00100---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var token = "hello ruan zong xian";
data.writeInterfaceToken(token);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_INTERFACETOKEN, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
expect(result.reply.readInterfaceToken()).assertEqual(token);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_00100---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_00200
* @tc.name The writeInterfaceToken interface is looping, the interface descriptor is written, and the
InterfaceToken is read
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_00200", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_00200---------------------------");
try{
for (let i = 0; i < 5;i++){
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
let token = "hello ruan zong xian";
data.writeInterfaceToken(token);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_INTERFACETOKEN, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
expect(result.reply.readInterfaceToken()).assertEqual(token);
});
data.reclaim();
reply.reclaim();
}
} catch (error) {
expect(error == null).assertTrue();
}
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_00200---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_00300
* @tc.name Call the WriteInterfaceToken interface, write the maximum length interface descriptor, and read
the InterfaceToken
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_00300", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_00300---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var token = "";
for(let i = 0; i < (40*K - 1); i++){
token += 'a';
}
data.writeInterfaceToken(token);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_INTERFACETOKEN, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
expect(result.reply.readInterfaceToken()).assertEqual(token);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_00300---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_00400
* @tc.name The WriteInterfaceToken interface is called, the exceeding-length interface descriptor is written,
and the InterfaceToken is read
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_00400", 0, async function(){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_00400---------------------------");
try{
var data = rpc.MessageSequence.create();
var token = "";
for(let i = 0; i < 40*K; i++){
token += 'a';
}
data.writeInterfaceToken(token);
} catch (error) {
let errCode = `${rpc.ErrorCode.WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR}`;
expect(error.code != errCode).assertTrue();
expect(error.message != null).assertTrue();
}
data.reclaim();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_00400---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_00500
* @tc.name Call the writeinterfacetoken interface to write a non string interface descriptor
and read interfacetoken
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_00500", 0, async function(){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_00500---------------------------");
try{
var data = rpc.MessageSequence.create();
var token = 123;
data.writeInterfaceToken(token);
} catch (error) {
let errCode = `${rpc.ErrorCode.WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR}`;
expect(error.code != errCode).assertTrue();
expect(error.message != null).assertTrue();
}
data.reclaim();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_00500---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_00600
* @tc.name Call the writeshortarray interface, write the array to the MessageSequence instance,
* and call readshortarray to read the data
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_00600", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_00600---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var wShortArryData = [-1, 0, 1];
data.writeShortArray(wShortArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_SHORTARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
assertArrayElementEqual(result.reply.readShortArray(),wShortArryData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_00600---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_00700
* @tc.name Call the writeshortarray interface, write the short integer array to the MessageSequence instance,
* and call readshortarray (datain: number []) to read the data
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_00700", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_00700---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var wShortArryData = [];
for(let i=0;i<(50*1024 - 1);i++){
wShortArryData[i] = 1;
}
data.writeShortArray(wShortArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_SHORTARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
var rShortArryData =[];
result.reply.readShortArray(rShortArryData);
assertArrayElementEqual(rShortArryData,wShortArryData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_00700---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_00800
* @tc.name Writeshortarray interface, boundary value verification
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_00800", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_00800---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var wShortArryData = [-32768, 0, 1, 2, 32767];
data.writeShortArray(wShortArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_SHORTARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
assertArrayElementEqual(result.reply.readShortArray(),wShortArryData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_00800---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_00900
* @tc.name Writeshortarray interface, illegal value validation
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_00900", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_00900---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var eShortArryData = [-32769, 32768];
data.writeShortArray(eShortArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_SHORTARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
var erShortArryData = [32767, -32768];
assertArrayElementEqual(result.reply.readShortArray(),erShortArryData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_00900---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_01000
* @tc.name Writeshortarray interface, transmission length verification
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_01000", 0, async function(){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_01000---------------------------");
try{
var data = rpc.MessageSequence.create();
var eShortArryData = [];
for(let i=0;i<50*K;i++){
eShortArryData[i] = 1;
};
data.writeShortArray(eShortArryData);
} catch (error) {
let errCode = `${rpc.ErrorCode.WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR}`;
expect(error.code != errCode).assertTrue();
expect(error.message != null).assertTrue();
}
data.reclaim();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_01000---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_01100
* @tc.name Call the writelongarray interface, write the long integer array to the MessageSequence instance,
* and call readlongarray to read the data
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_01100", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_01100---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var wLongArryData = [3276826, 123456, 9999999];
data.writeLongArray(wLongArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_LONGARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
assertArrayElementEqual(result.reply.readLongArray(),wLongArryData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_01100---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_01200
* @tc.name Call the writelongarray interface, write the long integer array to the MessageSequence instance,
* and call readlongarray (datain: number []) to read the data
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_01200", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_01200---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var wLongArryData = [];
for(let i=0;i<(25*K - 1);i++){
wLongArryData[i] = 11;
};
data.writeLongArray(wLongArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_LONGARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
var rLongArryData = [];
result.reply.readLongArray(rLongArryData);
assertArrayElementEqual(rLongArryData,wLongArryData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_01200---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_01300
* @tc.name Writelongarray interface, boundary value verification
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_01300", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_01300---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var wLongArryData = [-9007199254740992, 0, 1, 2, 9007199254740991];
data.writeLongArray(wLongArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_LONGARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
var rLongArryData = [];
result.reply.readLongArray(rLongArryData);
assertArrayElementEqual(rLongArryData,wLongArryData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_01300---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_01400
* @tc.name Writelongarray interface, long type precision verification
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_01400", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_01400---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var wLongArryData = [-9999999999999999, 9999999999999999];
data.writeLongArray(wLongArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_LONGARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
var rLongArryData = result.reply.readLongArray();
let newlongdata = [-10000000000000000,10000000000000000];
expect(rLongArryData[0]).assertEqual(newlongdata[0]);
expect(rLongArryData[1]).assertEqual(newlongdata[1]);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_01400---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_01500
* @tc.name Writelongarray Indicates an interface for verifying the input length
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_01500", 0, async function(){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_01500---------------------------");
try{
var data = rpc.MessageSequence.create();
var wLongArryData = [];
for(let i=0;i<25*K;i++){
wLongArryData[i] = 11;
};
data.writeLongArray(wLongArryData);
} catch (error) {
let errCode = `${rpc.ErrorCode.WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR}`;
expect(error.code != errCode).assertTrue();
expect(error.message != null).assertTrue();
}
data.reclaim();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_01500---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_01600
* @tc.name Call the writedoublearray interface, write the array to the MessageSequence instance,
* and call readdoublearra to read the data
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_01600", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_01600---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var wDoubleArryData = [1.2, 235.67, 99.76];
data.writeDoubleArray(wDoubleArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_DOUBLEARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
assertArrayElementEqual(result.reply.readDoubleArray(), wDoubleArryData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_01600---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_01700
* @tc.name Call the writedoublearray interface, write the array to the MessageSequence instance,
* and call readdoublearra (datain: number []) to read the data
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_01700", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_01700---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var wDoubleArryData = [];
for(let i = 0;i < (25*K - 1);i++){
wDoubleArryData[i] = 11.1;
};
data.writeDoubleArray(wDoubleArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_DOUBLEARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
var rDoubleArryData = [];
result.reply.readDoubleArray(rDoubleArryData);
assertArrayElementEqual(rDoubleArryData, wDoubleArryData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_01700---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_01800
* @tc.name Writedoublearray interface, boundary value verification
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_01800", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_01800---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var wDoubleArryData = [4.9E-324, 235.67, 1.79E+308];
data.writeDoubleArray(wDoubleArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_DOUBLEARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
assertArrayElementEqual(result.reply.readDoubleArray(), wDoubleArryData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_01800---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_01900
* @tc.name Writedoublearray interface, illegal value validation
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_01900", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_01900---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var eDoubleArryData = [(4.9E-324) - 1, (1.79E+308) + 1];
data.writeDoubleArray(eDoubleArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_DOUBLEARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
var rDoubleArryData = result.reply.readDoubleArray();
expect(rDoubleArryData[0]).assertEqual(-1);
expect(rDoubleArryData[1]).assertEqual(1.79e+308);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_01900---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_02000
* @tc.name Writedoublearray interface, Out-of-bounds value verification
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_02000", 0, async function(){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_02000---------------------------");
try{
var data = rpc.MessageSequence.create();
var eDoubleArryData = [];
for(let i = 0;i < 25*K;i++){
eDoubleArryData[i] = 11.1;
}
data.writeDoubleArray(eDoubleArryData);
} catch (error) {
let errCode = `${rpc.ErrorCode.WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR}`;
expect(error.code != errCode).assertTrue();
expect(error.message != null).assertTrue();
}
data.reclaim();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_02000---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_02100
* @tc.name Call the writebooleanarray interface, write the array to the MessageSequence instance,
* and call readbooleanarray to read the data
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_02100", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_02100---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var wBooleanArryData = [true, false, false];
data.writeBooleanArray(wBooleanArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_BOOLEANARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
assertArrayElementEqual(result.reply.readBooleanArray(),wBooleanArryData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_02100---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_02200
* @tc.name Call the writebooleanarray interface, write the array to the MessageSequence instance,
* and call readbooleanarray (datain: number []) to read the data
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_02200", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_02200---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var wBooleanArryData = [];
for (let i=0;i<(50*K - 1);i++){
if (i % 2 == 0){
wBooleanArryData[i] = false;
}else {
wBooleanArryData[i] = true;
}
}
data.writeBooleanArray(wBooleanArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_BOOLEANARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
var rBooleanArryData = [];
result.reply.readBooleanArray(rBooleanArryData);
assertArrayElementEqual(rBooleanArryData,wBooleanArryData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_02200---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_02300
* @tc.name Writebooleanarray interface, illegal value validation
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_02300", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_02300---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var errorBooleanArryData = [true, 9, false];
data.writeBooleanArray(errorBooleanArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_BOOLEANARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
var eCharArrayData = [true, false, false];
assertArrayElementEqual(result.reply.readBooleanArray(),eCharArrayData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_02300---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_02400
* @tc.name Writebooleanarray Interface for length verification of input parameters
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_02400", 0, async function(){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_02400---------------------------");
try{
var data = rpc.MessageSequence.create();
var wBooleanArryData = [];
for (let i=0;i<50*K;i++){
if (i % 2 == 0){
wBooleanArryData[i] = false;
}else {
wBooleanArryData[i] = true;
};
}
data.writeBooleanArray(wBooleanArryData);
} catch (error) {
let errCode = `${rpc.ErrorCode.WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR}`;
expect(error.code != errCode).assertTrue();
expect(error.message != null).assertTrue();
}
data.reclaim();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_02400---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_02500
* @tc.name Call the writechararray interface, write the array to the MessageSequence instance,
* and call readchararray to read the data
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_02500", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_02500---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var wCharArryData = [0,97,255];
data.writeCharArray(wCharArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_CHARARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
assertArrayElementEqual(result.reply.readCharArray(),wCharArryData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_02500---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_02600
* @tc.name Call the writechararray interface, write the array to the MessageSequence instance,
* and call readchararray (datain: number []) to read the data
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_02600", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_02600---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var wCharArryData = [];
for(let i=0;i<(50*K - 1);i++){
wCharArryData[i] = 96;
};
data.writeCharArray(wCharArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_CHARARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
var rCharArryData = [];
result.reply.readCharArray(rCharArryData);
assertArrayElementEqual(rCharArryData,wCharArryData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_02600---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_02700
* @tc.name Writechararray interface, illegal value validation
* @tc.desc Function test
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_02700", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_02700---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var errorCharArryData = [96, 'asfgdgdtu', 97];
data.writeCharArray(errorCharArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_CHARARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
let eCharArrayData = [96, 0, 97];
let readchardata = result.reply.readCharArray();
assertArrayElementEqual(readchardata, eCharArrayData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_02700---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_02800
* @tc.name Writechararray Indicates the length of an interface input parameter
* @tc.desc Function test
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_02800", 0, async function(){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_02800---------------------------");
try{
var data = rpc.MessageSequence.create();
var errorCharArryData = [];
for(let i=0;i<50*K;i++){
errorCharArryData[i] = 96;
};
data.writeCharArray(errorCharArryData);
} catch (error) {
console.info("SUB_Softbus_IPC_Compatibility_MessageSequence_02800: erroe" + error)
let errCode = `${rpc.ErrorCode.WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR}`;
expect(error.code != errCode).assertTrue();
expect(error.message != null).assertTrue();
}
data.reclaim();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_02800---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_02900
* @tc.name Call the writestringarray interface, write the array to the MessageSequence instance,
* and call readstringarray (datain: number []) to read the data
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_02900", 0, async function(){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_02900---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var wStringArryData = ['abc', 'hello', 'beauty'];
data.writeStringArray(wStringArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_STRINGARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
assertArrayElementEqual(result.reply.readStringArray(),wStringArryData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_02900---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_03000
* @tc.name Call the writestringarray interface, write the array to the MessageSequence instance,
* and call readstringarray() to read the data
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_03000", 0, async function(){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_03000---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var wStringArryData = [];
for (let i = 0;i < (10*K - 1);i++){
wStringArryData[i] = "heddSDF";
};
data.writeStringArray(wStringArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_STRINGARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
var rStringArryData = [];
result.reply.readStringArray(rStringArryData);
assertArrayElementEqual(rStringArryData,wStringArryData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_03000---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_03100
* @tc.name Writestringarray interface, illegal value validation
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_03100", 0, async function(){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_03100---------------------------");
try{
var data = rpc.MessageSequence.create();
var errorStringArryData = ['abc' , 123, 'beauty'];
data.writeStringArray(errorStringArryData);
} catch (error) {
let errCode = `${rpc.ErrorCode.WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR}`;
expect(error.code != errCode).assertTrue();
expect(error.message != null).assertTrue();
}
data.reclaim();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_03100---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_03200
* @tc.name writeStringArray Interface for length verification of input parameters
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_03200", 0, async function(){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_03200---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var wStringArryData = [];
for (let i = 0;i < 10 * K;i++){
wStringArryData[i] = "heddSDF";
}
data.writeStringArray(wStringArryData);
} catch (error) {
expect(error != null).assertTrue();
}
data.reclaim();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_03200---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_03300
* @tc.name Call the writebytearray interface, write the array to the MessageSequence instance,
* and call readbytearray to read the data
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_03300", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_03300---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
let ByteArrayVar = [1, 2, 3, 4, 5];
data.writeByteArray(ByteArrayVar);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_BYTEARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
assertArrayElementEqual(result.reply.readByteArray(),ByteArrayVar);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_03300---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_03400
* @tc.name Call the writebytearray interface, write the array to the MessageSequence instance,
* and call readbytearray (datain: number []) to read the data
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_03400", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_03400---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
let ByteArrayVar = [-128, 0, 1, 2, 127];
data.writeByteArray(ByteArrayVar);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_BYTEARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
var newArr = new Array(5);
result.reply.readByteArray(newArr);
assertArrayElementEqual(ByteArrayVar,newArr);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_03400---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_03500
* @tc.name Writebytearray interface, boundary value verification
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_03500", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_03500---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
let ByteArrayVar = [];
for (let i=0;i<(40*K - 1);i++){
ByteArrayVar[i] = 1;
}
data.writeByteArray(ByteArrayVar);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_BYTEARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
var newArr = new Array(5)
result.reply.readByteArray(newArr);
assertArrayElementEqual(newArr,ByteArrayVar);
});
data.reclaim();
reply.reclaim();
done();
} catch (error) {
expect(error == null).assertTrue();
}
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_03500---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_03600
* @tc.name Writebytearray interface, illegal value validation
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_03600", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_03600---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
let ByteArrayVar = [-129, 0, 1, 2, 128];
data.writeByteArray(ByteArrayVar);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_BYTEARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
var shortArryDataReply = result.reply.readByteArray();
expect(shortArryDataReply[0] == 127).assertTrue();
expect(shortArryDataReply[1] == ByteArrayVar[1]).assertTrue();
expect(shortArryDataReply[2] == ByteArrayVar[2]).assertTrue();
expect(shortArryDataReply[3] == ByteArrayVar[3]).assertTrue();
expect(shortArryDataReply[4] == -128).assertTrue();
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_03600---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_03700
* @tc.name Writebytearray Interface，input parameter length verification
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_03700", 0, async function(){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_03700---------------------------");
try{
var data = rpc.MessageSequence.create();
let ByteArrayVar = [];
for (let i=0;i<40*K;i++){
ByteArrayVar[i] = 1;
}
data.writeByteArray(ByteArrayVar)
data.reclaim();
} catch (error) {
let errCode = `${rpc.ErrorCode.WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR}`;
expect(error.code != errCode).assertTrue();
expect(error.message != null).assertTrue();
}
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_03700---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_03800
* @tc.name Call the writeintarray interface, write the array to the MessageSequence instance,
* and call readintarray to read the data
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_03800", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_03800---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var intArryData = [100, 111, 112];
data.writeIntArray(intArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_INTARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
assertArrayElementEqual(result.reply.readIntArray(),intArryData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_03800---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_03900
* @tc.name Call the writeintarray interface, write the array to the MessageSequence instance,
* and call readintarray (datain: number []) to read the data
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_03900", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_03900---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var intArryData = [];
for (let i=0;i<(50*K - 1);i++){
intArryData[i] = 1;
};
data.writeIntArray(intArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_INTARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
var newArr = new Array(3)
result.reply.readIntArray(newArr);
assertArrayElementEqual(newArr,intArryData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_03900---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_04000
* @tc.name Writeintarray interface, boundary value verification
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_04000", 0, async function(){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_04000---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var intArryData = [-2147483648, 0, 1, 2, 2147483647];
data.writeIntArray(intArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_INTARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
assertArrayElementEqual(result.reply.readIntArray(),intArryData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_04000---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_04100
* @tc.name Writeintarray interface, illegal value verification
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_04100", 0, async function(){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_04100---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var intArryData = [-2147483649, 0, 1, 2, 2147483648];
data.writeIntArray(intArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_INTARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
var shortArryDataReply = result.reply.readIntArray();
expect(shortArryDataReply[0] == 2147483647).assertTrue();
expect(shortArryDataReply[1] == intArryData[1]).assertTrue();
expect(shortArryDataReply[2] == intArryData[2]).assertTrue();
expect(shortArryDataReply[3] == intArryData[3]).assertTrue();
expect(shortArryDataReply[4] == -2147483648).assertTrue();
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_04100---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_04200
* @tc.name Writeintarray interface, input parameter length verification
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_04200", 0, async function(){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_04200---------------------------");
try{
var data = rpc.MessageSequence.create();
var intArryData = [];
for (let i=0;i<50*K;i++){
intArryData[i] = 1;
}
data.writeIntArray(intArryData);
} catch (error) {
let errCode = `${rpc.ErrorCode.WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR}`;
expect(error.code != errCode).assertTrue();
expect(error.message != null).assertTrue();
}
data.reclaim();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_04200---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_04300
* @tc.name Call the writefloatarray interface, write the array to the MessageSequence instance,
* and call readfloatarray to read the data
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_04300", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_04300---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var floatArryData = [1.2, 1.3, 1.4];
data.writeFloatArray(floatArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_FLOATARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
assertArrayElementEqual(result.reply.readFloatArray(),floatArryData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_04300---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_04400
* @tc.name Call the writefloatarray interface, write the array to the MessageSequence instance,
* and call readfloatarray (datain: number []) to read the data
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_04400", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_04400---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var floatArryData = [1.4E-45, 1.3, 3.4028235E38];
data.writeFloatArray(floatArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_FLOATARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
var newArr = new Array(3)
result.reply.readFloatArray(newArr);
assertArrayElementEqual(newArr,floatArryData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_04400---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_04500
* @tc.name Writefloatarray interface, boundary value verification
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_04500", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_04500---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var floatArryData = [(1.4E-45) - 1, 1.3, (3.4028235E38) + 1];
data.writeFloatArray(floatArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_FLOATARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
var newArr = result.reply.readFloatArray();
expect(newArr[0]).assertEqual(-1);
expect(newArr[1]).assertEqual(1.3);
expect(newArr[2]).assertEqual(3.4028235e+38);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_04500---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_04600
* @tc.name Writefloatarray interface, boundary value verification
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_04600", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_04600---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var floatArryData = [];
for (let i = 0;i < (25*K - 1);i++){
floatArryData[i] = 1.1;
};
data.writeFloatArray(floatArryData);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_FLOATARRAY, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
assertArrayElementEqual(result.reply.readFloatArray(),floatArryData);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_04600---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_04700
* @tc.name Writefloatarray interface, Longest array verification
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_04700", 0, async function(){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_04700---------------------------");
try{
var data = rpc.MessageSequence.create();
var floatArryData = [];
for (let i = 0;i < (25*K);i++){
floatArryData[i] = 1.1;
};
data.writeFloatArray(floatArryData);
} catch (error) {
let errCode = `${rpc.ErrorCode.WRITE_DATA_TO_MESSAGE_SEQUENCE_ERROR}`;
expect(error.code != errCode).assertTrue();
expect(error.message != null).assertTrue();
}
data.reclaim();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_04700---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_04800
* @tc.name Call the writeShort interface to write the short integer data to the MessageSequence instance,
* and call readshort to read the data
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_04800", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_04800---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
var short = 8;
data.writeShort(short);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_SHORT, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
assertArrayElementEqual(result.reply.readShort(),short);
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_04800---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_04900
* @tc.name WriteShort interface, boundary value verification
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_04900", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_04900---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
data.writeShort(-32768);
data.writeShort(0);
data.writeShort(1);
data.writeShort(2);
data.writeShort(32767);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_SHORT_MULTI, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
expect(result.reply.readShort() == -32768).assertTrue();
expect(result.reply.readShort() == 0).assertTrue();
expect(result.reply.readShort() == 1).assertTrue();
expect(result.reply.readShort() == 2).assertTrue();
expect(result.reply.readShort() == 32767).assertTrue();
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_04900---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_05000
* @tc.name WriteShort interface, Boundary value minimum value out of bounds verification
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_05000", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_05000---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
data.writeShort(-32769);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_SHORT_MULTI, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
expect(result.reply.readShort() == 32767).assertTrue();
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_05000---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageSequence_05100
* @tc.name WriteShort interface, Boundary value maximum value out of bounds verification
* @tc.desc Function test
* @tc.level 0
*/
it("SUB_Softbus_IPC_Compatibility_MessageSequence_05100", 0, async function(done){
console.info("---------------------start SUB_Softbus_IPC_Compatibility_MessageSequence_05100---------------------------");
try{
var data = rpc.MessageSequence.create();
var reply = rpc.MessageSequence.create();
var option = new rpc.MessageOption();
data.writeShort(32768);
expect(gIRemoteObject != undefined).assertTrue();
await gIRemoteObject.sendMessageRequest(CODE_WRITE_SHORT_MULTI, data, reply, option).then((result) => {
expect(result.errCode).assertEqual(0);
expect(result.reply.readShort() == -32768).assertTrue();
});
} catch (error) {
expect(error == null).assertTrue();
}
data.reclaim();
reply.reclaim();
done();
console.info("---------------------end SUB_Softbus_IPC_Compatibility_MessageSequence_05100---------------------------");
});
/*
* @tc.number SUB_Softbus_IPC_Compatibility_MessageParcel_00100
* @tc.name Call the writeinterfacetoken interface, write the interface descriptor, and read interfacetoken
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或