diff --git a/base/test/benchmarktest/BUILD.gn b/base/test/benchmarktest/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..60bf82b61bc32ef1407f49f8ac472971a979f346 --- /dev/null +++ b/base/test/benchmarktest/BUILD.gn @@ -0,0 +1,23 @@ +# Copyright (c) 2023 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +group("benchmarktest") { + testonly = true + deps = [] + deps += [ + # deps file + "parcel_benchmark_test:ParcelTest", + "refbase_benchmark_test:RefbaseTest", + "timer_benchmark_test:TimerTest", + ] +} diff --git a/base/test/benchmarktest/README.md b/base/test/benchmarktest/README.md new file mode 100644 index 0000000000000000000000000000000000000000..9b749a1b5a8fe8c89ade1efa71c95b37f2fd2335 --- /dev/null +++ b/base/test/benchmarktest/README.md @@ -0,0 +1,105 @@ +# Benchmark测试 + +Benchmarking is an activity of measuring and evaluating software performance indicators, which can establish a known +performance level (called a baseline) at a certain time through benchmarking. +When the software and hardware environment of the system changes, another benchmarking is conducted to determine the +impact of those changes on performance. This is the most common use of benchmark testing, with other uses including +determining performance limits at certain load levels, managing changes in systems or environments, +and identifying conditions that may cause performance issues. + +## 目录结构 + +``` +commonlibrary/c_utils/base/test +├─ benchmarktest +│ ├── ashemem_benchmark_test # Anonymous Shared Memory API test +│ ├── datetime_benchmark_test # datetime API test +│ ├── directory_benchmark_test # directory API test +│ ├── event_benchmark_test # event API test +│ ├── file_benchmark_test # file API test +│ ├── mapped_benchmark_test # mapped API test +│ ├── observer_benchmark_test # observer API test +│ ├── parcel_benchmark_test # parcel API test +│ ├── refbase_benchmark_test # refbase API test +│ ├── rwlock_benchmark_test # rwlock API test +│ ├── safe_block_queue_benchmark_test # safe blocke queue API test +│ ├── safe_block_queue_tracking_benchmark_test +│ ├── safe_map_benchmark_test # safe map API test +│ ├── safe_queue_benchmark_test # safe queue API test +│ ├── singleton_benchmark_test # singleton API test +│ ├── sorted_vector_benchmark_test # sortedvector API test +│ ├── string_benchmark_test # string API test +│ ├── thread_benchmark_test # thread API test +│ ├── thread_pool_benchmark_test # threadpool API test +│ ├── timer_benchmark_test # timer API test +│ ├── unique_fd_benchmark_test # uniquefd API test +│ ├── assert.h +│ ├── BUILD.gn +│ └── log.h +``` + +## Build +### Build Component +``` +./build.sh --product-name rk3568 --build-target c_utils +``` + +### Build testsuits +``` +./build.sh --product-name rk3568 --build-target commonlibrary/c_utils/base/test/benchmarktest/ +``` + +### output +``` +/out/rk3568/tests/benchmark +``` + +## Test environment setup(windows) +### Test dir + +``` + +Test +├── developer_test # test framework(git clone https://gitee.com/openharmony/testfwk_developer_test.git) +│ ├── aw +│ ├── config +│ │ ├── framework_config.xml #config the benchmark timeout field to "900" +│ │ └── user_config.xml # The SN field needs to be configured with the development board serial numbe + test_cases field needs to be configured with the compiled test case directory +│ ├── examples +│ ├── src +│ ├── third_party +│ ├── reports #test result +│ ├── BUILD.gn +│ ├── start.bat # Windwos +│ └── start.sh # Linux +├── testcase # cp -r /out/rk3568/tests/benchmark/ XXX/testcase/ +└── xdevice # (git clone https://gitee.com/openharmony/testfwk_xdevice.git) + +``` +## Execute test cases(windows) +### start test framework + start.bat + +### Select product type + default : rk3568 + + +### Execute(eg:parcel) + eg：run -t BENCHMARK -ts ParcelTest + + Instructions for executing command parameters： + ``` + -t [TESTTYPE]: Specify test case type，such as UT，MST，ST，PERF，FUZZ，BENCHMARK。（Required parameters） + -ts [TESTSUITE]: Specify test suilts，can be used independently。 + ``` + +### Test report log +After executing the test instructions, the console will automatically generate test results. +If you need a detailed test report, you can search in the corresponding data document. + +#### Test results +The root path of the test result output is as follows： +``` +Test/developer_test/reports/xxxx_xx_xx_xx_xx_xx + diff --git a/base/test/benchmarktest/README_zh.md b/base/test/benchmarktest/README_zh.md new file mode 100644 index 0000000000000000000000000000000000000000..79307114eb94f1bf5209dbc10969df13b6e0ff38 --- /dev/null +++ b/base/test/benchmarktest/README_zh.md @@ -0,0 +1,105 @@ +# Benchmark测试 + +基准测试（benchmarking）是一种测量和评估软件性能指标的活动，可以在某个时候通过基准测试建立一个已知的性能水平（称为基准线）， +当系统的软硬件环境发生变化之后再进行一次基准测试以确定那些变化对性能的影响。这是基准测试最常见的用途，其他用途包括测定某种负载水平下的性能极限、 +管理系统或环境的变化、发现可能导致性能问题的条件等。 + +## 目录结构 + +``` +commonlibrary/c_utils/base/test +├─ benchmarktest +│ ├── ashemem_benchmark_test # 匿名共享内存接口性能测试 +│ ├── datetime_benchmark_test # 日期与时间接口性能测试 +│ ├── directory_benchmark_test # 文件与目录接口性能测试 +│ ├── event_benchmark_test # 事件处理系统接口性能测试 +│ ├── file_benchmark_test # 读写文件接口性能测试 +│ ├── mapped_benchmark_test # 文件映射接口性能测试 +│ ├── observer_benchmark_test # 观察者模式接口性能测试 +│ ├── parcel_benchmark_test # 使用Parcel作为数据容器接口性能测试 +│ ├── refbase_benchmark_test # 智能指针管理动态分配内存对象接口性能测试 +│ ├── rwlock_benchmark_test # 读写锁接口性能测试 +│ ├── safe_block_queue_benchmark_test # 线程安全阻塞队列接口性能测试 +│ ├── safe_block_queue_tracking_benchmark_test +│ ├── safe_map_benchmark_test # 线程安全Map接口性能测试 +│ ├── safe_queue_benchmark_test # 线程安全栈与队列接口性能测试 +│ ├── singleton_benchmark_test # 单例模式接口性能测试 +│ ├── sorted_vector_benchmark_test # 有序Vector接口性能测试 +│ ├── string_benchmark_test # 字符串处理接口性能测试 +│ ├── thread_benchmark_test # 强化线程能力接口性能测试 +│ ├── thread_pool_benchmark_test # 线程池接口性能测试 +│ ├── timer_benchmark_test # 定时器接口性能测试 +│ ├── unique_fd_benchmark_test # 管理、传递文件描述符接口性能测试 +│ ├── assert.h +│ ├── BUILD.gn +│ └── log.h +``` + +## 编译构建 +### 编译部件 +``` +./build.sh --product-name rk3568 --build-target c_utils +``` + +### 测试套编译 +``` +./build.sh --product-name rk3568 --build-target commonlibrary/c_utils/base/test/benchmarktest/ +``` + +### 测试套生成路径 +``` +/out/rk3568/tests/benchmark +``` + +### 编译静态库 +``` +./build.sh --product-name rk3568 --build-target commonlibrary/c_utils/base:utilsbase +``` + +## 测试环境构建(windows) +### 测试目录构建 + +``` + +Test +├── developer_test # 开发者自测试框架 git clone https://gitee.com/openharmony/testfwk_developer_test.git +│ ├── aw +│ ├── config # 测试框架配置 +│ │ ├── framework_config.xml #配置benchmark timeout字段为"900" +│ │ └── user_config.xml #sn字段需要配置开发板序列号 test_cases字段需要配置编译生成的测试用例目录 +│ ├── examples +│ ├── src +│ ├── third_party +│ ├── reports # 测试结果报告 +│ ├── BUILD.gn +│ ├── start.bat # Windows +│ └── start.sh # Linux +├── testcase # cp -r /out/rk3568/tests/benchmark/ XXX/testcase/ +└── xdevice # git clone https://gitee.com/openharmony/testfwk_xdevice.git + +``` +## 执行测试用例(windows) +### 启动测试框架 + 执行start.bat + +### 选择产品形态 + 默认选择为rk3568 + + +### 执行测试用例(以parcel为例) + eg：run -t BENCHMARK -ts ParcelTest + + 执行命令参数说明： + ``` + -t [TESTTYPE]: 指定测试用例类型，有UT，MST，ST，PERF，FUZZ，BENCHMARK等。（必选参数） + -ts [TESTSUITE]: 指定测试套，可独立使用。 + ``` + +### 测试报告日志 +当执行完测试指令，控制台会自动生成测试结果，若需要详细测试报告您可在相应的数据文档中进行查找。 + +#### 测试结果 +测试结果输出根路径如下： +``` +Test/developer_test/reports/xxxx_xx_xx_xx_xx_xx + diff --git a/base/test/benchmarktest/assert.h b/base/test/benchmarktest/assert.h new file mode 100644 index 0000000000000000000000000000000000000000..e9ebc2ab33516b6a10d74ec4ad292a347195c832 --- /dev/null +++ b/base/test/benchmarktest/assert.h @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ASSERT_H +#define ASSERT_H + +#include + +template +void AssertEqual(const T1 &t1, const T2 &t2, const char* printInfo, benchmark::State& state) +{ + if (t1 != t2) { + state.SkipWithError(printInfo); + } +} + +template +void AssertUnequal(const T1 &t1, const T2 &t2, const char* printInfo, benchmark::State& state) +{ + if (t1 == t2) { + state.SkipWithError(printInfo); + } +} + +template +void AssertFalse(const T &t, const char* printInfo, benchmark::State& state) +{ + if (t) { + state.SkipWithError(printInfo); + } +} + +template +void AssertTrue(const T &t, const char* printInfo, benchmark::State& state) +{ + if (!t) { + state.SkipWithError(printInfo); + } +} + +template +void AssertLessThan(const T1 &t1, const T2 &t2, const char* printInfo, benchmark::State& state) +{ + if (t1 >= t2) { + state.SkipWithError(printInfo); + } +} + +template +void AssertLessThanOrEqual(const T1 &t1, const T2 &t2, const char* printInfo, benchmark::State& state) +{ + if (t1 > t2) { + state.SkipWithError(printInfo); + } +} + +template +void AssertGreaterThan(const T1 &t1, const T2 &t2, const char* printInfo, benchmark::State& state) +{ + if (t1 <= t2) { + state.SkipWithError(printInfo); + } +} + +template +void AssertGreaterThanOrEqual(const T1 &t1, const T2 &t2, const char* printInfo, benchmark::State& state) +{ + if (t1 < t2) { + state.SkipWithError(printInfo); + } +} + +void AssertStringEqual(const char* str1, const char* str2, const char* printInfo, benchmark::State& state) +{ + if (strcmp(str1, str2) != 0) { + state.SkipWithError(printInfo); + } +} +#endif \ No newline at end of file diff --git a/base/test/benchmarktest/log.h b/base/test/benchmarktest/log.h new file mode 100644 index 0000000000000000000000000000000000000000..19c2e7881ef792f5fca09de05854d92a5cf21e04 --- /dev/null +++ b/base/test/benchmarktest/log.h @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef LOG_H +#define LOG_H + +#include "hilog_base/log_base.h" + +constexpr LogType BENCHMARK_LOG_TYPE = LOG_CORE; +constexpr unsigned int BENCHMARK_LOG_DOMAIN = 0xD003D00; +constexpr const char *BENCHMARK_LOG_TAG = "benchmark_test"; + +#define BENCHMARK_LOGF(...) \ + (void)HiLogBasePrint(BENCHMARK_LOG_TYPE, LOG_FATAL, BENCHMARK_LOG_DOMAIN, BENCHMARK_LOG_TAG, __VA_ARGS__) +#define BENCHMARK_LOGE(...) \ + (void)HiLogBasePrint(BENCHMARK_LOG_TYPE, LOG_ERROR, BENCHMARK_LOG_DOMAIN, BENCHMARK_LOG_TAG, __VA_ARGS__) +#define BENCHMARK_LOGW(...) \ + (void)HiLogBasePrint(BENCHMARK_LOG_TYPE, LOG_WARN, BENCHMARK_LOG_DOMAIN, BENCHMARK_LOG_TAG, __VA_ARGS__) +#define BENCHMARK_LOGI(...) \ + (void)HiLogBasePrint(BENCHMARK_LOG_TYPE, LOG_INFO, BENCHMARK_LOG_DOMAIN, BENCHMARK_LOG_TAG, __VA_ARGS__) +#define BENCHMARK_LOGD(...) \ + (void)HiLogBasePrint(BENCHMARK_LOG_TYPE, LOG_DEBUG, BENCHMARK_LOG_DOMAIN, BENCHMARK_LOG_TAG, __VA_ARGS__) + +#endif // LOG_H diff --git a/base/test/benchmarktest/parcel_benchmark_test/BUILD.gn b/base/test/benchmarktest/parcel_benchmark_test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..c8d499b4b7e2d556a1e54899af3f08d0fb4e6654 --- /dev/null +++ b/base/test/benchmarktest/parcel_benchmark_test/BUILD.gn @@ -0,0 +1,35 @@ +# Copyright (c) 2023 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") + +module_output_path = "commonlibrary_c_utils/parcel" + +ohos_benchmarktest("ParcelTest") { + module_out_path = module_output_path + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + sources = [ "parcel_benchmark_test.cpp" ] + + deps = [ "//third_party/benchmark:benchmark" ] + + external_deps = [ + "c_utils:utils", + "hilog:libhilog_base", + ] +} diff --git a/base/test/benchmarktest/parcel_benchmark_test/parcel_benchmark_test.cpp b/base/test/benchmarktest/parcel_benchmark_test/parcel_benchmark_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5703d724259bd26b193670181beedf0befbf9045 --- /dev/null +++ b/base/test/benchmarktest/parcel_benchmark_test/parcel_benchmark_test.cpp @@ -0,0 +1,2561 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include "directory_ex.h" +#include "parcel.h" +#include "refbase.h" +#include "securec.h" +#include "../log.h" +#include "../assert.h" +using namespace std; + +namespace OHOS { +namespace { + +static constexpr size_t DEFAULT_CPACITY = 204800; // 200K +static constexpr size_t CAPACITY_THRESHOLD = 4096; // 4k +static constexpr int32_t COMPARE_STRING_RESULT = 0; +static constexpr size_t DATA_CAPACITY_INIT_SIZE = 0; +static constexpr size_t DATA_OFFSETS_INIT_SIZE = 0; +static constexpr size_t DATA_READBYTES_INIT_SIZE = 0; +static constexpr size_t REWIND_INIT_VALUE = 0; +static constexpr size_t REWINDWRITE003_VECTOR_LENGTH = 5; +static constexpr int32_t WRITE_AND_CMP_INT32_VALUE = 5; + +#define PARCEL_TEST_CHAR_ARRAY_SIZE 48 +#define PARCEL_TEST1_CHAR_ARRAY_SIZE 205780 +#define PARCEL_WRITEPOINTER_CHAR_ARRAY_SIZE 128 +#define PARCEL_INJECTOFFSETS_CHAR_ARRAY_SIZE 256 + +class BenchmarkParcelTest : public benchmark::Fixture { +public: + BenchmarkParcelTest() + { + Iterations(iterations); + Repetitions(repetitions); + ReportAggregatesOnly(); + } + + ~BenchmarkParcelTest() override = default; + void SetUp(const ::benchmark::State& state) override + { + } + + void TearDown(const ::benchmark::State& state) override + { + } + +protected: + const int32_t repetitions = 3; + const int32_t iterations = 1000; +}; + + +class RemoteObject : public virtual Parcelable { +public: + RemoteObject() + { + asRemote_ = true; + } + bool Marshalling(Parcel &parcel) const override; + static sptr Unmarshalling(Parcel &parcel); + static bool Marshalling(Parcel &parcel, const sptr &object); +}; + +bool RemoteObject::Marshalling(Parcel &parcel, const sptr &object) +{ + return false; +} + +bool RemoteObject::Marshalling(Parcel &parcel) const +{ + BENCHMARK_LOGD("ParcelTest (bool RemoteObject::Marshalling(Parcel &parcel) const) is called."); + parcel_flat_binder_object flat; + flat.hdr.type = 0xff; + flat.flags = 0x7f; + flat.binder = 0; + flat.handle = (uint32_t)(-1); + flat.cookie = reinterpret_cast(this); + bool status = parcel.WriteBuffer(&flat, sizeof(parcel_flat_binder_object)); + if (!status) { + return false; + } + return true; +} + +sptr RemoteObject::Unmarshalling(Parcel &parcel) +{ + BENCHMARK_LOGD("ParcelTest sptr RemoteObject::Unmarshalling(Parcel &parcel) is called."); + const uint8_t *buffer = parcel.ReadBuffer(sizeof(parcel_flat_binder_object)); + if (buffer == nullptr) { + return nullptr; + } + sptr obj = new RemoteObject(); + return obj; +} + +/*-------------------------------base data------------------------------------*/ + +struct TestData { + bool booltest; + int8_t int8test; + int16_t int16test; + int32_t int32test; + uint8_t uint8test; + uint16_t uint16test; + uint32_t uint32test; +}; + +void WriteTestData(Parcel &parcel, const struct TestData &data, benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest void WriteTestData is called."); + bool result = false; + result = parcel.WriteBool(data.booltest); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.WriteInt8(data.int8test); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.WriteInt16(data.int16test); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.WriteInt32(data.int32test); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.WriteUint8(data.uint8test); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.WriteUint16(data.uint16test); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.WriteUint32(data.uint32test); + AssertEqual(result, true, "result did not equal true as expected.", state); +} + +void WriteUnalignedTestData(Parcel &parcel, const struct TestData &data, benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest void WriteUnalignedTestData is called."); + bool result = false; + result = parcel.WriteBoolUnaligned(data.booltest); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.WriteInt8Unaligned(data.int8test); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.WriteInt16Unaligned(data.int16test); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.WriteUint8Unaligned(data.uint8test); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.WriteUint16Unaligned(data.uint16test); + AssertEqual(result, true, "result did not equal true as expected.", state); +} + +void ReadTestData(Parcel &parcel, const struct TestData &data, benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest void ReadTestData is called."); + bool readbool = parcel.ReadBool(); + AssertEqual(readbool, data.booltest, "readbool did not equal data.booltest as expected.", state); + + int8_t readint8 = parcel.ReadInt8(); + AssertEqual(readint8, data.int8test, "readint8 did not equal data.int8test as expected.", state); + + int16_t readint16 = parcel.ReadInt16(); + AssertEqual(readint16, data.int16test, "readint16 did not equal data.int16test as expected.", state); + + int32_t readint32 = parcel.ReadInt32(); + AssertEqual(readint32, data.int32test, "readint32 did not equal data.int32test as expected.", state); + + uint8_t readuint8 = parcel.ReadUint8(); + AssertEqual(readuint8, data.uint8test, "readuint8 did not equal data.uint8test as expected.", state); + + uint16_t readuint16 = parcel.ReadUint16(); + AssertEqual(readuint16, data.uint16test, "readuint16 did not equal data.uint16test as expected.", state); + + uint32_t readuint32 = parcel.ReadUint32(); + AssertEqual(readuint32, data.uint32test, "readuint32 did not equal data.uint32test as expected.", state); +} + +void ReadUnalignedTestData(Parcel &parcel, const struct TestData &data, benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest void ReadUnalignedTestData is called."); + bool readbool = parcel.ReadBoolUnaligned(); + AssertEqual(readbool, data.booltest, "readbool did not equal data.booltest as expected.", state); + + int8_t readint8; + AssertTrue(parcel.ReadInt8Unaligned(readint8), + "parcel.ReadInt8Unaligned(readint8) did not equal true as expected.", state); + AssertEqual(readint8, data.int8test, "readint8 did not equal data.int8test as expected.", state); + + int16_t readint16; + AssertTrue(parcel.ReadInt16Unaligned(readint16), + "parcel.ReadInt16Unaligned(readint16) did not equal true as expected.", state); + AssertEqual(readint16, data.int16test, "readint16 did not equal data.int16test as expected.", state); + + uint8_t readuint8; + AssertTrue(parcel.ReadUint8Unaligned(readuint8), + "parcel.ReadUint8Unaligned(readuint8) did not equal true as expected.", state); + AssertEqual(readuint8, data.uint8test, "readuint8 did not equal data.uint8test as expected.", state); + + uint16_t readuint16; + AssertTrue(parcel.ReadUint16Unaligned(readuint16), + "parcel.ReadUint16Unaligned(readuint16) did not equal true as expected.", state); + AssertEqual(readuint16, data.uint16test, "readuint16 did not equal data.uint16test as expected.", state); +} + +void ReadTestDataWithTarget(Parcel &parcel, const struct TestData &data, benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest void ReadTestDataWithTarget is called."); + bool result = false; + bool boolVal = true; + result = parcel.ReadBool(boolVal); + AssertEqual(result, true, "result did not equal true as expected.", state); + AssertEqual(boolVal, data.booltest, "boolVal did not equal data.booltest as expected.", state); + + int8_t int8Val; + result = parcel.ReadInt8(int8Val); + AssertEqual(result, true, "result did not equal true as expected.", state); + AssertEqual(int8Val, data.int8test, "int8Val did not equal data.int8test as expected.", state); + + int16_t int16Val; + result = parcel.ReadInt16(int16Val); + AssertEqual(result, true, "result did not equal true as expected.", state); + AssertEqual(int16Val, data.int16test, "int16Val did not equal data.int16test as expected.", state); + + int32_t int32Val; + result = parcel.ReadInt32(int32Val); + AssertEqual(result, true, "result did not equal true as expected.", state); + AssertEqual(int32Val, data.int32test, "int32Val did not equal data.int32test as expected.", state); + + uint8_t uint8Val; + result = parcel.ReadUint8(uint8Val); + AssertEqual(result, true, "result did not equal true as expected.", state); + AssertEqual(uint8Val, data.uint8test, "uint8Val did not equal data.uint8test as expected.", state); + + uint16_t uint16Val; + result = parcel.ReadUint16(uint16Val); + AssertEqual(result, true, "result did not equal true as expected.", state); + AssertEqual(uint16Val, data.uint16test, "uint16Val did not equal data.uint16test as expected.", state); + + uint32_t uint32Val; + result = parcel.ReadUint32(uint32Val); + AssertEqual(result, true, "result did not equal true as expected.", state); + AssertEqual(uint32Val, data.uint32test, "uint32Val did not equal data.uint32test as expected.", state); +} + +/** + * Here to simulate the scenario of ipc sending data, + * the buffer will be released when the Parcel object is destructed. + */ +bool SendData(void *&buffer, size_t size, const uint8_t *data) +{ + BENCHMARK_LOGD("ParcelTest bool SendData is called."); + const size_t parcelMinSizeValue = 1; + if (size < parcelMinSizeValue) { + return false; + } + + buffer = malloc(size); + if (buffer == nullptr) { + return false; + } + + if (memcpy_s(buffer, size, data, size) != EOK) { + return false; + } + return true; +} + +bool CopyOldParcelToNewParcel(Parcel &oldParcel, Parcel &newParcel, benchmark::State& state) +{ + void *buffer = nullptr; + size_t size = oldParcel.GetDataSize(); + + AssertTrue(SendData(buffer, size, reinterpret_cast(oldParcel.GetData())), + "SendData(buffer, size, reinterpret_cast(oldParcel.GetData())) \ + did not equal true as expected.", state); + + bool result = newParcel.ParseFrom(reinterpret_cast(buffer), size); + AssertEqual(result, true, "result did not equal true as expected.", state); + + return true; +} + +/** + * @tc.name: test_parcel_001 + * @tc.desc: test parcel CheckOffsets, WriteRemoteObject, RewindRead and + * RewindWrite failed. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_001 start."); + while (state.KeepRunning()) { + Parcel parcel; + bool result = parcel.CheckOffsets(); + AssertEqual(result, false, "result did not equal false as expected.", state); + + result = parcel.WriteRemoteObject(nullptr); + AssertEqual(result, false, "result did not equal false as expected.", state); + + size_t rewindReadPos = parcel.GetDataSize() + 1; + result = parcel.RewindRead(rewindReadPos); + AssertEqual(result, false, "result did not equal false as expected.", state); + + result = parcel.RewindWrite(rewindReadPos); + AssertEqual(result, false, "result did not equal false as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_001 end."); +} + +/** + * @tc.name: test_parcel_readvec_001 + * @tc.desc: test parcel read vector failed with invlalid input. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_readvec_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_readvec_001 start."); + while (state.KeepRunning()) { + Parcel parcel; + + bool result = parcel.ReadBoolVector(nullptr); + AssertEqual(result, false, "result did not equal false as expected.", state); + + result = parcel.ReadInt8Vector(nullptr); + AssertEqual(result, false, "result did not equal false as expected.", state); + + result = parcel.ReadInt16Vector(nullptr); + AssertEqual(result, false, "result did not equal false as expected.", state); + + result = parcel.ReadInt32Vector(nullptr); + AssertEqual(result, false, "result did not equal false as expected.", state); + + result = parcel.ReadInt64Vector(nullptr); + AssertEqual(result, false, "result did not equal false as expected.", state); + + result = parcel.ReadUInt8Vector(nullptr); + AssertEqual(result, false, "result did not equal false as expected.", state); + + result = parcel.ReadUInt16Vector(nullptr); + AssertEqual(result, false, "result did not equal false as expected.", state); + + result = parcel.ReadUInt32Vector(nullptr); + AssertEqual(result, false, "result did not equal false as expected.", state); + + result = parcel.ReadUInt64Vector(nullptr); + AssertEqual(result, false, "result did not equal false as expected.", state); + + result = parcel.ReadFloatVector(nullptr); + AssertEqual(result, false, "result did not equal false as expected.", state); + + result = parcel.ReadDoubleVector(nullptr); + AssertEqual(result, false, "result did not equal false as expected.", state); + + result = parcel.ReadStringVector(nullptr); + AssertEqual(result, false, "result did not equal false as expected.", state); + + result = parcel.ReadString16Vector(nullptr); + AssertEqual(result, false, "result did not equal false as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_readvec_001 end."); +} + +/** + * @tc.name: test_parcel_readvec_002 + * @tc.desc: test parcel read vector failed with invlalid vector length -1. + * @tc.type: FUNC + */ +template +void WriteSignalDataToVector002(T1 &value, benchmark::State& state, const F executeFunc) +{ + int32_t writeInt32Value = -1; + Parcel parcel; + std::vector vec; + vec.push_back(value); + parcel.WriteInt32(writeInt32Value); + + bool result = executeFunc(parcel, vec); + AssertEqual(result, false, "result did not equal false as expected.", state); +} + +BENCHMARK_F(BenchmarkParcelTest, test_parcel_readvec_002)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_readvec_002 start."); + while (state.KeepRunning()) { + bool writeBoolValue = true; + WriteSignalDataToVector002(writeBoolValue, state, + [](auto &parcel, auto &vec) {return parcel.ReadBoolVector(&vec);}); + + int8_t writeInt8Value = 1; + WriteSignalDataToVector002(writeInt8Value, state, + [](auto &parcel, auto &vec) {return parcel.ReadInt8Vector(&vec);}); + + int16_t writeInt16Value = 1; + WriteSignalDataToVector002(writeInt16Value, state, + [](auto &parcel, auto &vec) {return parcel.ReadInt16Vector(&vec);}); + + int32_t writeInt32Value = 1; + WriteSignalDataToVector002(writeInt32Value, state, + [](auto &parcel, auto &vec) {return parcel.ReadInt32Vector(&vec);}); + + int64_t writeInt64Value = 1; + WriteSignalDataToVector002(writeInt64Value, state, + [](auto &parcel, auto &vec) {return parcel.ReadInt64Vector(&vec);}); + + uint8_t writeUint8Value = 1; + WriteSignalDataToVector002(writeUint8Value, state, + [](auto &parcel, auto &vec) {return parcel.ReadUInt8Vector(&vec);}); + + uint16_t writeUint16Value = 1; + WriteSignalDataToVector002(writeUint16Value, state, + [](auto &parcel, auto &vec) {return parcel.ReadUInt16Vector(&vec);}); + + uint32_t writeUint32Value = 1; + WriteSignalDataToVector002(writeUint32Value, state, + [](auto &parcel, auto &vec) {return parcel.ReadUInt32Vector(&vec);}); + + uint64_t writeUint64Value = 1; + WriteSignalDataToVector002(writeUint64Value, state, + [](auto &parcel, auto &vec) {return parcel.ReadUInt64Vector(&vec);}); + + float writeFloatValue = 1; + WriteSignalDataToVector002(writeFloatValue, state, + [](auto &parcel, auto &vec) {return parcel.ReadFloatVector(&vec);}); + + double writeDoubleValue = 1; + WriteSignalDataToVector002(writeDoubleValue, state, + [](auto &parcel, auto &vec) {return parcel.ReadDoubleVector(&vec);}); + + std::string writeStringValue = "test"; + WriteSignalDataToVector002(writeStringValue, state, + [](auto &parcel, auto &vec) {return parcel.ReadStringVector(&vec);}); + + std::u16string writeU16StringValue = u"test"; + WriteSignalDataToVector002(writeU16StringValue, state, + [](auto &parcel, auto &vec) {return parcel.ReadString16Vector(&vec);}); + } + BENCHMARK_LOGD("ParcelTest test_parcel_readvec_002 end."); +} + +/** + * @tc.name: test_parcel_readvec_003 + * @tc.desc: test parcel read vector failed with invlalid vector length + * std::vector::max_size(). + * @tc.type: FUNC + */ +template +void WriteSignalDataToVector003(T1 &value, benchmark::State& state, const F executeFunc) +{ + Parcel parcel; + std::vector vec; + vec.push_back(value); + parcel.WriteInt32(vec.max_size()); + + bool result = executeFunc(parcel, vec); + AssertEqual(result, false, "result did not equal false as expected.", state); +} + +BENCHMARK_F(BenchmarkParcelTest, test_parcel_readvec_003)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_readvec_003 start."); + while (state.KeepRunning()) { + bool writeBoolValue = true; + WriteSignalDataToVector003(writeBoolValue, state, + [](auto &parcel, auto &vec) {return parcel.ReadBoolVector(&vec);}); + + int8_t writeInt8Value = 1; + WriteSignalDataToVector003(writeInt8Value, state, + [](auto &parcel, auto &vec) {return parcel.ReadInt8Vector(&vec);}); + + int16_t writeInt16Value = 1; + WriteSignalDataToVector003(writeInt16Value, state, + [](auto &parcel, auto &vec) {return parcel.ReadInt16Vector(&vec);}); + + int32_t writeInt32Value = 1; + WriteSignalDataToVector003(writeInt32Value, state, + [](auto &parcel, auto &vec) {return parcel.ReadInt32Vector(&vec);}); + + int64_t writeInt64Value = 1; + WriteSignalDataToVector003(writeInt64Value, state, + [](auto &parcel, auto &vec) {return parcel.ReadInt64Vector(&vec);}); + + uint8_t writeUint8Value = 1; + WriteSignalDataToVector003(writeUint8Value, state, + [](auto &parcel, auto &vec) {return parcel.ReadUInt8Vector(&vec);}); + + uint16_t writeUint16Value = 1; + WriteSignalDataToVector003(writeUint16Value, state, + [](auto &parcel, auto &vec) {return parcel.ReadUInt16Vector(&vec);}); + + uint32_t writeUint32Value = 1; + WriteSignalDataToVector003(writeUint32Value, state, + [](auto &parcel, auto &vec) {return parcel.ReadUInt32Vector(&vec);}); + + uint64_t writeUint64Value = 1; + WriteSignalDataToVector003(writeUint64Value, state, + [](auto &parcel, auto &vec) {return parcel.ReadUInt64Vector(&vec);}); + + float writeFloatValue = 1; + WriteSignalDataToVector003(writeFloatValue, state, + [](auto &parcel, auto &vec) {return parcel.ReadFloatVector(&vec);}); + + double writeDoubleValue = 1; + WriteSignalDataToVector003(writeDoubleValue, state, + [](auto &parcel, auto &vec) {return parcel.ReadDoubleVector(&vec);}); + + std::string writeStringValue = "test"; + WriteSignalDataToVector003(writeStringValue, state, + [](auto &parcel, auto &vec) {return parcel.ReadStringVector(&vec);}); + + std::u16string writeU16StringValue = u"test"; + WriteSignalDataToVector003(writeU16StringValue, state, + [](auto &parcel, auto &vec) {return parcel.ReadString16Vector(&vec);}); + } + BENCHMARK_LOGD("ParcelTest test_parcel_readvec_003 end."); +} + +/** + * @tc.name: test_parcel_writevec_001 + * @tc.desc: test parcel write vector failed with writting data out of the + * maximum capacity. + * @tc.type: FUNC + */ +template +void WriteDataToVector(T1 &value, benchmark::State& state, const F executeFunc) +{ + std::vector vec; + for (unsigned int idx = 0; idx < DEFAULT_CPACITY / sizeof(T1); idx++) { + vec.push_back(value); + } + bool result = executeFunc(vec); + AssertEqual(result, false, "result did not equal false as expected.", state); +} + +template +void WriteDataToVector(std::string &value, benchmark::State& state, const F executeFunc) +{ + std::vector vec; + vec.push_back(value); + + bool result = executeFunc(vec); + AssertEqual(result, false, "result did not equal false as expected.", state); +} + +template +void WriteDataToVector(std::u16string &value, benchmark::State& state, const F executeFunc) +{ + std::vector vec; + vec.push_back(value); + + bool result = executeFunc(vec); + AssertEqual(result, false, "result did not equal false as expected.", state); +} + +BENCHMARK_F(BenchmarkParcelTest, test_parcel_writevec_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_writevec_001 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + bool writeBoolValue = true; + WriteDataToVector(writeBoolValue, state, [&](auto &vec) {return parcel.WriteBoolVector(vec);}); + + int8_t writeInt8Value = 1; + WriteDataToVector(writeInt8Value, state, + [&](auto &vec) {parcel.FlushBuffer(); return parcel.WriteInt8Vector(vec);}); + + int16_t writeInt16Value = 1; + WriteDataToVector(writeInt16Value, state, + [&](auto &vec) {parcel.FlushBuffer(); return parcel.WriteInt16Vector(vec);}); + + int32_t writeInt32Value = 1; + WriteDataToVector(writeInt32Value, state, + [&](auto &vec) {parcel.FlushBuffer(); return parcel.WriteInt32Vector(vec);}); + + int64_t writeInt64Value = 1; + WriteDataToVector(writeInt64Value, state, + [&](auto &vec) {parcel.FlushBuffer(); return parcel.WriteInt64Vector(vec);}); + + uint8_t writeUint8Value = 1; + WriteDataToVector(writeUint8Value, state, + [&](auto &vec) {parcel.FlushBuffer(); return parcel.WriteUInt8Vector(vec);}); + + uint16_t writeUint16Value = 1; + WriteDataToVector(writeUint16Value, state, + [&](auto &vec) {parcel.FlushBuffer(); return parcel.WriteUInt16Vector(vec);}); + + uint32_t writeUint32Value = 1; + WriteDataToVector(writeUint32Value, state, + [&](auto &vec) {parcel.FlushBuffer(); return parcel.WriteUInt32Vector(vec);}); + + uint64_t writeUint64Value = 1; + WriteDataToVector(writeUint64Value, state, + [&](auto &vec) {parcel.FlushBuffer(); return parcel.WriteUInt64Vector(vec);}); + + float writeFloatValue = 1; + WriteDataToVector(writeFloatValue, state, + [&](auto &vec) {parcel.FlushBuffer(); return parcel.WriteFloatVector(vec);}); + + double writeDoubleValue = 1; + WriteDataToVector(writeDoubleValue, state, + [&](auto &vec) {parcel.FlushBuffer(); return parcel.WriteDoubleVector(vec);}); + + char insertCharValue = 't'; + std::string x12((DEFAULT_CPACITY / sizeof(char)), insertCharValue); + WriteDataToVector(x12, state, + [&](auto &vec) {parcel.FlushBuffer(); return parcel.WriteStringVector(vec);}); + + char16_t insertCharTValue = u't'; + std::u16string x13((DEFAULT_CPACITY / sizeof(char16_t)), insertCharTValue); + WriteDataToVector(x13, state, + [&] (auto &vec) {parcel.FlushBuffer(); return parcel.WriteString16Vector(vec);}); + } + BENCHMARK_LOGD("ParcelTest test_parcel_writevec_001 end."); +} + +/** + * @tc.name: test_parcel_SetMaxCapacity_001 + * @tc.desc: test parcel primary type read write. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_SetMaxCapacity_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_SetMaxCapacity_001 start."); + const size_t setMaxCapacityValue = 1; + while (state.KeepRunning()) { + size_t cap = DEFAULT_CPACITY; + Parcel parcel(nullptr); + AssertTrue(parcel.SetMaxCapacity(cap + setMaxCapacityValue), + "parcel.SetMaxCapacity(cap + 1) did not equal true as expected.", state); + AssertFalse(parcel.SetMaxCapacity(cap - setMaxCapacityValue), + "parcel.SetMaxCapacity(cap - 1) did not equal false as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_SetMaxCapacity_001 end."); +} + +/** + * @tc.name: test_parcel_SetAllocator_001 + * @tc.desc: test setting allocator to parcels with and without existed allocator. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_SetAllocator_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_SetAllocator_001 start."); + while (state.KeepRunning()) { + Allocator* alloc = new DefaultAllocator(); + Parcel parcel(alloc); + AssertFalse(parcel.SetAllocator(alloc), + "parcel.SetAllocator(alloc) did not equal false as expected.", state); + AssertFalse(parcel.SetAllocator(nullptr), + "parcel.SetAllocator(nullptr) did not equal false as expected.", state); + + struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 }; + + WriteTestData(parcel, data, state); + parcel.SetAllocator(new DefaultAllocator()); + ReadTestData(parcel, data, state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_SetAllocator_001 end."); +} + +/** + * @tc.name: test_parcel_write_001 + * @tc.desc: test parcel write failed. + * @tc.type: FUNC + */ +template +void TestParcelWrite001(T1 value, benchmark::State& state, const F executeFunc) +{ + bool result = executeFunc(value); + AssertEqual(result, false, "result did not equal false as expected.", state); +} + +BENCHMARK_F(BenchmarkParcelTest, test_parcel_write_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_write_001 start."); + while (state.KeepRunning()) { + Parcel parcel1; + parcel1.WriteBool(true); + Parcel parcel2; + AssertTrue(CopyOldParcelToNewParcel(parcel1, parcel2, state), + "CopyOldParcelToNewParcel(parcel1, parcel2, state) did not equal true as expected.", state); + + string str8write; + TestParcelWrite001(str8write, state, [&](auto &value) {return parcel2.WriteString(value);}); + u16string str16Write; + TestParcelWrite001(str16Write, state, [&](auto &value) {return parcel2.WriteString16(value);}); + + TestParcelWrite001(false, state, [&](auto &value) {return parcel2.WriteBool(value);}); + TestParcelWrite001(false, state, [&](auto &value) {return parcel2.WriteBoolUnaligned(value);}); + + TestParcelWrite001(false, state, [&](auto &value) {return parcel2.WriteInt8(value);}); + TestParcelWrite001(false, state, [&](auto &value) {return parcel2.WriteInt8Unaligned(value);}); + + TestParcelWrite001(false, state, [&](auto &value) {return parcel2.WriteInt32(value);}); + + TestParcelWrite001(false, state, [&](auto &value) {return parcel2.WriteInt64(value);}); + + TestParcelWrite001(false, state, [&](auto &value) {return parcel2.WriteUint8(value);}); + + TestParcelWrite001(false, state, [&](auto &value) {return parcel2.WriteUint16(value);}); + + TestParcelWrite001(false, state, [&](auto &value) {return parcel2.WriteUint8Unaligned(value);}); + + TestParcelWrite001(false, state, [&](auto &value) {return parcel2.WriteUint16Unaligned(value);}); + + TestParcelWrite001(false, state, [&](auto &value) {return parcel2.WriteUint32(value);}); + + TestParcelWrite001(false, state, [&](auto &value) {return parcel2.WriteUint64(value);}); + + TestParcelWrite001(false, state, [&](auto &value) {return parcel2.WriteFloat(value);}); + + TestParcelWrite001(false, state, [&](auto &value) {return parcel2.WriteDouble(value);}); + + TestParcelWrite001(false, state, [&](auto &value) {return parcel2.WritePointer(value);}); + } + BENCHMARK_LOGD("ParcelTest test_parcel_write_001 end."); +} + +/** + * @tc.name: test_parcel_WriteAndRead_001 + * @tc.desc: test parcel primary type read write. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_WriteAndRead_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_001 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 }; + WriteTestData(parcel, data, state); + ReadTestData(parcel, data, state); + + WriteUnalignedTestData(parcel, data, state); + ReadUnalignedTestData(parcel, data, state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_001 end."); +} + +/** + * @tc.name: test_parcel_WriteAndRead_002 + * @tc.desc: test parcel primary type read write. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_WriteAndRead_002)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_002 start."); + while (state.KeepRunning()) { + Parcel parcel1(nullptr); + Parcel parcel2(nullptr); + struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 }; + WriteTestData(parcel1, data, state); + WriteUnalignedTestData(parcel1, data, state); + + AssertTrue(CopyOldParcelToNewParcel(parcel1, parcel2, state), + "CopyOldParcelToNewParcel(parcel1, parcel2, state) did not equal true as expected.", state); + ReadTestData(parcel2, data, state); + ReadUnalignedTestData(parcel2, data, state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_002 end."); +} + +/** + * @tc.name: test_parcel_WriteAndRead_003 + * @tc.desc: test parcel primary type read write. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_WriteAndRead_003)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_003 start."); + while (state.KeepRunning()) { + Parcel parcel1(nullptr); + Parcel parcel2(nullptr); + struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 }; + WriteTestData(parcel1, data, state); + + AssertTrue(CopyOldParcelToNewParcel(parcel1, parcel2, state), + "CopyOldParcelToNewParcel(parcel1, parcel2, state) did not equal true as expected.", state); + ReadTestDataWithTarget(parcel2, data, state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_003 end."); +} + +/** + * @tc.name: test_parcel_WriteAndRead_004 + * @tc.desc: test parcel primary type read write. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_WriteAndRead_004)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_004 start."); + while (state.KeepRunning()) { + Parcel parcel1(nullptr); + int64_t int64test = -0x1234567887654321; + bool result = parcel1.WriteInt64(int64test); + AssertEqual(result, true, "result did not equal true as expected.", state); + + uint64_t uint64test = 0x1234567887654321; + result = parcel1.WriteUint64(uint64test); + AssertEqual(result, true, "result did not equal true as expected.", state); + + int64_t readint64 = parcel1.ReadInt64(); + AssertEqual(readint64, int64test, "readint64 did not equal int64test as expected.", state); + + uint64_t readuint64 = parcel1.ReadUint64(); + AssertEqual(readuint64, uint64test, "readuint64 did not equal uint64test as expected.", state); + + Parcel parcel2(nullptr); + AssertTrue(CopyOldParcelToNewParcel(parcel1, parcel2, state), + "CopyOldParcelToNewParcel(parcel1, parcel2, state) did not equal true as expected.", state); + + readint64 = parcel2.ReadInt64(); + AssertEqual(readint64, int64test, "readint64 did not equal int64test as expected.", state); + + readuint64 = parcel2.ReadUint64(); + AssertEqual(readuint64, uint64test, "readuint64 did not equal uint64test as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_004 end."); +} + +/** + * @tc.name: test_parcel_WriteAndRead_String_001 + * @tc.desc: test parcel string read write. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_WriteAndRead_String_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_String_001 start."); + while (state.KeepRunning()) { + Parcel parcel1(nullptr); + string strWrite = "test"; + bool result = parcel1.WriteString(strWrite); + AssertEqual(result, true, "result did not equal true as expected.", state); + string strWrite1 = + "test for write string padded**********************************************************##################"; + result = parcel1.WriteString(strWrite1); + AssertEqual(result, true, "result did not equal true as expected.", state); + + string strWrite2 = + "test for write string padded**********************************************************##################"; + result = parcel1.WriteString(strWrite2); + AssertEqual(result, true, "result did not equal true as expected.", state); + string strRead = parcel1.ReadString(); + string strRead1 = parcel1.ReadString(); + string strRead2 = parcel1.ReadString(); + AssertEqual(COMPARE_STRING_RESULT, strcmp(strRead.c_str(), strWrite.c_str()), + "strcmp(strRead.c_str(), strWrite.c_str()) did not equal 0 as expected.", state); + AssertEqual(COMPARE_STRING_RESULT, strcmp(strRead1.c_str(), strWrite1.c_str()), + "strcmp(strRead1.c_str(), strWrite1.c_str()) did not equal 0 as expected.", state); + AssertEqual(COMPARE_STRING_RESULT, strcmp(strRead2.c_str(), strWrite2.c_str()), + "strcmp(strRead2.c_str(), strWrite2.c_str()) did not equal 0 as expected.", state); + + Parcel parcel2(nullptr); + AssertTrue(CopyOldParcelToNewParcel(parcel1, parcel2, state), + "CopyOldParcelToNewParcel(parcel1, parcel2, state) did not equal true as expected.", state); + + strRead = parcel2.ReadString(); + strRead1 = parcel2.ReadString(); + strRead2 = parcel2.ReadString(); + AssertEqual(COMPARE_STRING_RESULT, strcmp(strRead.c_str(), strWrite.c_str()), + "strcmp(strRead.c_str(), strWrite.c_str()) did not equal 0 as expected.", state); + AssertEqual(COMPARE_STRING_RESULT, strcmp(strRead1.c_str(), strWrite1.c_str()), + "strcmp(strRead1.c_str(), strWrite1.c_str()) did not equal 0 as expected.", state); + AssertEqual(COMPARE_STRING_RESULT, strcmp(strRead2.c_str(), strWrite2.c_str()), + "strcmp(strRead2.c_str(), strWrite2.c_str()) did not equal 0 as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_String_001 end."); +} + +/** + * @tc.name: test_parcel_WriteAndRead_String_002 + * @tc.desc: test parcel string read write. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_WriteAndRead_String_002)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_String_002 start."); + while (state.KeepRunning()) { + Parcel parcel1(nullptr); + u16string str16Write = u"12345"; + bool result = parcel1.WriteString16(str16Write); + AssertEqual(result, true, "result did not equal true as expected.", state); + + u16string str16Write2 = u"12345 test for write16string padded*********"; + result = parcel1.WriteString16(str16Write2); + AssertEqual(result, true, "result did not equal true as expected.", state); + + u16string str16Read = parcel1.ReadString16(); + u16string str16Read2 = parcel1.ReadString16(); + AssertEqual(COMPARE_STRING_RESULT, str16Read.compare(str16Write), + "str16Read.compare(str16Write) did not equal 0 as expected.", state); + AssertEqual(COMPARE_STRING_RESULT, str16Read2.compare(str16Write2), + "str16Read2.compare(str16Write2) did not equal 0 as expected.", state); + + Parcel parcel2(nullptr); + AssertTrue(CopyOldParcelToNewParcel(parcel1, parcel2, state), + "CopyOldParcelToNewParcel(parcel1, parcel2, state) did not equal true as expected.", state); + + str16Read = parcel2.ReadString16(); + str16Read2 = parcel2.ReadString16(); + AssertEqual(COMPARE_STRING_RESULT, str16Read.compare(str16Write), + "str16Read.compare(str16Write) did not equal 0 as expected.", state); + AssertEqual(COMPARE_STRING_RESULT, str16Read2.compare(str16Write2), + "str16Read2.compare(str16Write2) did not equal 0 as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_String_002 end."); +} + +/** + * @tc.name: test_parcel_WriteAndRead_String_003 + * @tc.desc: test parcel CString read write. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_WriteAndRead_String_003)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_String_003 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + string test1 = "12345"; + string test2 = "23456"; + string test3 = "34567"; + string test4 = "45678"; + bool result = parcel.WriteCString(nullptr); + AssertEqual(result, false, "result did not equal false as expected.", state); + + result = parcel.WriteCString(test1.c_str()); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.WriteCString(test2.c_str()); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.WriteCString(test3.c_str()); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.WriteCString(test4.c_str()); + AssertEqual(result, true, "result did not equal true as expected.", state); + + AssertEqual(COMPARE_STRING_RESULT, strcmp(test1.c_str(), parcel.ReadCString()), + "strcmp(test1.c_str(), parcel.ReadCString()) did not equal 0 as expected.", state); + AssertEqual(COMPARE_STRING_RESULT, strcmp(test2.c_str(), parcel.ReadCString()), + "strcmp(test2.c_str(), parcel.ReadCString()) did not equal 0 as expected.", state); + AssertEqual(COMPARE_STRING_RESULT, strcmp(test3.c_str(), parcel.ReadCString()), + "strcmp(test3.c_str(), parcel.ReadCString()) did not equal 0 as expected.", state); + AssertEqual(COMPARE_STRING_RESULT, strcmp(test4.c_str(), parcel.ReadCString()), + "strcmp(test4.c_str(), parcel.ReadCString()) did not equal 0 as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_String_003 end."); +} + +/** + * @tc.name: test_parcel_WriteAndRead_String004 + * @tc.desc: test parcel CString read write. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_WriteAndRead_String004)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_String004 start."); + while (state.KeepRunning()) { + Parcel parcel1(nullptr); + bool result = false; + size_t writeString16Length = 0; + // write from Java, read from C++ + result = parcel1.WriteString16WithLength(nullptr, writeString16Length); + AssertEqual(result, true, "result did not equal true as expected.", state); + + u16string str16write = u"12345"; + char16_t *value1 = str16write.data(); + result = parcel1.WriteString16WithLength(value1, str16write.length()); + AssertEqual(result, true, "result did not equal true as expected.", state); + + u16string str16write2 = u"12345 test for write16string padded*********"; + char16_t *value2 = str16write2.data(); + result = parcel1.WriteString16WithLength(value2, str16write2.length()); + AssertEqual(result, true, "result did not equal true as expected.", state); + + u16string str16readNull = parcel1.ReadString16(); + u16string str16read1 = parcel1.ReadString16(); + u16string str16read2 = parcel1.ReadString16(); + AssertEqual(COMPARE_STRING_RESULT, str16readNull.compare(std::u16string()), + "str16readNull.compare(std::u16string()) did not equal 0 as expected.", state); + AssertEqual(COMPARE_STRING_RESULT, str16read1.compare(str16write), + "str16read1.compare(str16write) did not equal 0 as expected.", state); + AssertEqual(COMPARE_STRING_RESULT, str16read2.compare(str16write2), + "str16read2.compare(str16write2) did not equal 0 as expected.", state); + + // write from C++, read from Java + result = parcel1.WriteString16(str16write); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel1.WriteString16(str16write2); + AssertEqual(result, true, "result did not equal true as expected.", state); + + int32_t readLength1 = 0; + u16string str16read3 = parcel1.ReadString16WithLength(readLength1); + AssertEqual(readLength1, static_cast(str16write.length()), + "readLength1 did not equal static_cast(str16write.length()) as expected.", state); + + int32_t readLength2 = 0; + u16string str16read4 = parcel1.ReadString16WithLength(readLength2); + AssertEqual(readLength2, static_cast(str16write2.length()), + "readLength2 did not equal static_cast(str16write2.length()) as expected.", state); + + AssertEqual(COMPARE_STRING_RESULT, str16read3.compare(str16write), + "str16read3.compare(str16write) did not equal 0 as expected.", state); + + AssertEqual(COMPARE_STRING_RESULT, str16read4.compare(str16write2), + "str16read4.compare(str16write2) did not equal 0 as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_String004 end."); +} + +/** + * @tc.name: test_parcel_WriteAndRead_String005 + * @tc.desc: test parcel CString read write. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_WriteAndRead_String005)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_String005 start."); + while (state.KeepRunning()) { + Parcel parcel1(nullptr); + bool result = false; + size_t writeString8Length = 0; + // write from Java, read from C++ + result = parcel1.WriteString8WithLength(nullptr, writeString8Length); + AssertEqual(result, true, "result did not equal true as expected.", state); + + string str8write = "12345"; + char *value1 = str8write.data(); + result = parcel1.WriteString8WithLength(value1, str8write.length()); + AssertEqual(result, true, "result did not equal true as expected.", state); + + string str8write2 = "12345 test for write16string padded*********"; + char *value2 = str8write2.data(); + result = parcel1.WriteString8WithLength(value2, str8write2.length()); + AssertEqual(result, true, "result did not equal true as expected.", state); + + string str8readNull = parcel1.ReadString(); + string str8read1 = parcel1.ReadString(); + string str8read2 = parcel1.ReadString(); + AssertEqual(COMPARE_STRING_RESULT, str8readNull.compare(std::string()), + "str8readNull.compare(std::string()) did not equal 0 as expected.", state); + AssertEqual(COMPARE_STRING_RESULT, str8read1.compare(str8write), + "str8read1.compare(str8write) did not equal 0 as expected.", state); + AssertEqual(COMPARE_STRING_RESULT, str8read2.compare(str8write2), + "str8read2.compare(str8write2) did not equal 0 as expected.", state); + + // write from C++, read from Java + result = parcel1.WriteString(str8write); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel1.WriteString(str8write2); + AssertEqual(result, true, "result did not equal true as expected.", state); + + int32_t readLength1 = 0; + string str8read3 = parcel1.ReadString8WithLength(readLength1); + AssertEqual(readLength1, static_cast(str8write.length()), + "readLength1 did not equal static_cast(str8write.length()) as expected.", state); + + int32_t readLength2 = 0; + string str8read4 = parcel1.ReadString8WithLength(readLength2); + AssertEqual(readLength2, static_cast(str8write2.length()), + "readLength2 did not equal static_cast(str8write2.length()) as expected.", state); + AssertEqual(COMPARE_STRING_RESULT, str8read3.compare(str8write), + "str8read3.compare(str8write) did not equal 0 as expected.", state); + AssertEqual(COMPARE_STRING_RESULT, str8read4.compare(str8write2), + "str8read4.compare(str8write2) did not equal 0 as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_String005 end."); +} + +/** + * @tc.name: test_parcel_WriteAndRead_Float_001 + * @tc.desc: test parcel float types read write. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_WriteAndRead_Float_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_Float_001 start."); + while (state.KeepRunning()) { + Parcel parcel1(nullptr); + float floatwrite = 12.345678f; + bool result = parcel1.WriteFloat(floatwrite); + AssertEqual(result, true, "result did not equal true as expected.", state); + + double doublewrite = 1345.7653; + result = parcel1.WriteDouble(doublewrite); + AssertEqual(result, true, "result did not equal true as expected.", state); + + float floatread; + result = parcel1.ReadFloat(floatread); + AssertEqual(result, true, "result did not equal true as expected.", state); + AssertEqual(floatwrite, floatread, "floatwrite did not equal floatread as expected.", state); + + double doubleread; + doubleread = parcel1.ReadDouble(); + AssertEqual(doublewrite, doubleread, "doublewrite did not equal doubleread as expected.", state); + + Parcel parcel2(nullptr); + AssertTrue(CopyOldParcelToNewParcel(parcel1, parcel2, state), + "CopyOldParcelToNewParcel(parcel1, parcel2, state) did not equal true as expected.", state); + + result = parcel2.ReadFloat(floatread); + AssertEqual(result, true, "result did not equal true as expected.", state); + AssertEqual(floatwrite, floatread, "floatwrite did not equal floatread as expected.", state); + + doubleread = parcel2.ReadDouble(); + AssertEqual(doublewrite, doubleread, "doublewrite did not equal doubleread as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_Float_001 end."); +} + +/** + * @tc.name: test_parcel_WriteAndRead_String_005 + * @tc.desc: test parcel String type read write. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_WriteAndRead_String_005)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_String_005 start."); + while (state.KeepRunning()) { + Parcel parcel1(nullptr); + string strwrite = "test"; + bool result = parcel1.WriteString(strwrite); + AssertEqual(result, true, "result did not equal true as expected.", state); + string strwrite1 = + "test for write string padded**********************************************************##################"; + result = parcel1.WriteString(strwrite1); + AssertEqual(result, true, "result did not equal true as expected.", state); + string strwrite2 = + "test for write string padded**********************************************************##################"; + result = parcel1.WriteString(strwrite2); + AssertEqual(result, true, "result did not equal true as expected.", state); + + string strread; + string strread1; + string strread2; + result = parcel1.ReadString(strread); + AssertEqual(result, true, "result did not equal true as expected.", state); + result = parcel1.ReadString(strread1); + AssertEqual(result, true, "result did not equal true as expected.", state); + result = parcel1.ReadString(strread2); + AssertEqual(result, true, "result did not equal true as expected.", state); + + AssertEqual(COMPARE_STRING_RESULT, strcmp(strread.c_str(), strwrite.c_str()), + "strcmp(strread.c_str(), strwrite.c_str()) did not equal 0 as expected.", state); + AssertEqual(COMPARE_STRING_RESULT, strcmp(strread1.c_str(), strwrite1.c_str()), + "strcmp(strread1.c_str(), strwrite1.c_str()) did not equal 0 as expected.", state); + AssertEqual(COMPARE_STRING_RESULT, strcmp(strread2.c_str(), strwrite2.c_str()), + "strcmp(strread2.c_str(), strwrite2.c_str()) did not equal 0 as expected.", state); + + Parcel parcel2(nullptr); + AssertTrue(CopyOldParcelToNewParcel(parcel1, parcel2, state), + "CopyOldParcelToNewParcel(parcel1, parcel2, state) did not equal true as expected.", state); + + result = parcel2.ReadString(strread); + AssertEqual(result, true, "result did not equal true as expected.", state); + result = parcel2.ReadString(strread1); + AssertEqual(result, true, "result did not equal true as expected.", state); + result = parcel2.ReadString(strread2); + AssertEqual(result, true, "result did not equal true as expected.", state); + + AssertEqual(COMPARE_STRING_RESULT, strcmp(strread.c_str(), strwrite.c_str()), + "strcmp(strread.c_str(), strwrite.c_str()) did not equal 0 as expected.", state); + AssertEqual(COMPARE_STRING_RESULT, strcmp(strread1.c_str(), strwrite1.c_str()), + "strcmp(strread1.c_str(), strwrite1.c_str()) did not equal 0 as expected.", state); + AssertEqual(COMPARE_STRING_RESULT, strcmp(strread2.c_str(), strwrite2.c_str()), + "strcmp(strread2.c_str(), strwrite2.c_str()) did not equal 0 as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_String_005 end."); +} + +struct Padded { + char title; + int32_t handle; + uint64_t cookie; +}; + +struct Unpadded { + char tip; +}; + +void ValidatePadded(const struct Padded &left, const struct Padded &right, benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest void ValidatePadded is called."); + AssertEqual(left.title, right.title, "left.title did not equal right.title as expected.", state); + + AssertEqual(left.handle, right.handle, "left.handle did not equal right.handle as expected.", state); + + AssertEqual(left.cookie, right.cookie, "left.cookie did not equal right.cookie as expected.", state); +} + +void ValidateUnpadded(const struct Unpadded &left, const struct Unpadded &right, benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest void ValidateUnpadded is called."); + AssertEqual(left.tip, right.tip, "left.tip did not equal right.tip as expected.", state); +} + +/** + * @tc.name: test_CalcNewCapacity_001 + * @tc.desc: test kinds of input to CalcNewCapacity. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_CalcNewCapacity_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_CalcNewCapacity_001 start."); + while (state.KeepRunning()) { + Parcel parcel; + size_t newMaxCapacity; + size_t minNewCapacity = CAPACITY_THRESHOLD; + const string strLenThreshd = string(minNewCapacity, 't'); + bool ret = parcel.WriteUnpadBuffer(static_cast(strLenThreshd.data()), minNewCapacity); + AssertEqual(ret, true, "ret did not equal true as expected.", state); + + newMaxCapacity = CAPACITY_THRESHOLD - 1; + minNewCapacity = newMaxCapacity; + const string strLessThreshd = string(minNewCapacity, 'l'); + parcel.SetMaxCapacity(newMaxCapacity); + ret = parcel.WriteUnpadBuffer(static_cast(strLessThreshd.data()), minNewCapacity); + AssertEqual(ret, true, "ret did not equal true as expected.", state); + + newMaxCapacity = -1; // minNewCapacity = CAPACITY_THRESHOLD - 1 + const string strNoMaxCap = string(minNewCapacity, 'n'); + parcel.SetMaxCapacity(newMaxCapacity); + ret = parcel.WriteUnpadBuffer(static_cast(strNoMaxCap.data()), minNewCapacity); + AssertEqual(ret, true, "ret did not equal true as expected.", state); + + minNewCapacity = CAPACITY_THRESHOLD + 1; // newMaxCapacity = -1 + const string strExtThreshd = string(minNewCapacity, 'e'); + parcel.SetMaxCapacity(newMaxCapacity); + ret = parcel.WriteUnpadBuffer(static_cast(strExtThreshd.data()), minNewCapacity); + AssertEqual(ret, true, "ret did not equal true as expected.", state); + + newMaxCapacity = CAPACITY_THRESHOLD; // minNewCapacity = CAPACITY_THRESHOLD + 1 + const string strCapThreshd = string(minNewCapacity, 'e'); + parcel.SetMaxCapacity(newMaxCapacity); + ret = parcel.WriteUnpadBuffer(static_cast(strCapThreshd.data()), minNewCapacity); + AssertEqual(ret, true, "ret did not equal true as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_CalcNewCapacity_001 end."); +} + +/** + * @tc.name: test_SetDataCapacity_001 + * @tc.desc: test kinds of input to SetDataCapacity. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_SetDataCapacity_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_SetDataCapacity_001 start."); + while (state.KeepRunning()) { + Parcel parcel; + struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 }; + WriteTestData(parcel, data, state); + + bool result = parcel.SetDataCapacity(0); + AssertFalse(result, "result did not equal false as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_SetDataCapacity_001 end."); +} + +/** + * @tc.name: test_SetDataSize_001 + * @tc.desc: test kinds of input to SetDataSize. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_SetDataSize_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_SetDataSize_001 start."); + while (state.KeepRunning()) { + Parcel parcel; + bool result = parcel.SetDataCapacity(sizeof(bool)); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.WriteBool(true); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.SetDataSize(DEFAULT_CPACITY + 1); + AssertEqual(result, false, "result did not equal false as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_SetDataSize_001 end."); +} + +/** + * @tc.name: test_parcel_Data_Structure_001 + * @tc.desc: test parcel struct data related function. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_Data_Structure_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_Data_Structure_001 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + const struct Padded pad = { 'p', 0x34567890, -0x2345678998765432 }; + const struct Unpadded unpad = { 'u' }; + + bool result = parcel.WriteBuffer(static_cast(&pad), sizeof(struct Padded)); + AssertEqual(result, true, "result did not equal true as expected.", state); + + const struct Padded *padRead = + reinterpret_cast(parcel.ReadBuffer(sizeof(struct Padded))); + ValidatePadded(*padRead, pad, state); + AssertEqual(parcel.GetWritePosition(), parcel.GetReadPosition(), + "parcel.GetWritePosition() did not equal parcel.GetReadPosition() as expected.", state); + + result = parcel.WriteBuffer(static_cast(&unpad), sizeof(struct Unpadded)); + const struct Unpadded *unpadRead = + reinterpret_cast(parcel.ReadBuffer(sizeof(struct Unpadded))); + ValidateUnpadded(*unpadRead, unpad, state); + AssertUnequal(parcel.GetWritePosition(), parcel.GetReadPosition(), + "parcel.GetWritePosition() was not different from parcel.GetReadPosition() as expected.", state); + + parcel.RewindRead(REWIND_INIT_VALUE); + parcel.RewindWrite(REWIND_INIT_VALUE); + AssertEqual(parcel.GetWritePosition(), parcel.GetReadPosition(), + "parcel.GetWritePosition() did not equal parcel.GetReadPosition() as expected.", state); + + result = parcel.WriteUnpadBuffer(static_cast(&pad), sizeof(struct Padded)); + AssertEqual(result, true, "result did not equal true as expected.", state); + + const struct Padded *padReadNew = + reinterpret_cast(parcel.ReadUnpadBuffer(sizeof(struct Padded))); + ValidatePadded(*padReadNew, pad, state); + AssertEqual(parcel.GetWritePosition(), parcel.GetReadPosition(), + "parcel.GetWritePosition() did not equal parcel.GetReadPosition() as expected.", state); + + result = parcel.WriteUnpadBuffer(static_cast(&unpad), sizeof(struct Unpadded)); + AssertEqual(result, true, "result did not equal true as expected.", state); + + const struct Unpadded *unpadReadNew = + reinterpret_cast(parcel.ReadUnpadBuffer(sizeof(struct Unpadded))); + ValidateUnpadded(*unpadReadNew, unpad, state); + AssertEqual(parcel.GetWritePosition(), parcel.GetReadPosition(), + "parcel.GetWritePosition() did not equal parcel.GetReadPosition() as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_Data_Structure_001 end."); +} + +/** + * @tc.name: test_parcel_Data_Structure_002 + * @tc.desc: test invalid input to WriteBuffer and WriteBufferAddTerminator. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_Data_Structure_002)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_Data_Structure_002 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + const string str = "test invalid input"; + const string strOverflow = "test write with SIZE_MAX bytes"; + const string strWriteFail = string((DEFAULT_CPACITY + 1) / sizeof(char), 'f'); + const string strWriteTermFail = string((DEFAULT_CPACITY - 2) / sizeof(char), 't'); + bool result = parcel.WriteBuffer(nullptr, sizeof(string)); + AssertEqual(result, false, "result did not equal false as expected.", state); + + result = parcel.WriteBufferAddTerminator(nullptr, sizeof(string), sizeof(char)); + AssertEqual(result, false, "result did not equal false as expected.", state); + + result = parcel.WriteBuffer(static_cast(str.data()), 0); + AssertEqual(result, false, "result did not equal false as expected.", state); + + size_t writeBufferSize = 0; + result = parcel.WriteBufferAddTerminator(static_cast(str.data()), writeBufferSize, sizeof(char)); + AssertEqual(result, false, "result did not equal false as expected.", state); + + result = parcel.WriteBuffer(static_cast(strWriteFail.data()), strWriteFail.length()); + AssertEqual(result, false, "result did not equal false as expected.", state); + + result = parcel.WriteBufferAddTerminator(static_cast(strWriteFail.data()), + strWriteFail.length(), sizeof(char)); + AssertEqual(result, false, "result did not equal false as expected.", state); + + result = parcel.WriteBufferAddTerminator(static_cast(str.data()), str.length(), sizeof(char)); + AssertEqual(result, true, "result did not equal true as expected.", state); + + Parcel recvParcel(nullptr); + AssertTrue(CopyOldParcelToNewParcel(parcel, recvParcel, state), + "CopyOldParcelToNewParcel(parcel, recvParcel, state) did not equal true as expected.", state); + + result = recvParcel.WriteBufferAddTerminator(static_cast(&str), str.length() + 1, sizeof(char)); + AssertEqual(result, false, "result did not equal false as expected.", state); + } +} + +struct VectorTestData { + vector booltest = { false, false, true, false, true }; + vector int8test = { 0x01, 0x10, -0x20, 0x30, 0x40 }; + vector int16test = { 0x1234, -0x2345, 0x3456, -0x4567, 0x5678 }; + vector int32test = { 0x12345678, -0x23456789, 0x34567890, -0x45678901 }; + vector int64test = { 0x1234567887654321, -0x2345678998765432 }; + vector uint8test = { 0x01, 0x10, 0x20, 0x30, 0x40 }; + vector uint16test = { 0x1234, 0x2345, 0x3456, 0x4567, 0x5678 }; + vector uint32test = { 0x12345678, 0x23456789, 0x34567890, 0x45678901 }; + vector uint64test = { 0x1234567887654321, 0x2345678998765432 }; +}; + +void WriteVectorTestData(Parcel &parcel, const VectorTestData &data, benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest void WriteVectorTestData is called."); + bool result = parcel.WriteBoolVector(data.booltest); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.WriteInt8Vector(data.int8test); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.WriteInt16Vector(data.int16test); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.WriteInt32Vector(data.int32test); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.WriteInt64Vector(data.int64test); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.WriteUInt8Vector(data.uint8test); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.WriteUInt16Vector(data.uint16test); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.WriteUInt32Vector(data.uint32test); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel.WriteUInt64Vector(data.uint64test); + AssertEqual(result, true, "result did not equal true as expected.", state); +} + +template +void LoopReadVectorCmpData(const vector &vec1, const vector &vec2, + const char* printInfo, benchmark::State& state) +{ + for (size_t idx = 0; idx < vec1.size(); idx++) { + AssertEqual(vec1[idx], vec2[idx], printInfo, state); + } +} + +template <> void LoopReadVectorCmpData(const vector &vec1, const vector &vec2, + const char* printInfo, benchmark::State& state) +{ + for (size_t idx = 0; idx < vec1.size(); idx++) { + AssertEqual(COMPARE_STRING_RESULT, vec1[idx].compare(vec2[idx]), printInfo, state); + } +} + +void ReadVectorTestData(Parcel &parcel, const VectorTestData &data, benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest void ReadVectorTestData is called."); + vector boolread; + vector int8read; + vector int16read; + vector int32read; + vector int64read; + vector uint8read; + vector uint16read; + vector uint32read; + vector uint64read; + bool result = parcel.ReadBoolVector(&boolread); + AssertEqual(result, true, "result did not equal true as expected.", state); + LoopReadVectorCmpData(data.booltest, boolread, + "data.booltest[i] did not equal boolread[i] as expected.", state); + + result = parcel.ReadInt8Vector(&int8read); + AssertEqual(result, true, "result did not equal true as expected.", state); + LoopReadVectorCmpData(data.int8test, int8read, + "data.int8test[i] did not equal int8read[i] as expected.", state); + + result = parcel.ReadInt16Vector(&int16read); + AssertEqual(result, true, "result did not equal true as expected.", state); + LoopReadVectorCmpData(data.int16test, int16read, + "data.int16test[i] did not equal int16read[i] as expected.", state); + + result = parcel.ReadInt32Vector(&int32read); + AssertEqual(result, true, "result did not equal true as expected.", state); + LoopReadVectorCmpData(data.int32test, int32read, + "data.int32test[i] did not equal int32read[i] as expected.", state); + + result = parcel.ReadInt64Vector(&int64read); + AssertEqual(result, true, "result did not equal true as expected.", state); + LoopReadVectorCmpData(data.int64test, int64read, + "data.int64test[i] did not equal int64read[i] as expected.", state); + + result = parcel.ReadUInt8Vector(&uint8read); + AssertEqual(result, true, "result did not equal true as expected.", state); + LoopReadVectorCmpData(data.uint8test, uint8read, + "data.uint8test[i] did not equal uint8read[i] as expected.", state); + + result = parcel.ReadUInt16Vector(&uint16read); + AssertEqual(result, true, "result did not equal true as expected.", state); + LoopReadVectorCmpData(data.uint16test, uint16read, + "data.uint16test[i] did not equal uint16read[i] as expected.", state); + + result = parcel.ReadUInt32Vector(&uint32read); + AssertEqual(result, true, "result did not equal true as expected.", state); + LoopReadVectorCmpData(data.uint32test, uint32read, + "data.uint32test[i] did not equal uint32read[i] as expected.", state); + + result = parcel.ReadUInt64Vector(&uint64read); + AssertEqual(result, true, "result did not equal true as expected.", state); + LoopReadVectorCmpData(data.uint64test, uint64read, + "data.uint64test[i] did not equal uint64read[i] as expected.", state); +} + +/** + * @tc.name: test_parcel_WriteAndReadVector_001 + * @tc.desc: test vector parcel read and write. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_WriteAndReadVector_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndReadVector_001 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + struct VectorTestData data; + + WriteVectorTestData(parcel, data, state); + ReadVectorTestData(parcel, data, state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndReadVector_001 end."); +} + +/** + * @tc.name: test_parcel_WriteAndReadVector_002 + * @tc.desc: test vector parcel read and write. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_WriteAndReadVector_002)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndReadVector_002 start."); + while (state.KeepRunning()) { + Parcel parcel1(nullptr); + struct VectorTestData data; + WriteVectorTestData(parcel1, data, state); + + Parcel parcel2(nullptr); + AssertTrue(CopyOldParcelToNewParcel(parcel1, parcel2, state), + "CopyOldParcelToNewParcel(parcel1, parcel2, state) did not equal true as expected.", state); + ReadVectorTestData(parcel2, data, state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndReadVector_002 end."); +} + +/** + * @tc.name: test_parcel_WriteAndReadVector_003 + * @tc.desc: test vector parcel read and write. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_WriteAndReadVector_003)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndReadVector_003 start."); + while (state.KeepRunning()) { + Parcel parcel1(nullptr); + vector stringtest{ "test", "test for", "test for write", "test for write vector" }; + vector string16test{ u"test", u"test for", u"test for write", u"test for write vector" }; + bool result = parcel1.WriteStringVector(stringtest); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel1.WriteString16Vector(string16test); + AssertEqual(result, true, "result did not equal true as expected.", state); + + vector stringread; + result = parcel1.ReadStringVector(&stringread); + AssertEqual(result, true, "result did not equal true as expected.", state); + LoopReadVectorCmpData(stringtest, stringread, + "stringtest[i] did not equal stringread[i] as expected.", state); + + vector u16stringread; + result = parcel1.ReadString16Vector(&u16stringread); + AssertEqual(result, true, "result did not equal true as expected.", state); + LoopReadVectorCmpData(string16test, u16stringread, + "string16test[i].compare(u16stringread[i]) did not equal 0 as expected.", state); + + Parcel parcel2(nullptr); + AssertTrue(CopyOldParcelToNewParcel(parcel1, parcel2, state), + "CopyOldParcelToNewParcel(parcel1, parcel2, state) did not equal true as expected.", state); + + result = parcel2.ReadStringVector(&stringread); + AssertEqual(result, true, "result did not equal true as expected.", state); + LoopReadVectorCmpData(stringtest, stringread, + "stringtest[i] did not equal stringread[i] as expected.", state); + + result = parcel2.ReadString16Vector(&u16stringread); + AssertEqual(result, true, "result did not equal true as expected.", state); + LoopReadVectorCmpData(string16test, u16stringread, + "string16test[i].compare(u16stringread[i]) did not equal 0 as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndReadVector_003 end."); +} + +/** + * @tc.name: test_parcel_WriteAndReadVector_004 + * @tc.desc: test vector parcel read and write. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_WriteAndReadVector_004)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndReadVector_004 start."); + while (state.KeepRunning()) { + Parcel parcel1(nullptr); + Parcel parcel2(nullptr); + vector floattest{ 11221.132313, 11221.45678 }; + vector doubletest{ 1122.132313, 1122.45678 }; + + bool result = parcel1.WriteFloatVector(floattest); + AssertEqual(result, true, "result did not equal true as expected.", state); + + result = parcel1.WriteDoubleVector(doubletest); + AssertEqual(result, true, "result did not equal true as expected.", state); + + vector floatread; + vector doubleread; + + result = parcel1.ReadFloatVector(&floatread); + AssertEqual(result, true, "result did not equal true as expected.", state); + LoopReadVectorCmpData(floattest, floatread, + "floattest[i] did not equal floatread[i] as expected.", state); + + result = parcel1.ReadDoubleVector(&doubleread); + AssertEqual(result, true, "result did not equal true as expected.", state); + LoopReadVectorCmpData(doubletest, doubleread, + "doubletest[i] did not equal doubleread[i] as expected.", state); + } +} + +bool CallWriteVector(Parcel &parcel, const std::vector &vectorTest) +{ + BENCHMARK_LOGD("ParcelTest bool CallWriteVector is called."); + return parcel.WriteBoolVector(vectorTest); +} + +bool CallWriteVector(Parcel &parcel, const std::vector &vectorTest) +{ + BENCHMARK_LOGD("ParcelTest bool CallWriteVector is called."); + return parcel.WriteInt8Vector(vectorTest); +} + +bool CallWriteVector(Parcel &parcel, const std::vector &vectorTest) +{ + BENCHMARK_LOGD("ParcelTest bool CallWriteVector is called."); + return parcel.WriteInt16Vector(vectorTest); +} + +bool CallWriteVector(Parcel &parcel, const std::vector &vectorTest) +{ + BENCHMARK_LOGD("ParcelTest bool CallWriteVector is called."); + return parcel.WriteInt32Vector(vectorTest); +} + +bool CallWriteVector(Parcel &parcel, const std::vector &vectorTest) +{ + BENCHMARK_LOGD("ParcelTest bool CallWriteVector is called."); + return parcel.WriteInt64Vector(vectorTest); +} + +bool CallWriteVector(Parcel &parcel, const std::vector &vectorTest) +{ + BENCHMARK_LOGD("ParcelTest bool CallWriteVector is called."); + return parcel.WriteUInt8Vector(vectorTest); +} + +bool CallWriteVector(Parcel &parcel, const std::vector &vectorTest) +{ + BENCHMARK_LOGD("ParcelTest bool CallWriteVector is called."); + return parcel.WriteUInt16Vector(vectorTest); +} + +bool CallWriteVector(Parcel &parcel, const std::vector &vectorTest) +{ + BENCHMARK_LOGD("ParcelTest bool CallWriteVector is called."); + return parcel.WriteUInt32Vector(vectorTest); +} + +bool CallWriteVector(Parcel &parcel, const std::vector &vectorTest) +{ + BENCHMARK_LOGD("ParcelTest bool CallWriteVector is called."); + return parcel.WriteUInt64Vector(vectorTest); +} + +bool CallWriteVector(Parcel &parcel, const std::vector &vectorTest) +{ + BENCHMARK_LOGD("ParcelTest bool CallWriteVector is called."); + return parcel.WriteFloatVector(vectorTest); +} + +bool CallWriteVector(Parcel &parcel, const std::vector &vectorTest) +{ + BENCHMARK_LOGD("ParcelTest bool CallWriteVector is called."); + return parcel.WriteDoubleVector(vectorTest); +} + +bool CallWriteVector(Parcel &parcel, const std::vector &vectorTest) +{ + BENCHMARK_LOGD("ParcelTest bool CallWriteVector is called."); + return parcel.WriteStringVector(vectorTest); +} + +bool CallWriteVector(Parcel &parcel, const std::vector &vectorTest) +{ + BENCHMARK_LOGD("ParcelTest bool CallWriteVector is called."); + return parcel.WriteString16Vector(vectorTest); +} + +template +void ParcelWriteVector(const std::vector &vectorTest, benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest void ParcelWriteVector is called."); + Parcel parcel1(nullptr); + Parcel parcel2(nullptr); + bool result = CallWriteVector(parcel1, vectorTest); + AssertEqual(result, true, "result did not equal true as expected.", state); + AssertTrue(CopyOldParcelToNewParcel(parcel1, parcel2, state), + "CopyOldParcelToNewParcel(parcel1, parcel2, state) did not equal true as expected.", state); + + result = CallWriteVector(parcel2, vectorTest); + AssertEqual(result, false, "result did not equal false as expected.", state); +} + +/** + * @tc.name: test_parcel_WriteAndReadVector_005 + * @tc.desc: test vector parcel write failed. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_WriteAndReadVector_005)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndReadVector_005 start."); + while (state.KeepRunning()) { + vector boolVectorTest { true, false }; + vector int8VectorTest { 1, 0 }; + vector int16VectorTest { 1, 0 }; + vector int32VectorTest { 1, 0 }; + vector int64VectorTest { 1, 0 }; + vector uint8VectorTest { 1, 0 }; + vector uint16VectorTest { 1, 0 }; + vector uint32VectorTest { 1, 0 }; + vector uint64VectorTest { 1, 0 }; + vector floatVectorTest { 1.1, 0 }; + vector doubleVectorTest { 1.1, 0 }; + vector stringVectorTest { "true", "false" }; + vector string16VectorTest { u"true", u"false" }; + + ParcelWriteVector(boolVectorTest, state); + ParcelWriteVector(int8VectorTest, state); + ParcelWriteVector(int16VectorTest, state); + ParcelWriteVector(int32VectorTest, state); + ParcelWriteVector(int64VectorTest, state); + ParcelWriteVector(uint8VectorTest, state); + ParcelWriteVector(uint16VectorTest, state); + ParcelWriteVector(uint32VectorTest, state); + ParcelWriteVector(uint64VectorTest, state); + ParcelWriteVector(floatVectorTest, state); + ParcelWriteVector(doubleVectorTest, state); + ParcelWriteVector(stringVectorTest, state); + ParcelWriteVector(string16VectorTest, state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndReadVector_005 end."); +} + +class TestParcelable : public virtual Parcelable { +public: + TestParcelable() = default; + ~TestParcelable() = default; + + bool Marshalling(Parcel &parcel) const override; + static TestParcelable *Unmarshalling(Parcel &parcel); + +public: + int32_t int32Write_ = -0x12345678; + int32_t int32Read_; +}; + +bool TestParcelable::Marshalling(Parcel &parcel) const +{ + BENCHMARK_LOGD("ParcelTest bool TestParcelable::Marshalling is called."); + bool result = parcel.WriteInt32(this->int32Write_); + return result; +} + +TestParcelable *TestParcelable::Unmarshalling(Parcel &parcel) +{ + BENCHMARK_LOGD("ParcelTest TestParcelable *TestParcelable::Unmarshalling is called."); + auto *read = new TestParcelable(); + read->int32Read_ = parcel.ReadInt32(); + return read; +} + +/** + * @tc.name: test_parcel_parcelable_001 + * @tc.desc: test parcel read and write parcelable obj. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_parcelable_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_parcelable_001 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + sptr parcelableWrite = new TestParcelable(); + bool result = false; + + result = parcel.WriteParcelable(parcelableWrite); + AssertEqual(result, true, "result did not equal true as expected.", state); + AssertEqual(parcel.GetWritePosition(), parcel.GetDataSize(), + "parcel.GetWritePosition() did not equal parcel.GetDataSize() as expected.", state); + + sptr parcelableRead = parcel.ReadParcelable(); + AssertEqual(parcelableWrite->int32Write_, parcelableRead->int32Read_, + "parcelableWrite->int32Write_ did not equal parcelableRead->int32Read_ as expected.", state); + AssertEqual(parcel.GetReadPosition(), parcel.GetDataSize(), + "parcel.GetReadPosition() did not equal parcel.GetDataSize() as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_parcelable_001 end."); +} + +/** + * @tc.name: test_parcel_parcelable_002 + * @tc.desc: test parcel read and write parcelable obj. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_parcelable_002)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_parcelable_002 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + bool result = parcel.WriteParcelable(nullptr); + AssertEqual(result, true, "result did not equal true as expected.", state); + + sptr parcelableRead = parcel.ReadParcelable(); + AssertEqual(nullptr, parcelableRead, "nullptr did not equal parcelableRead as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_parcelable_002 end."); +} + +/** + * @tc.name: test_parcel_parcelable_003 + * @tc.desc: test parcel read and write parcelable obj. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_parcelable_003)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_parcelable_003 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + sptr parcelableWriteNull; + bool result = parcel.WriteStrongParcelable(parcelableWriteNull); + AssertEqual(result, true, "result did not equal true as expected.", state); + + sptr parcelableWrite = new TestParcelable(); + + bool test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::HOLD_OBJECT); + AssertEqual(test, false, "test did not equal false as expected.", state); + + test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::IPC); + AssertEqual(test, false, "test did not equal false as expected.", state); + + test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::RPC); + AssertEqual(test, false, "test did not equal false as expected.", state); + + result = parcel.WriteStrongParcelable(parcelableWrite); + AssertEqual(result, true, "result did not equal true as expected.", state); + + sptr parcelableReadNull = parcel.ReadParcelable(); + AssertEqual(nullptr, parcelableReadNull, + "nullptr did not equal parcelableReadNull as expected.", state); + + sptr parcelableRead = parcel.ReadParcelable(); + AssertEqual(parcelableWrite->int32Write_, parcelableRead->int32Read_, + "parcelableWrite->int32Write_ did not equal parcelableRead->int32Read_ as expected.", state); + + test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::HOLD_OBJECT); + AssertEqual(test, true, "test did not equal true as expected.", state); + + test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::IPC); + AssertEqual(test, false, "test did not equal false as expected.", state); + + test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::RPC); + AssertEqual(test, false, "test did not equal false as expected.", state); + + parcelableWrite->ClearBehavior(Parcelable::BehaviorFlag::HOLD_OBJECT); + test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::HOLD_OBJECT); + AssertEqual(test, false, "test did not equal false as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_parcelable_003 end."); +} + +/** + * @tc.name: test_SetMaxCapacity_001 + * @tc.desc: test parcel capacity function. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_SetMaxCapacity_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_SetMaxCapacity_001 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + char test[PARCEL_TEST_CHAR_ARRAY_SIZE] = {0}; + bool ret = parcel.WriteBuffer(test, PARCEL_TEST_CHAR_ARRAY_SIZE); + AssertEqual(ret, true, "ret did not equal true as expected.", state); + + // because default maxCap is 200 * 1024, so reset it more + const size_t maxCapacitySize = 201 * 1024; + parcel.SetMaxCapacity(maxCapacitySize); + // test write data over max capacity: 205780 + 48 > 201 * 1024 + char test2[PARCEL_TEST1_CHAR_ARRAY_SIZE] = {0}; + ret = parcel.WriteBuffer(test2, PARCEL_TEST1_CHAR_ARRAY_SIZE); + AssertEqual(ret, false, "ret did not equal false as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_SetMaxCapacity_001 end."); +} + +/** + * @tc.name: test_SetMaxCapacity_002 + * @tc.desc: test parcel capacity function. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_SetMaxCapacity_002)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_SetMaxCapacity_002 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + char test[PARCEL_TEST_CHAR_ARRAY_SIZE] = {0}; + bool ret = parcel.WriteInt32(5767168); + AssertEqual(ret, true, "ret did not equal true as expected.", state); + + ret = parcel.WriteBuffer(test, PARCEL_TEST_CHAR_ARRAY_SIZE); + AssertEqual(ret, true, "ret did not equal true as expected.", state); + + vector val; + ret = parcel.ReadString16Vector(&val); + AssertEqual(ret, false, "ret did not equal false as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_SetMaxCapacity_002 end."); +} + +BENCHMARK_F(BenchmarkParcelTest, test_ValidateReadData_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_ValidateReadData_001 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + parcel.WriteBool(true); + string strWrite = "test"; + bool result = parcel.WriteString(strWrite); + AssertEqual(result, true, "result did not equal true as expected.", state); + + RemoteObject obj1; + result = parcel.WriteRemoteObject(&obj1); + AssertEqual(result, true, "result did not equal true as expected.", state); + + parcel.WriteInt32(WRITE_AND_CMP_INT32_VALUE); + RemoteObject obj2; + result = parcel.WriteRemoteObject(&obj2); + AssertEqual(result, true, "result did not equal true as expected.", state); + + u16string str16Write = u"12345"; + result = parcel.WriteString16(str16Write); + AssertEqual(result, true, "result did not equal true as expected.", state); + + bool readBool = parcel.ReadBool(); + AssertEqual(readBool, true, "readBool did not equal true as expected.", state); + + string strRead = parcel.ReadString(); + AssertEqual(COMPARE_STRING_RESULT, strcmp(strRead.c_str(), strWrite.c_str()), + "strcmp(strRead.c_str(), strWrite.c_str()) did not equal 0 as expected.", state); + + sptr readObj1 = parcel.ReadObject(); + AssertEqual(true, (readObj1.GetRefPtr() != nullptr), + "(readObj1.GetRefPtr() != nullptr) did not equal true as expected.", state); + + int32_t readInt32 = parcel.ReadInt32(); + AssertEqual(readInt32, WRITE_AND_CMP_INT32_VALUE, "readInt32 did not equal 5 as expected.", state); + + sptr readObj2 = parcel.ReadObject(); + AssertEqual(true, (readObj2.GetRefPtr() != nullptr), + "(readObj2.GetRefPtr() != nullptr) did not equal true as expected.", state); + + u16string str16Read = parcel.ReadString16(); + AssertEqual(COMPARE_STRING_RESULT, str16Read.compare(str16Write), + "str16Read.compare(str16Write) did not equal 0 as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_ValidateReadData_001 end."); +} + +BENCHMARK_F(BenchmarkParcelTest, test_ValidateReadData_002)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_ValidateReadData_002 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + parcel.WriteBool(true); + string strWrite = "test"; + bool result = parcel.WriteString(strWrite); + AssertEqual(result, true, "result did not equal true as expected.", state); + + RemoteObject obj1; + result = parcel.WriteRemoteObject(&obj1); + AssertEqual(result, true, "result did not equal true as expected.", state); + + parcel.WriteInt32(WRITE_AND_CMP_INT32_VALUE); + RemoteObject obj2; + result = parcel.WriteRemoteObject(&obj2); + AssertEqual(result, true, "result did not equal true as expected.", state); + + u16string str16Write = u"12345"; + result = parcel.WriteString16(str16Write); + AssertEqual(result, true, "result did not equal true as expected.", state); + + bool readBool = parcel.ReadBool(); + AssertEqual(readBool, true, "readBool did not equal true as expected.", state); + + string strRead = parcel.ReadString(); + AssertEqual(COMPARE_STRING_RESULT, strcmp(strRead.c_str(), strWrite.c_str()), + "strcmp(strRead.c_str(), strWrite.c_str()) did not equal 0 as expected.", state); + + int32_t readInt32 = parcel.ReadInt32(); + int32_t compareInt32Value = 0; + AssertEqual(readInt32, compareInt32Value, "readInt32 did not equal 0 as expected.", state); + + u16string str16Read = parcel.ReadString16(); + AssertEqual(COMPARE_STRING_RESULT, str16Read.compare(std::u16string()), + "str16Read.compare(std::u16string()) did not equal 0 as expected.", state); + + sptr readObj1 = parcel.ReadObject(); + AssertEqual(true, (readObj1.GetRefPtr() == nullptr), + "(readObj1.GetRefPtr() == nullptr) did not equal true as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_ValidateReadData_002 end."); +} + +BENCHMARK_F(BenchmarkParcelTest, test_RewindWrite_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_RewindWrite_001 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + parcel.WriteInt32(WRITE_AND_CMP_INT32_VALUE); + string strWrite = "test"; + parcel.WriteString(strWrite); + RemoteObject obj1; + parcel.WriteRemoteObject(&obj1); + size_t pos = parcel.GetWritePosition(); + parcel.WriteInt32(WRITE_AND_CMP_INT32_VALUE); + RemoteObject obj2; + parcel.WriteRemoteObject(&obj2); + u16string str16Write = u"12345"; + parcel.WriteString16(str16Write); + + bool result = parcel.RewindWrite(pos); + AssertEqual(result, true, "result did not equal true as expected.", state); + parcel.WriteInt32(WRITE_AND_CMP_INT32_VALUE); + parcel.WriteInt32(WRITE_AND_CMP_INT32_VALUE); + + int32_t readint32 = parcel.ReadInt32(); + AssertEqual(readint32, WRITE_AND_CMP_INT32_VALUE, "readint32 did not equal 5 as expected.", state); + + string strRead = parcel.ReadString(); + AssertEqual(COMPARE_STRING_RESULT, strcmp(strRead.c_str(), strWrite.c_str()), + "strcmp(strRead.c_str(), strWrite.c_str()) did not equal 0 as expected.", state); + + sptr readObj1 = parcel.ReadObject(); + AssertEqual(true, (readObj1.GetRefPtr() != nullptr), + "(readObj1.GetRefPtr() != nullptr) did not equal true as expected.", state); + + readint32 = parcel.ReadInt32(); + AssertEqual(readint32, WRITE_AND_CMP_INT32_VALUE, "readint32 did not equal 5 as expected.", state); + + sptr readObj2 = parcel.ReadObject(); + AssertEqual(true, (readObj2.GetRefPtr() == nullptr), + "(readObj2.GetRefPtr() == nullptr) did not equal true as expected.", state); + readint32 = parcel.ReadInt32(); + AssertEqual(readint32, WRITE_AND_CMP_INT32_VALUE, "readint32 did not equal 5 as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_RewindWrite_001 end."); +} + +BENCHMARK_F(BenchmarkParcelTest, test_RewindWrite_002)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_RewindWrite_002 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + parcel.WriteInt32(WRITE_AND_CMP_INT32_VALUE); + string strWrite = "test"; + parcel.WriteString(strWrite); + RemoteObject obj1; + parcel.WriteRemoteObject(&obj1); + parcel.WriteInt32(WRITE_AND_CMP_INT32_VALUE); + RemoteObject obj2; + parcel.WriteRemoteObject(&obj2); + size_t pos = parcel.GetWritePosition(); + u16string str16Write = u"12345"; + parcel.WriteString16(str16Write); + bool result = parcel.RewindWrite(pos); + AssertEqual(result, true, "result did not equal true as expected.", state); + + int32_t readint32 = parcel.ReadInt32(); + AssertEqual(readint32, WRITE_AND_CMP_INT32_VALUE, "readint32 did not equal 5 as expected.", state); + + string strRead = parcel.ReadString(); + AssertEqual(COMPARE_STRING_RESULT, strcmp(strRead.c_str(), strWrite.c_str()), + "strcmp(strRead.c_str(), strWrite.c_str()) did not equal 0 as expected.", state); + + uint32_t readUint32 = parcel.ReadUint32(); + uint32_t compareUint32Value = 0; + AssertEqual(readUint32, compareUint32Value, "readUint32 did not equal 0 as expected.", state); + + string strRead2 = parcel.ReadString(); + AssertEqual(COMPARE_STRING_RESULT, strRead2.compare(std::string()), + "strRead2.compare(std::string()) did not equal 0 as expected.", state); + + sptr readObj1 = parcel.ReadObject(); + AssertEqual(true, (readObj1.GetRefPtr() == nullptr), + "(readObj1.GetRefPtr() == nullptr) did not equal true as expected.", state); + + double compareDoubleValue = 0; + double readDouble = parcel.ReadDouble(); + AssertEqual(readDouble, compareDoubleValue, "readDouble did not equal 0 as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_RewindWrite_002 end."); +} + +enum ParcelVectorValue { + VALUE_ZERO = 0, + VALUE_ONE = 1, + VALUE_TWO = 2, + VALUE_THREE = 3, + VALUE_FORE = 4, + VALUE_FIVE = 5 +}; +enum ParcelVectorIndex { + INDEX_ZERO = 0, + INDEX_ONE = 1, + INDEX_TWO = 2, + INDEX_THREE = 3, + INDEX_FORE = 4, + INDEX_FIVE = 5 +}; + +BENCHMARK_F(BenchmarkParcelTest, test_RewindWrite_003)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_RewindWrite_003 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + std::vector val{VALUE_ONE, VALUE_TWO, VALUE_THREE, VALUE_FORE, VALUE_FIVE}; + AssertEqual(val.size(), REWINDWRITE003_VECTOR_LENGTH, "val.size() did not equal 5 as expected.", state); + bool result = parcel.WriteInt32Vector(val); + AssertEqual(result, true, "result did not equal true as expected.", state); + size_t pos = parcel.GetWritePosition() - sizeof(int32_t); + result = parcel.RewindWrite(pos); + AssertEqual(result, true, "result did not equal true as expected.", state); + + RemoteObject obj; + parcel.WriteRemoteObject(&obj); + std::vector int32Read; + result = parcel.ReadInt32Vector(&int32Read); + AssertEqual(result, false, "result did not equal false as expected.", state); + AssertEqual(int32Read.size(), REWINDWRITE003_VECTOR_LENGTH, + "int32Read.size() did not equal 5 as expected.", state); + AssertEqual(int32Read[INDEX_ZERO], VALUE_ONE, "int32Read[0] did not equal 1 as expected.", state); + AssertEqual(int32Read[INDEX_ONE], VALUE_TWO, "int32Read[1] did not equal 2 as expected.", state); + AssertEqual(int32Read[INDEX_TWO], VALUE_THREE, "int32Read[2] did not equal 3 as expected.", state); + AssertEqual(int32Read[INDEX_THREE], VALUE_FORE, "int32Read[3] did not equal 4 as expected.", state); + AssertEqual(int32Read[INDEX_FORE], VALUE_ZERO, "int32Read[4] did not equal 0 as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_RewindWrite_003 end."); +} + +/** + * @tc.name: test_GetDataCapacity_001 + * @tc.desc: test kinds of input to SetDataCapacity. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_GetDataCapacity_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_GetDataCapacity_001 start."); + while (state.KeepRunning()) { + Parcel parcel; + size_t size = parcel.GetDataCapacity(); + AssertEqual(size, DATA_CAPACITY_INIT_SIZE, + "test_GetDataCapacity_001 size did not equal zero as expected.", state); + + struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 }; + WriteTestData(parcel, data, state); + size = parcel.GetDataCapacity(); + AssertUnequal(size, DATA_CAPACITY_INIT_SIZE, + "test_GetDataCapacity_001 size equal zero as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_GetDataCapacity_001 end."); +} + +/** + * @tc.name: test_GetMaxCapacity_001 + * @tc.desc: test parcel capacity function. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_GetMaxCapacity_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_GetMaxCapacity_001 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + size_t size = parcel.GetMaxCapacity(); + AssertEqual(size, DEFAULT_CPACITY, + "test_GetMaxCapacity_001 size did not equal DEFAULT_CPACITY as expected.", state); + + size_t maxCapacity = DEFAULT_CPACITY * 2; + bool result = parcel.SetMaxCapacity(maxCapacity); + AssertEqual(result, true, "test_GetMaxCapacity_001 result did not equal true as expected.", state); + + size = parcel.GetMaxCapacity(); + AssertEqual(size, maxCapacity, + "test_GetMaxCapacity_001 size did not equal to maxCapacity as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_GetMaxCapacity_001 end."); +} + +/** + * @tc.name: test_GetObjectOffsets_001 + * @tc.desc: test parcel Object offsets function. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_GetObjectOffsets_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_GetObjectOffsets_001 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + binder_size_t* pObjectOffsets = reinterpret_cast(parcel.GetObjectOffsets()); + AssertEqual(pObjectOffsets, nullptr, + "test_GetObjectOffsets_001 pObjectOffsets did not equal to nullptr as expected.", state); + + RemoteObject obj; + bool result = parcel.WriteRemoteObject(&obj); + AssertEqual(result, true, + "test_GetObjectOffsets_001 result did not equal true as expected.", state); + + pObjectOffsets = reinterpret_cast(parcel.GetObjectOffsets()); + AssertUnequal(pObjectOffsets, nullptr, + "test_GetObjectOffsets_001 pObjectOffsets equal nullptr as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_GetObjectOffsets_001 end."); +} + +/** + * @tc.name: test_GetOffsetsSize_001 + * @tc.desc: test parcel Object offsets Size function. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_GetOffsetsSize_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_GetOffsetsSize_001 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + size_t size = parcel.GetOffsetsSize(); + AssertEqual(size, DATA_OFFSETS_INIT_SIZE, + "test_GetOffsetsSize_001 size did not equal to 0 as expected.", state); + + RemoteObject obj; + bool result = parcel.WriteRemoteObject(&obj); + AssertEqual(result, true, "test_GetOffsetsSize_001 result did not equal true as expected.", state); + + size = parcel.GetOffsetsSize(); + AssertUnequal(size, DATA_OFFSETS_INIT_SIZE, "test_GetOffsetsSize_001 size equal 0 as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_GetOffsetsSize_001 end."); +} + +/** + * @tc.name: test_GetReadableBytes_001 + * @tc.desc: test parcel readable bytes function. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_GetReadableBytes_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_GetReadableBytes_001 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + int8_t writeInt8 = 0x34; + bool result = parcel.WriteInt8(writeInt8); + AssertEqual(result, true, "test_GetReadableBytes_001 result did not equal true as expected.", state); + + size_t size = parcel.GetReadableBytes(); + AssertUnequal(size, DATA_READBYTES_INIT_SIZE, "test_GetReadableBytes_001 size equal 0 as expected.", state); + + int8_t readint8 = parcel.ReadInt8(); + AssertEqual(readint8, writeInt8, + "test_GetReadableBytes_001 readint8 not equal writeInt8 as expected.", state); + + size = parcel.GetReadableBytes(); + AssertEqual(size, DATA_READBYTES_INIT_SIZE, + "test_GetReadableBytes_001 size did not equal 0 as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_GetReadableBytes_001 end."); +} + +/** + * @tc.name: test_GetWritableBytes_001 + * @tc.desc: test parcel writable bytes function. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_GetWritableBytes_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_GetWritableBytes_001 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + int8_t writeInt8 = 0x34; + bool result = parcel.WriteInt8(writeInt8); + AssertEqual(result, true, "test_GetWritableBytes_001 result did not equal true as expected.", state); + + size_t size = parcel.GetDataCapacity() - sizeof(int32_t); + size_t writablesize = parcel.GetWritableBytes(); + AssertEqual(writablesize, size, + "test_GetWritableBytes_001 writablesize did not equal size as expected.", state); + + int16_t writeInt16 = 0x1234; + result = parcel.WriteInt16(writeInt16); + AssertEqual(result, true, "test_GetWritableBytes_001 result did not equal true as expected.", state); + + size = parcel.GetDataCapacity() - (sizeof(int32_t)*2); + writablesize = parcel.GetWritableBytes(); + AssertEqual(writablesize, size, + "test_GetWritableBytes_001 writablesize did not equal size as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_GetWritableBytes_001 end."); +} + +/** + * @tc.name: test_InjectOffsets_001 + * @tc.desc: test parcel inject offsets function. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_InjectOffsets_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_InjectOffsets_001 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + int32_t size = 256; + bool result = parcel.WriteInt32(size); + AssertEqual(result, true, "test_InjectOffsets_001 result did not equal true as expected.", state); + + binder_size_t objectOffsets[PARCEL_INJECTOFFSETS_CHAR_ARRAY_SIZE] = {0}; + result = parcel.WriteBuffer(static_cast(objectOffsets), sizeof(binder_size_t) * size); + AssertEqual(result, true, "test_InjectOffsets_001 result did not equal true as expected.", state); + + int32_t offsetSize = parcel.ReadInt32(); + AssertEqual(offsetSize, size, "test_InjectOffsets_001 offsetSize did not equal size as expected.", state); + + const uint8_t* offsets = parcel.ReadBuffer(sizeof(binder_size_t) * offsetSize); + AssertUnequal(offsets, nullptr, "test_InjectOffsets_001 offsets equal nullptr as expected.", state); + + Parcel newParcel(nullptr); + newParcel.InjectOffsets(reinterpret_cast(offsets), offsetSize); + + binder_size_t* pObjectOffsets = reinterpret_cast(newParcel.GetObjectOffsets()); + AssertUnequal(pObjectOffsets, nullptr, + "test_InjectOffsets_001 pObjectOffsets equal nullptr as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_InjectOffsets_001 end."); +} + +/** + * @tc.name: test_parcel_WriteAndRead_Float_002 + * @tc.desc: test parcel write and read write. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_WriteAndRead_Float_002)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_Float_002 start."); + while (state.KeepRunning()) { + Parcel parcel1(nullptr); + float floatwrite = 12.345678f; + bool result = parcel1.WriteFloat(floatwrite); + AssertEqual(result, true, "test_parcel_WriteAndRead_Float_002 result did not equal true as expected.", state); + + double doublewrite = 1345.7653; + result = parcel1.WriteDouble(doublewrite); + AssertEqual(result, true, "test_parcel_WriteAndRead_Float_002 result did not equal true as expected.", state); + + float floatread = parcel1.ReadFloat(); + AssertEqual(floatread, floatwrite, + "test_parcel_WriteAndRead_Float_002 floatread did not equal floatwrite as expected.", state); + + double doubleread; + result = parcel1.ReadDouble(doubleread); + AssertEqual(result, true, "test_parcel_WriteAndRead_Float_002 result did not equal true as expected.", state); + AssertEqual(doubleread, doublewrite, + "test_parcel_WriteAndRead_Float_002 doublewrite did not equal doubleread as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_Float_002 end."); +} +/** + * @tc.name: test_parcel_WriteAndRead_005 + * @tc.desc: test parcel write and read write. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_WriteAndRead_005)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_005 start."); + while (state.KeepRunning()) { + Parcel parcel1(nullptr); + int64_t int64test = -0x1234567887654321; + bool result = parcel1.WriteInt64(int64test); + AssertEqual(result, true, "test_parcel_WriteAndRead_005 result did not equal true as expected.", state); + + uint64_t uint64test = 0x1234567887654321; + result = parcel1.WriteUint64(uint64test); + AssertEqual(result, true, "test_parcel_WriteAndRead_005 result did not equal true as expected.", state); + + int64_t readint64; + result = parcel1.ReadInt64(readint64); + AssertEqual(result, true, "test_parcel_WriteAndRead_005 result did not equal true as expected.", state); + AssertEqual(readint64, int64test, + "test_parcel_WriteAndRead_005 readint64 did not equal int64test as expected.", state); + + uint64_t readuint64; + result = parcel1.ReadUint64(readuint64); + AssertEqual(result, true, "test_parcel_WriteAndRead_005 result did not equal true as expected.", state); + AssertEqual(readuint64, uint64test, + "test_parcel_WriteAndRead_005 readuint64 did not equal uint64test as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_005 end."); +} + +/** + * @tc.name: test_ReadPointer_001 + * @tc.desc: test parcel read pointer function. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_ReadPointer_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_ReadPointer_001 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + char writePointer[PARCEL_WRITEPOINTER_CHAR_ARRAY_SIZE] = {0}; + bool result = parcel.WritePointer((uintptr_t)writePointer); + AssertEqual(result, true, "test_ReadPointer_001 result did not equal true as expected.", state); + + char* readPointer = reinterpret_cast(parcel.ReadPointer()); + AssertEqual(readPointer, writePointer, + "test_ReadPointer_001 readPointer did not equal writePointer as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_ReadPointer_001 end."); +} + +/** + * @tc.name: test_parcel_WriteAndRead_String006 + * @tc.desc: test parcel CString read write. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_WriteAndRead_String006)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_String006 start."); + while (state.KeepRunning()) { + Parcel parcel1(nullptr); + u16string str16Write = u"12345"; + bool result = parcel1.WriteString16(str16Write); + AssertEqual(result, true, "test_parcel_WriteAndRead_String006 result did not equal true as expected.", state); + + u16string str16Read; + result = parcel1.ReadString16(str16Read); + AssertEqual(result, true, "test_parcel_WriteAndRead_String006 result did not equal true as expected.", state); + AssertEqual(COMPARE_STRING_RESULT, str16Read.compare(str16Write), + "test_parcel_WriteAndRead_String006 str16Read.compare(str16Write) did not equal 0 as expected.", state); + + Parcel parcel2(nullptr); + AssertTrue(CopyOldParcelToNewParcel(parcel1, parcel2, state), + "CopyOldParcelToNewParcel(parcel1, parcel2, state) did not equal true as expected.", state); + + result = parcel2.ReadString16(str16Read); + AssertEqual(result, true, "test_parcel_WriteAndRead_String006 result did not equal true as expected.", state); + AssertEqual(COMPARE_STRING_RESULT, str16Read.compare(str16Write), + "test_parcel_WriteAndRead_String006 str16Read.compare(str16Write) did not equal 0 as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_WriteAndRead_String006 end."); +} + +/** + * @tc.name: test_parcel_parcelable_004 + * @tc.desc: test parcel ReadStrongParcelable obj. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_parcel_parcelable_004)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_parcel_parcelable_004 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + sptr parcelableWrite = new TestParcelable(); + bool result = parcel.WriteStrongParcelable(parcelableWrite); + AssertEqual(result, true, "test_parcel_parcelable_004 result did not equal true as expected.", state); + + sptr parcelableRead = parcel.ReadStrongParcelable(); + AssertUnequal(nullptr, parcelableRead, + "test_parcel_parcelable_004 nullptr equal to parcelableRead as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_parcel_parcelable_004 end."); +} + +/** + * @tc.name: test_SkipBytes_001 + * @tc.desc: test parcel Skip Bytes function. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_SkipBytes_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_SkipBytes_001 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + char buffer[CAPACITY_THRESHOLD] = {0}; + bool result = parcel.WriteBuffer(static_cast(buffer), CAPACITY_THRESHOLD); + AssertEqual(result, true, "test_SkipBytes_001 result did not equal true as expected.", state); + + size_t skipSize = 1024; + parcel.SkipBytes(skipSize); + size_t readableSize = parcel.GetReadableBytes(); + AssertEqual((skipSize+readableSize), CAPACITY_THRESHOLD, + "test_SkipBytes_001 (skipSize+readableSize) did not equal CAPACITY_THRESHOLD as expected.", state); + + skipSize = CAPACITY_THRESHOLD; + parcel.SkipBytes(skipSize); + readableSize = parcel.GetReadableBytes(); + AssertEqual(readableSize, DATA_READBYTES_INIT_SIZE, + "test_SkipBytes_001 readableSize did not equal 0 as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_SkipBytes_001 end."); +} + +/** + * @tc.name: test_WriteObject_001 + * @tc.desc: test parcel Write Object function. + * @tc.type: FUNC + */ +BENCHMARK_F(BenchmarkParcelTest, test_WriteObject_001)(benchmark::State& state) +{ + BENCHMARK_LOGD("ParcelTest test_WriteObject_001 start."); + while (state.KeepRunning()) { + Parcel parcel(nullptr); + sptr remoteWriteNUll; + bool result = parcel.WriteObject(remoteWriteNUll); + AssertEqual(result, false, "test_WriteObject_001 result did not equal false as expected.", state); + + sptr parcelableWrite = new RemoteObject(); + result = parcel.WriteObject(parcelableWrite); + AssertEqual(result, true, "test_WriteObject_001 result did not equal true as expected.", state); + + sptr parcelableRead = parcel.ReadObject(); + AssertEqual((parcelableRead.GetRefPtr() != nullptr), true, + "test_WriteObject_001 (parcelableRead.GetRefPtr() != nullptr) did not equal true as expected.", state); + } + BENCHMARK_LOGD("ParcelTest test_WriteObject_001 end."); +} +} // namespace +} // namespace OHOS +// Run the benchmark +BENCHMARK_MAIN(); \ No newline at end of file diff --git a/base/test/benchmarktest/refbase_benchmark_test/BUILD.gn b/base/test/benchmarktest/refbase_benchmark_test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..e6039f2e31c99f2447fc162389ff98dfd503dc8f --- /dev/null +++ b/base/test/benchmarktest/refbase_benchmark_test/BUILD.gn @@ -0,0 +1,35 @@ +# Copyright (c) 2023 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") + +module_output_path = "commonlibrary_c_utils/refbase" + +ohos_benchmarktest("RefbaseTest") { + module_out_path = module_output_path + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + sources = [ "refbase_benchmark_test.cpp" ] + + deps = [ "//third_party/benchmark:benchmark" ] + + external_deps = [ + "c_utils:utils", + "hilog:libhilog_base", + ] +} diff --git a/base/test/benchmarktest/refbase_benchmark_test/refbase_benchmark_test.cpp b/base/test/benchmarktest/refbase_benchmark_test/refbase_benchmark_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..15356896412e38ec39f77a577e461bd75ac8c8b1 --- /dev/null +++ b/base/test/benchmarktest/refbase_benchmark_test/refbase_benchmark_test.cpp @@ -0,0 +1,1892 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "refbase.h" +#include "singleton.h" +#include "../log.h" +#include "../assert.h" +#include +using namespace std; + +namespace OHOS { +namespace { + +class BenchmarkRefbaseTest : public benchmark::Fixture { + public: + BenchmarkRefbaseTest() + { + Iterations(iterations); + Repetitions(repetitions); + ReportAggregatesOnly(); + } + + ~BenchmarkRefbaseTest() override = default; + + void SetUp(const ::benchmark::State &state) override + { + } + + void TearDown(const ::benchmark::State &state) override + { + } + + protected: + const int32_t repetitions = 3; + const int32_t iterations = 1000; +}; + +static constexpr int FLAG_OF_CONS = 1; +static constexpr int FLAG_OF_DEST = 2; +static int g_sptrCount = 0; +static int g_refbaseflag = 0; +static int g_freeFlag = 0; +constexpr int EXPECTED_REF_COUNT_ZERO = 0; +constexpr int EXPECTED_REF_COUNT_ONE = 1; +constexpr int EXPECTED_REF_COUNT_TWO = 2; +constexpr int EXPECTED_REF_COUNT_THREE = 3; +constexpr int EXPECTED_REF_COUNT_FOUR = 4; + +class RefBaseTest : public RefBase { +public: + RefBaseTest() + { + g_refbaseflag = FLAG_OF_CONS; + isgetrefptr_ = false; + } + ~RefBaseTest() + { + g_refbaseflag = FLAG_OF_DEST; + } + + void OnLastStrongRef(const void *objectId) override + { + g_freeFlag = 1; + } + + void SetRefPtr() + { + isgetrefptr_ = true; + } + bool GetTestRefPtrFlag() + { + return isgetrefptr_; + } + +private: + bool isgetrefptr_; +}; + +class IRemoteObject : public virtual RefBase { +public: + IRemoteObject() + { + ExtendObjectLifetime(); + } + virtual bool IsProxyObject() = 0; + ~IRemoteObject() {} +}; + +class RefBaseTestTracker : public RefBase { +public: + explicit RefBaseTestTracker(int value) : value_(value) + { + checkCount_++; + } + RefBaseTestTracker() = default; + ~RefBaseTestTracker() + { + BENCHMARK_LOGD("RefbaseTest ~RefBaseTestTracker() is called."); + checkCount_--; + } + + RefBaseTestTracker(const RefBaseTestTracker &testTracker) + { + BENCHMARK_LOGD("RefbaseTest RefBaseTestTracker(const RefBaseTestTracker &testTracker) is called."); + checkCount_++; + value_ = testTracker.value_; + } + + RefBaseTestTracker &operator=(const RefBaseTestTracker &testTracker) + { + BENCHMARK_LOGD("RefbaseTest RefBaseTestTracker &operator=(const RefBaseTestTracker &testTracker) is called."); + checkCount_++; + value_ = testTracker.value_; + return *this; + } + + RefBaseTestTracker(RefBaseTestTracker &&testTracker) + { + BENCHMARK_LOGD("RefbaseTest RefBaseTestTracker(RefBaseTestTracker &&testTracker) is called."); + checkCount_++; + value_ = testTracker.value_; + } + + RefBaseTestTracker &operator=(RefBaseTestTracker &&testTracker) + { + BENCHMARK_LOGD("RefbaseTest RefBaseTestTracker &operator=(RefBaseTestTracker &&testTracker) is called."); + checkCount_++; + value_ = testTracker.value_; + return *this; + } + + static RefBaseTestTracker *GetInstance() + { + BENCHMARK_LOGD("RefbaseTest static RefBaseTestTracker *GetInstance() is called."); + static RefBaseTestTracker instance; + return &instance; + } + + void InitTracker() + { + BENCHMARK_LOGD("RefbaseTest void InitTracker() is called."); + checkCount_ = 0; + freeCount_ = 0; + firstRefCount_ = 0; + lastRefCount_ = 0; + } + + void TrackObject(IRemoteObject *object) + { + BENCHMARK_LOGD("RefbaseTest void TrackObject(IRemoteObject *object) is called."); + std::lock_guard lockGuard(objectMutex_); + trackObjects_.emplace_back(object); + } + + void TrackNewObject(IRemoteObject *object) + { + BENCHMARK_LOGD("RefbaseTest void TrackNewObject(IRemoteObject *object) is called."); + std::lock_guard lockGuard(objectOnfirstMutex_); + RefBaseTestTracker::firstRefCount_++; + } + + void UntrackObject(IRemoteObject *object) + { + BENCHMARK_LOGD("RefbaseTest void UntrackObject(IRemoteObject *object) is called."); + std::lock_guard lockGuard(objectMutex_); + auto iter = find(trackObjects_.begin(), trackObjects_.end(), object); + if (iter != trackObjects_.end()) { + trackObjects_.erase(iter); + } + } + + void TrackFreeObject(IRemoteObject *object) + { + BENCHMARK_LOGD("RefbaseTest void TrackFreeObject(IRemoteObject *object) is called."); + std::lock_guard lockGuard(objectOnfreeMutex_); + RefBaseTestTracker::freeCount_++; + } + + void PrintTrackResults() + { + BENCHMARK_LOGD("RefbaseTest void PrintTrackResults() is called."); + std::lock_guard lockGuard(objectMutex_); + if (!trackObjects_.empty()) { + for (auto o : trackObjects_) { + BENCHMARK_LOGD("object: %{public}p, strong: %{public}d, weak: %{public}d", + static_cast(o), o->GetSptrRefCount(), o->GetWptrRefCount()); + } + } + BENCHMARK_LOGD("firstRefCount_: %{public}d", RefBaseTestTracker::firstRefCount_); + BENCHMARK_LOGD("lastRefCount_: %{public}d", RefBaseTestTracker::lastRefCount_); + BENCHMARK_LOGD("freeCount_: %{public}d", RefBaseTestTracker::freeCount_); + } + +public: + int checkCount_ = 0; + int freeCount_ = 0; + int firstRefCount_ = 0; + int lastRefCount_ = 0; + +private: + + std::vector trackObjects_; + std::mutex objectMutex_; + std::mutex objectOnfirstMutex_; + std::mutex objectOnfreeMutex_; + int value_; +}; + +class IPCObjectProxy : public IRemoteObject { +public: + bool IsProxyObject() override + { + return 0; + } + string descriptor_; + explicit IPCObjectProxy(const string &descriptor) + { + descriptor_ = descriptor; + RefBaseTestTracker *tracker = RefBaseTestTracker::GetInstance(); + tracker->TrackObject(this); + tracker->TrackNewObject(this); + }; + ~IPCObjectProxy() {} + void RefPtrCallback() override; + void OnLastStrongRef(const void *objectId) override; + void OnFirstStrongRef(const void *objectId) override; + std::mutex mutexLast_; +}; + +const int SLEEP_FOR_ONE_MILLISECOND = 1; + +class IPCProcessSkeleton : public virtual RefBase, public Singleton { + friend class Singleton; + +private: + IPCProcessSkeleton() = default; + +public: + ~IPCProcessSkeleton() override = default; + + std::mutex mutex_; + std::map> objects1_; + + void DumpMapObjects() + { + BENCHMARK_LOGD("RefbaseTest void DumpMapObjects() is called."); + if (!objects1_.empty()) { + for (auto &o : objects1_) { + BENCHMARK_LOGD("strong: %{public}d, weak: %{public}d", + o.second->GetSptrRefCount(), o.second->GetWptrRefCount()); + } + } + } + IRemoteObject *QueryObjectInner(const string &descriptor) + { + BENCHMARK_LOGD("RefbaseTest IRemoteObject *QueryObjectInner(const string &descriptor) is called."); + auto it = objects1_.find(descriptor); + if (it != objects1_.end()) { + it->second->AttemptAcquire(this); + std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_FOR_ONE_MILLISECOND)); + return it->second.GetRefPtr(); + } + + return nullptr; + } + + IRemoteObject *FindOrNewObject(int handle) + { + BENCHMARK_LOGD("RefbaseTest IRemoteObject *FindOrNewObject(int handle) is called."); + std::lock_guard lockGuard(mutex_); + IRemoteObject *remoteObject = QueryObjectInner(to_string(handle)); + if (remoteObject != nullptr) { + std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_FOR_ONE_MILLISECOND)); + return remoteObject; + } + + remoteObject = new IPCObjectProxy(to_string(handle)); + remoteObject->AttemptAcquire(this); + objects1_.insert(std::pair>(to_string(handle), remoteObject)); + return remoteObject; + } + + bool DetachObject(IRemoteObject *object, string descriptor) + { + BENCHMARK_LOGD("RefbaseTest bool DetachObject(IRemoteObject *object, string descriptor) is called."); + std::lock_guard lockGuard(mutex_); + if (object->GetSptrRefCount()) { + return false; + } + return (objects1_.erase(descriptor) > 0); + } +}; + +const int SLEEP_FOR_TEN_NANOSECONDS = 10; + +void IPCObjectProxy::OnLastStrongRef(const void *objectId) +{ + BENCHMARK_LOGD("RefbaseTest void IPCObjectProxy::OnLastStrongRef(const void *objectId) is called."); + std::lock_guard lock(mutexLast_); + (void)IPCProcessSkeleton::GetInstance().DetachObject(this, descriptor_); + RefBaseTestTracker *tracker = RefBaseTestTracker::GetInstance(); + tracker->lastRefCount_++; + std::this_thread::sleep_for(std::chrono::nanoseconds(SLEEP_FOR_TEN_NANOSECONDS)); +} + +void IPCObjectProxy::OnFirstStrongRef(const void *objectId) +{ + BENCHMARK_LOGD("RefbaseTest void IPCObjectProxy::OnFirstStrongRef(const void *objectId) is called."); + std::this_thread::sleep_for(std::chrono::nanoseconds(SLEEP_FOR_TEN_NANOSECONDS)); +} + +void IPCObjectProxy::RefPtrCallback() +{ + BENCHMARK_LOGD("RefbaseTest void IPCObjectProxy::RefPtrCallback() is called."); + RefBaseTestTracker *tracker = RefBaseTestTracker::GetInstance(); + tracker->UntrackObject(this); + tracker->TrackFreeObject(this); + RefBase::RefPtrCallback(); +} + +constexpr int CYCLE_NUM1 = 2; +constexpr int CYCLE_NUM2 = 2; + +int RegisterEventThread() +{ + BENCHMARK_LOGD("RefbaseTest int RegisterEventThread() is called."); + auto &ipc = IPCProcessSkeleton::GetInstance(); + int handle = 10; + for (int i = 0; i < CYCLE_NUM2; i++) { + sptr remote = ipc.FindOrNewObject(handle); + if (remote) { + remote->IsProxyObject(); + } + } + return 0; +} + +class SptrTest : public RefBase { +public: + SptrTest() + { + g_sptrCount++; + } + ~SptrTest() + { + g_sptrCount--; + } + void CreateSptr() + { + test1 = new SptrTest(); + } + +private: + sptr test1; +}; + +class SptrTest1; +class SptrTest2; +class SptrTest2 : public RefBase { +public: + SptrTest2() + { + BENCHMARK_LOGD("RefbaseTest SptrTest2() is called."); + g_sptrCount++; + } + ~SptrTest2() + { + BENCHMARK_LOGD("RefbaseTest ~SptrTest2() is called."); + g_sptrCount--; + } + +private: + sptr test; +}; + +class SptrTest1 : public RefBase { +public: + SptrTest1() + { + BENCHMARK_LOGD("RefbaseTest SptrTest1() is called."); + g_sptrCount++; + } + ~SptrTest1() + { + BENCHMARK_LOGD("RefbaseTest ~SptrTest1() is called."); + g_sptrCount--; + } + +private: + sptr test; +}; + +class WptrTest : public RefBase { +public: + WptrTest() + { + g_sptrCount++; + } + ~WptrTest() + { + g_sptrCount--; + } +}; + +class WptrTest2 : public RefBase { +public: + WptrTest2() + { + g_sptrCount++; + flag_ = 0; + } + ~WptrTest2() + { + g_sptrCount--; + } + +private: + int flag_; +}; + +class RefBaseMemTest : public RefBase { +public: + explicit RefBaseMemTest(int value): value_(value) + { + BENCHMARK_LOGD("RefbaseTest explicit RefBaseMemTest(int value): value_(value) is called."); + checkCount_++; + } + + ~RefBaseMemTest() + { + BENCHMARK_LOGD("RefbaseTest ~RefBaseMemTest() is called."); + checkCount_--; + } + + RefBaseMemTest(const RefBaseMemTest &testRefbaseMem) + { + BENCHMARK_LOGD("RefbaseTest RefBaseMemTest(const RefBaseMemTest &testRefbaseMem) is called."); + checkCount_++; + value_ = testRefbaseMem.value_; + } + + RefBaseMemTest &operator=(const RefBaseMemTest &testRefbaseMem) + { + BENCHMARK_LOGD("RefbaseTest RefBaseMemTest &operator=(const RefBaseMemTest &testRefbaseMem) is called."); + checkCount_++; + value_ = testRefbaseMem.value_; + return *this; + } + + RefBaseMemTest(RefBaseMemTest &&testRefbaseMem) + { + BENCHMARK_LOGD("RefbaseTest RefBaseMemTest(RefBaseMemTest &&testRefbaseMem) is called."); + checkCount_++; + value_ = testRefbaseMem.value_; + } + + RefBaseMemTest &operator=(RefBaseMemTest &&testRefbaseMem) + { + BENCHMARK_LOGD("RefbaseTest RefBaseMemTest &operator=(RefBaseMemTest &&testRefbaseMem) is called."); + checkCount_++; + value_ = testRefbaseMem.value_; + return *this; + } + +public: + static inline int checkCount_ = 0; + +private: + int value_; +}; + +// This is a class which can be tracked when implemented. +class TestDebug : public RefBase { +public: + TestDebug() + { + EnableTracker(); + } +}; + +/* + * @tc.name: testRefbaseOperateThreads001 + * @tc.desc: Refbase for threads + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefbaseOperateThreads001)(benchmark::State &state) +{ + BENCHMARK_LOGD("RefbaseTest testRefbaseOperateThreads001 start."); + constexpr int cycleNum = 1; + while (state.KeepRunning()) { + RefBaseTestTracker *tracker = RefBaseTestTracker::GetInstance(); + tracker->InitTracker(); + for (int n = 0; n < cycleNum; n++) { + std::vector> threads; + for (int i = 0; i < CYCLE_NUM1; i++) { + threads.emplace_back(std::async(RegisterEventThread)); + } + + for (auto &f : threads) { + f.get(); + } + } + auto &ipc = IPCProcessSkeleton::GetInstance(); + ipc.DumpMapObjects(); + AssertEqual(tracker->firstRefCount_, tracker->freeCount_, + "tracker->firstRefCount_ and tracker->freeCount_ are not equal", state); + } + BENCHMARK_LOGD("RefbaseTest testRefbaseOperateThreads001 end."); +} + +/* + * @tc.name: testRefbaseOperate001 + * @tc.desc: test AttemptAcquire, IncWeakRef, DecWeakRef, IncStrongRef, DecStrongRef of Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefbaseOperate001)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefbaseOperate001 start."); + while (state.KeepRunning()) { + RefBaseTestTracker *tracker = RefBaseTestTracker::GetInstance(); + tracker->InitTracker(); + + auto remoteObject = new IPCObjectProxy("ss"); + remoteObject->AttemptAcquire(this); + remoteObject->IncWeakRef(this); + remoteObject->IncStrongRef(this); + remoteObject->DecStrongRef(this); + remoteObject->AttemptAcquire(this); + + remoteObject->IncStrongRef(this); + remoteObject->DecStrongRef(this); + + remoteObject->DecWeakRef(this); + AssertEqual(tracker->firstRefCount_, tracker->freeCount_, + "tracker->firstRefCount_ and tracker->freeCount_ are not equal", state); + } + BENCHMARK_LOGD("RefbaseTest testRefbaseOperate001 end."); +} + +constexpr int REF_MEM_TEST_OBJ_1_PARAM = 1; +constexpr int REF_MEM_TEST_OBJ_2_PARAM = 2; + +/* + * @tc.name: testRefbaseOperateLeftValue001 + * @tc.desc: Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefbaseOperateLeftValue001)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefbaseOperateLeftValue001 start."); + while (state.KeepRunning()) { + RefBaseMemTest::checkCount_ = 0; + { + vector refMemTestArray; + sptrrefMemTestObj1 = new RefBaseMemTest(REF_MEM_TEST_OBJ_1_PARAM); + sptrrefMemTestObj2 = new RefBaseMemTest(REF_MEM_TEST_OBJ_2_PARAM); + refMemTestArray.push_back(*refMemTestObj1); + refMemTestArray.push_back(*refMemTestObj2); + } + AssertEqual(RefBaseMemTest::checkCount_, 0, "RefBaseMemTest::checkCount_ did not equal 0", state); + + { + vector refMemTestArray; + RefBaseMemTest refMemTestObj1(REF_MEM_TEST_OBJ_1_PARAM); + RefBaseMemTest refMemTestObj2(REF_MEM_TEST_OBJ_2_PARAM); + refMemTestArray.push_back(refMemTestObj1); + refMemTestArray.push_back(refMemTestObj2); + } + AssertEqual(RefBaseMemTest::checkCount_, 0, "RefBaseMemTest::checkCount_ did not equal 0", state); + } + BENCHMARK_LOGD("RefbaseTest testRefbaseOperateLeftValue001 end."); +} + +/* + * @tc.name: testRefbaseOperateRightValue001 + * @tc.desc: Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefbaseOperateRightValue001)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefbaseOperateRightValue001 start."); + while (state.KeepRunning()) { + RefBaseMemTest::checkCount_ = 0; + { + vector refMemTestArray; + sptrrefMemTestObj1 = new RefBaseMemTest(REF_MEM_TEST_OBJ_1_PARAM); + sptrrefMemTestObj2 = new RefBaseMemTest(REF_MEM_TEST_OBJ_2_PARAM); + refMemTestArray.emplace_back(*refMemTestObj1); + refMemTestArray.emplace_back(*refMemTestObj2); + } + AssertEqual(RefBaseMemTest::checkCount_, 0, "RefBaseMemTest::checkCount_ did not equal 0", state); + + { + vector refMemTestArray; + RefBaseMemTest refMemTestObj1(REF_MEM_TEST_OBJ_1_PARAM); + RefBaseMemTest refMemTestObj2(REF_MEM_TEST_OBJ_2_PARAM); + refMemTestArray.emplace_back(refMemTestObj1); + refMemTestArray.emplace_back(refMemTestObj2); + } + AssertEqual(RefBaseMemTest::checkCount_, 0, "RefBaseMemTest::checkCount_ did not equal 0", state); + } + BENCHMARK_LOGD("RefbaseTest testRefbaseOperateRightValue001 end."); +} + +/* + * @tc.name: testRefbaseAcquire001 + * @tc.desc: Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefbaseAcquire001)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefbaseAcquire001 start."); + while (state.KeepRunning()) { + RefBaseTest* testobject = new RefBaseTest(); + testobject->AttemptAcquire(this); + + g_freeFlag = 0; + AssertEqual(testobject->GetSptrRefCount(), EXPECTED_REF_COUNT_ONE, + "testobject->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + + { + AssertTrue(testobject->IsAttemptAcquireSet(), + "testobject->IsAttemptAcquireSet() did not equal true", state); + sptr sptrRef = testobject; + AssertEqual(sptrRef->GetSptrRefCount(), EXPECTED_REF_COUNT_ONE, + "sptrRef->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + AssertFalse(testobject->IsAttemptAcquireSet(), + "testobject->IsAttemptAcquireSet() did not equal false", state); + } + + AssertEqual(g_freeFlag, EXPECTED_REF_COUNT_ONE, "g_freeFlag did not equal EXPECTED_REF_COUNT_ONE", state); + } + BENCHMARK_LOGD("RefbaseTest testRefbaseAcquire001 end."); +} + +/* + * @tc.name: testSptrefbase001 + * @tc.desc: Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testSptrefbase001)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testSptrefbase001 start."); + while (state.KeepRunning()) { + sptr testobject = new RefBaseTest(); + testobject->ExtendObjectLifetime(); + AssertTrue(testobject->IsExtendLifeTimeSet(), "testobject->IsExtendLifeTimeSet() did not equal true", state); + AssertEqual(g_refbaseflag, EXPECTED_REF_COUNT_ONE, + "g_refbaseflag did not equal EXPECTED_REF_COUNT_ONE", state); + wptr weakObject(testobject); + int count = testobject->GetWptrRefCount(); + AssertEqual(count, EXPECTED_REF_COUNT_TWO, "count did not equal EXPECTED_REF_COUNT_TWO", state); + testobject = nullptr; + + sptr strongObject = weakObject.promote(); + AssertEqual(strongObject->GetSptrRefCount(), EXPECTED_REF_COUNT_ONE, + "GetSptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + } + BENCHMARK_LOGD("RefbaseTest testSptrefbase001 end."); +} + +/* + * @tc.name: testSptrefbaseRealease001 + * @tc.desc: Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testSptrefbaseRealease001)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testSptrefbaseRealease001 start."); + constexpr int expectedFlag = 1; + while (state.KeepRunning()) { + sptr testObject = new RefBaseTest(); + AssertEqual(g_refbaseflag, expectedFlag, "g_refbaseflag did not equal expectedFlag", state); + wptr weakObject(testObject); + testObject = nullptr; + AssertEqual(g_refbaseflag, FLAG_OF_DEST, "g_refbaseflag did not equal FLAG_OF_DEST", state); + } + BENCHMARK_LOGD("RefbaseTest testSptrefbaseRealease001 end."); +} + +/* + * @tc.name: testSptrefbaseRealease002 + * @tc.desc: Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testSptrefbaseRealease002)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testSptrefbaseRealease002 start."); + constexpr int expectedFlag = 1; + while (state.KeepRunning()) { + wptr testObject = new RefBaseTest(); + AssertEqual(g_refbaseflag, expectedFlag, "g_refbaseflag did not equal expectedFlag", state); + testObject = nullptr; + AssertEqual(g_refbaseflag, FLAG_OF_DEST, "g_refbaseflag did not equal FLAG_OF_DEST", state); + } + BENCHMARK_LOGD("RefbaseTest testSptrefbaseRealease002 end."); +} + +/* + * @tc.name: testSptrefbase002 + * @tc.desc: Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testSptrefbase002)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testSptrefbase002 start."); + constexpr int expectedRefbaseFlag1 = 1; + constexpr int expectedRefbaseFlag2 = 2; + while (state.KeepRunning()) { + { + sptr testObject(new RefBaseTest()); + AssertEqual(g_refbaseflag, expectedRefbaseFlag1, "g_refbaseflag did not equal expectedRefbaseFlag1", state); + } + AssertEqual(g_refbaseflag, expectedRefbaseFlag2, + "g_refbaseflag did not equal expectedRefbaseFlag2", state); + } + BENCHMARK_LOGD("RefbaseTest testSptrefbase002 end."); +} + +/* + * @tc.name: testSptrefbase003 + * @tc.desc: Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testSptrefbase003)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testSptrefbase003 start."); + while (state.KeepRunning()) { + sptr testObject1(new RefBaseTest()); + sptr testObject2 = testObject1.GetRefPtr(); + testObject2->SetRefPtr(); + AssertTrue(testObject1->GetTestRefPtrFlag(), "testObject1->GetTestRefPtrFlag() did not equal true", state); + + sptr testObject3(testObject1); + AssertTrue(testObject3->GetTestRefPtrFlag(), "testObject3->GetTestRefPtrFlag() did not equal true", state); + + sptr testObject4 = testObject1; + AssertTrue(testObject3->GetTestRefPtrFlag(), "testObject3->GetTestRefPtrFlag() did not equal true", state); + + bool ret = (testObject3 == testObject4); + AssertTrue(ret, "ret did not equal true", state); + + int refcount = testObject1->GetSptrRefCount(); + AssertEqual(refcount, EXPECTED_REF_COUNT_FOUR, "refcount did not equal EXPECTED_REF_COUNT_FOUR", state); + + sptr testObject5(new RefBaseTest()); + ret = (testObject5 != testObject1); + AssertTrue(ret, "ret did not equal true", state); + } + BENCHMARK_LOGD("RefbaseTest testSptrefbase003 end."); +} + +/* + * @tc.name: testSptrefbase004 + * @tc.desc: Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testSptrefbase004)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testSptrefbase004 start."); + constexpr int expectedRefbaseFlag = 2; + while (state.KeepRunning()) { + sptr testObject1(new RefBaseTest()); + testObject1->SetRefPtr(); + RefBaseTest testObject2 = *testObject1; + AssertTrue(testObject2.GetTestRefPtrFlag(), "testObject2.GetTestRefPtrFlag() did not equal true", state); + + auto testObject3 = testObject1; + testObject1 = nullptr; + testObject3 = nullptr; + AssertEqual(g_refbaseflag, expectedRefbaseFlag, "g_refbaseflag did not equal expectedRefbaseFlag", state); + } + BENCHMARK_LOGD("RefbaseTest testSptrefbase004 end."); +} + +/* + * @tc.name: testSptrefbase005 + * @tc.desc: Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testSptrefbase005)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testSptrefbase005 start."); + while (state.KeepRunning()) { + sptr testObject1(new RefBaseTest()); + wptr testObject2 = testObject1; + AssertEqual(testObject1->GetSptrRefCount(), EXPECTED_REF_COUNT_ONE, + "testObject1->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + AssertEqual(testObject1->GetWptrRefCount(), EXPECTED_REF_COUNT_TWO, + "testObject1->GetWptrRefCount() did not equal EXPECTED_REF_COUNT_TWO", state); + } + BENCHMARK_LOGD("RefbaseTest testSptrefbase005 end."); +} + +/* + * @tc.name: testSptrefbase006 + * @tc.desc: Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testSptrefbase006)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testSptrefbase006 start."); + while (state.KeepRunning()) { + sptr testObject1; + AssertEqual(testObject1.GetRefPtr(), nullptr, "testObject1.GetRefPtr() did not equal nullptr", state); + testObject1 = new RefBaseTest(); + sptr testObject2(testObject1); + AssertEqual(testObject1->GetSptrRefCount(), EXPECTED_REF_COUNT_TWO, + "testObject1->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_TWO", state); + } + BENCHMARK_LOGD("RefbaseTest testSptrefbase006 end."); +} + +/* + * @tc.name: testSptrefbase007 + * @tc.desc: Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testSptrefbase007)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testSptrefbase007 start."); + while (state.KeepRunning()) { + const sptr &testObject1 = new RefBaseTest(); + sptr testObject2(testObject1); + AssertEqual(testObject1->GetSptrRefCount(), EXPECTED_REF_COUNT_TWO, + "testObject1->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_TWO", state); + } + BENCHMARK_LOGD("RefbaseTest testSptrefbase007 end."); +} + +/* + * @tc.name: testSptrefbase008 + * @tc.desc: Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testSptrefbase008)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testSptrefbase008 start."); + while (state.KeepRunning()) { + sptr testObject1; + sptr testObject2(testObject1); + AssertEqual(testObject2, nullptr, "testObject2 did not equal nullptr", state); + } + BENCHMARK_LOGD("RefbaseTest testSptrefbase008 end."); +} + +/* + * @tc.name: testSptrefbase009 + * @tc.desc: Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testSptrefbase009)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testSptrefbase009 start."); + while (state.KeepRunning()) { + sptr testObject0 = new RefBaseTest(); + sptr testObject1 = move(testObject0); + sptr testObject2(testObject1); + AssertEqual(testObject0.GetRefPtr(), nullptr, "testObject0.GetRefPtr() did not equal nullptr", state); + AssertEqual(testObject2.GetRefPtr(), testObject1.GetRefPtr(), + "testObject2.GetRefPtr() did not equal testObject1.GetRefPtr()", state); + } + BENCHMARK_LOGD("RefbaseTest testSptrefbase009 end."); +} + +/* + * @tc.name: testSptrefbase010 + * @tc.desc: Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testSptrefbase010)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testSptrefbase010 start."); + while (state.KeepRunning()) { + sptr testObject1 = new RefBaseTest(); + sptr testObject3(new RefBaseTest()); + sptr &testObject2 = testObject3; + testObject2 = testObject1; + AssertEqual(testObject2.GetRefPtr(), testObject1.GetRefPtr(), + "testObject2.GetRefPtr() did not equal testObject1.GetRefPtr()", state); + + const sptr &testObject4 = new RefBaseTest(); + AssertEqual(testObject1->GetSptrRefCount(), EXPECTED_REF_COUNT_TWO, + "testObject1->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_TWO", state); + testObject2 = testObject4; + AssertEqual(testObject2.GetRefPtr(), testObject4.GetRefPtr(), + "testObject2.GetRefPtr() did not equal testObject4.GetRefPtr()", state); + AssertEqual(testObject4->GetSptrRefCount(), EXPECTED_REF_COUNT_TWO, + "testObject4->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_TWO", state); + AssertEqual(testObject1->GetSptrRefCount(), EXPECTED_REF_COUNT_ONE, + "testObject1->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + } + BENCHMARK_LOGD("RefbaseTest testSptrefbase010 end."); +} + +/* + * @tc.name: testSptrefbase011 + * @tc.desc: test MakeSptr of sptr + */ +BENCHMARK_F(BenchmarkRefbaseTest, testSptrefbase011)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testSptrefbase011 start."); + while (state.KeepRunning()) { + RefBase ref; + sptr baseObject = sptr::MakeSptr(ref); + AssertEqual(baseObject.GetRefPtr()->GetSptrRefCount(), EXPECTED_REF_COUNT_ONE, + "baseObject.GetRefPtr()->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + } + BENCHMARK_LOGD("RefbaseTest testSptrefbase011 end."); +} + +/* + * @tc.name: testSptrefbase012 + * @tc.desc: test move assignment operator of sptr + */ +BENCHMARK_F(BenchmarkRefbaseTest, testSptrefbase012)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testSptrefbase012 start."); + while (state.KeepRunning()) { + sptr baseObject1(new RefBase()); + sptr baseObject2; + baseObject2 = std::move(baseObject1); + AssertEqual(baseObject1.GetRefPtr(), nullptr, "baseObject1.GetRefPtr() did not equal nullptr", state); + AssertEqual(baseObject2.GetRefPtr()->GetSptrRefCount(), EXPECTED_REF_COUNT_ONE, + "baseObject2.GetRefPtr()->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + sptr baseObject3(new RefBase()); + baseObject3 = std::move(baseObject2); + AssertEqual(baseObject2.GetRefPtr(), nullptr, "baseObject2.GetRefPtr() did not equal nullptr", state); + AssertEqual(baseObject3.GetRefPtr()->GetSptrRefCount(), EXPECTED_REF_COUNT_ONE, + "baseObject3.GetRefPtr()->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + } + BENCHMARK_LOGD("RefbaseTest testSptrefbase012 end."); +} + +/* + * @tc.name: testSptrefbase013 + * @tc.desc: test copy Constructor for sptr with the managed class type (O) + */ +BENCHMARK_F(BenchmarkRefbaseTest, testSptrefbase013)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testSptrefbase013 start."); + while (state.KeepRunning()) { + sptr baseObject1(new RefBaseTest()); + sptr baseObject2(baseObject1); + AssertEqual(baseObject1.GetRefPtr(), baseObject2.GetRefPtr(), + "baseObject1.GetRefPtr() did not equal baseObject2.GetRefPtr()", state); + AssertEqual(baseObject2.GetRefPtr()->GetSptrRefCount(), EXPECTED_REF_COUNT_TWO, + "baseObject2.GetRefPtr()->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_TWO", state); + } + BENCHMARK_LOGD("RefbaseTest testSptrefbase013 end."); +} + +/* + * @tc.name: testSptrefbase014 + * @tc.desc: test clear of sptr + */ +BENCHMARK_F(BenchmarkRefbaseTest, testSptrefbase014)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testSptrefbase014 start."); + while (state.KeepRunning()) { + sptr baseObject(new RefBaseTest()); + baseObject.clear(); + AssertEqual(baseObject.GetRefPtr(), nullptr, "baseObject.GetRefPtr() did not equal nullptr", state); + } + BENCHMARK_LOGD("RefbaseTest testSptrefbase014 end."); +} + +/* + * @tc.name: testSptrefbase015 + * @tc.desc: test boolean conversion operator of sptr + */ +BENCHMARK_F(BenchmarkRefbaseTest, testSptrefbase015)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testSptrefbase015 start."); + while (state.KeepRunning()) { + sptr baseObject1; + AssertFalse(baseObject1, "baseObject1 did not equal false", state); + sptr baseObject2(new RefBaseTest()); + AssertTrue(baseObject2, "baseObject2 did not equal true", state); + } + BENCHMARK_LOGD("RefbaseTest testSptrefbase015 end."); +} + +/* + * @tc.name: testSptrefbase016 + * @tc.desc: test Copy assignment operator for sptr with + * a different managed class type (O) + */ +BENCHMARK_F(BenchmarkRefbaseTest, testSptrefbase016)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testSptrefbase016 start."); + while (state.KeepRunning()) { + sptr testObject0(new RefBase()); + sptr testObject1(new RefBaseTest()); + testObject0 = testObject1; + AssertEqual(testObject1->GetSptrRefCount(), EXPECTED_REF_COUNT_TWO, + "GetSptrRefCount() did not equal EXPECTED_REF_COUNT_TWO", state); + } + BENCHMARK_LOGD("RefbaseTest testSptrefbase016 end."); +} + +/* + * @tc.name: testSptrefbase017 + * @tc.desc: test Equal-to operator between the sptr and wptr + */ +BENCHMARK_F(BenchmarkRefbaseTest, testSptrefbase017)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testSptrefbase017 start."); + while (state.KeepRunning()) { + sptr testObject0(new RefBase()); + wptr testObject1(new RefBase()); + AssertUnequal(testObject0, testObject1, "testObject0 did not unequal testObject1", state); + } + BENCHMARK_LOGD("RefbaseTest testSptrefbase017 end."); +} + +/* + * @tc.name: testSptrefbase018 + * @tc.desc: test Not-equal-to operator between the sptr and wptr + */ +BENCHMARK_F(BenchmarkRefbaseTest, testSptrefbase018)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testSptrefbase018 start."); + while (state.KeepRunning()) { + sptr testObject0(new RefBase()); + wptr testObject1(new RefBase()); + AssertUnequal(testObject0, testObject1, "testObject0 did not unequal testObject1", state); + } + BENCHMARK_LOGD("RefbaseTest testSptrefbase018 end."); +} + +/* + * @tc.name: testSptrefbase019 + * @tc.desc: test ForceSetRefPtr of sptr + */ +BENCHMARK_F(BenchmarkRefbaseTest, testSptrefbase019)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testSptrefbase019 start."); + while (state.KeepRunning()) { + sptr testObject; + AssertEqual(testObject.GetRefPtr(), nullptr, "testObject.GetRefPtr() did not equal nullptr", state); + RefBase baseObject; + testObject.ForceSetRefPtr(&baseObject); + AssertEqual(testObject.GetRefPtr(), &baseObject, "testObject.GetRefPtr() did not equal &baseObject", state); + } + BENCHMARK_LOGD("RefbaseTest testSptrefbase019 end."); +} + +/* + * @tc.name: testRefbase001 + * @tc.desc: test copy of Refbase. + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefbase001)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefbase001 start."); + while (state.KeepRunning()) { + RefBase baseObject1{}; + AssertEqual(baseObject1.GetRefCounter()->GetRefCount(), EXPECTED_REF_COUNT_ONE, + "refs->GetRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + RefBase baseObject2(baseObject1); + AssertEqual(baseObject1.GetRefCounter()->GetRefCount(), EXPECTED_REF_COUNT_ONE, + "refs->GetRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + RefBase baseObject3; + baseObject3 = baseObject2; + AssertEqual(baseObject1.GetRefCounter()->GetRefCount(), EXPECTED_REF_COUNT_ONE, + "refs->GetRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + } + BENCHMARK_LOGD("RefbaseTest testRefbase001 end."); +} + +/* + * @tc.name: testRefbase002 + * @tc.desc: test AttemptIncStrong of RefBase. + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefbase002)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefbase002 start."); + while (state.KeepRunning()) { + RefBase *baseObject = new RefBase(); + baseObject->AttemptIncStrong(this); + AssertTrue(baseObject->IsAttemptAcquireSet(), "baseObject->IsAttemptAcquireSet() did not equal true", state); + delete baseObject; + } + BENCHMARK_LOGD("RefbaseTest testRefbase002 end."); +} + +/* + * @tc.name: testRefbase003 + * @tc.desc: test AttemptIncStrongRef of RefBase. + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefbase003)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefbase003 start."); + while (state.KeepRunning()) { + RefBase *baseObject = new RefBase(); + baseObject->AttemptIncStrongRef(this); + AssertEqual(baseObject->GetRefCounter()->GetRefCount(), 1, "refs->GetRefCount() did not equal 1", state); + delete baseObject; + } + BENCHMARK_LOGD("RefbaseTest testRefbase003 end."); +} + +/* + * @tc.name: testRefbase004 + * @tc.desc: Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefbase004)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefbase004 start."); + while (state.KeepRunning()) { + { + sptr testObject1(new SptrTest()); + testObject1->CreateSptr(); + } + AssertEqual(g_sptrCount, EXPECTED_REF_COUNT_ZERO, "g_sptrCount did not equal EXPECTED_REF_COUNT_ZERO", state); + } + BENCHMARK_LOGD("RefbaseTest testRefbase004 end."); +} + +/* + * @tc.name: testRefbase005 + * @tc.desc: Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefbase005)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefbase005 start."); + while (state.KeepRunning()) { + { + sptr testObject1(new SptrTest1()); + sptr testObject2(new SptrTest2()); + AssertEqual(g_sptrCount, EXPECTED_REF_COUNT_TWO, + "g_sptrCount did not equal EXPECTED_REF_COUNT_TWO", state); + } + AssertEqual(g_sptrCount, EXPECTED_REF_COUNT_ZERO, "g_sptrCount did not equal EXPECTED_REF_COUNT_ZERO", state); + } + BENCHMARK_LOGD("RefbaseTest testRefbase005 end."); +} + +/* + * @tc.name: testRefbase006 + * @tc.desc: test count of refcounter. + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefbase006)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefbase006 start."); + while (state.KeepRunning()) { + sptr testObject1(new RefBase()); + AssertEqual(testObject1->GetRefCounter()->GetRefCount(), EXPECTED_REF_COUNT_ONE, + "testObject1->GetRefCounter()->GetRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + wptr testObject2(testObject1); + AssertEqual(testObject1->GetRefCounter()->GetRefCount(), EXPECTED_REF_COUNT_TWO, + "testObject1->GetRefCounter()->GetRefCount() did not equal EXPECTED_REF_COUNT_TWO", state); + } + BENCHMARK_LOGD("RefbaseTest testRefbase006 end."); +} + +/* + * @tc.name: testRefbase007 + * @tc.desc: test move constructor. + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefbase007)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefbase007 start."); + while (state.KeepRunning()) { + RefBase baseObject1{}; + AssertEqual(baseObject1.GetRefCounter()->GetRefCount(), EXPECTED_REF_COUNT_ONE, + "baseObject1.GetRefCounter()->GetRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + + RefBase baseObject2{}; + AssertEqual(baseObject2.GetRefCounter()->GetRefCount(), EXPECTED_REF_COUNT_ONE, + "baseObject2.GetRefCounter()->GetRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + baseObject2 = std::move(baseObject1); + AssertEqual(baseObject2.GetRefCounter()->GetRefCount(), EXPECTED_REF_COUNT_ONE, + "baseObject2.GetRefCounter()->GetRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + AssertEqual(baseObject1.GetRefCounter(), nullptr, "baseObject1.GetRefCounter() did not equal nullptr", state); + AssertEqual(baseObject1.GetSptrRefCount(), EXPECTED_REF_COUNT_ZERO, + "baseObject1.GetSptrRefCount() did not equal EXPECTED_REF_COUNT_ZERO", state); + AssertEqual(baseObject1.GetWptrRefCount(), EXPECTED_REF_COUNT_ZERO, + "baseObject1.GetWptrRefCount() did not equal EXPECTED_REF_COUNT_ZERO", state); + + RefBase baseObject3{}; + AssertEqual(baseObject3.GetRefCounter()->GetRefCount(), EXPECTED_REF_COUNT_ONE, + "baseObject3.GetRefCounter()->GetRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + baseObject3 = std::move(baseObject2); + AssertEqual(baseObject3.GetRefCounter()->GetRefCount(), EXPECTED_REF_COUNT_ONE, + "baseObject3.GetRefCounter()->GetRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + AssertEqual(baseObject2.GetRefCounter(), nullptr, "baseObject2.GetRefCounter() did not equal nullptr", state); + AssertEqual(baseObject2.GetSptrRefCount(), EXPECTED_REF_COUNT_ZERO, + "baseObject2.GetSptrRefCount() did not equal EXPECTED_REF_COUNT_ZERO", state); + AssertEqual(baseObject2.GetWptrRefCount(), EXPECTED_REF_COUNT_ZERO, + "baseObject2.GetWptrRefCount() did not equal EXPECTED_REF_COUNT_ZERO", state); + + baseObject2 = std::move(baseObject1); + AssertEqual(baseObject1.GetRefCounter(), baseObject2.GetRefCounter(), + "baseObject1.GetRefCounter() did not equal baseObject2.GetRefCounter()", state); + + RefBase baseObject4(std::move(baseObject3)); + AssertEqual(baseObject4.GetRefCounter()->GetRefCount(), EXPECTED_REF_COUNT_ONE, + "refs->GetRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + } + BENCHMARK_LOGD("RefbaseTest testRefbase007 end."); +} + +const int ONE_REF_COUNT = 1; +const int TWO_REF_COUNT = 2; +const int THREE_REF_COUNT = 3; + +template +void CompOrigWptrAndTarWptr001(const wptr &origWptr, const wptr &tarWptr, int value, benchmark::State& state) +{ + AssertEqual(static_cast(origWptr.GetRefPtr()), static_cast(tarWptr.GetRefPtr()), + "testOrigWptrObject.GetRefPtr() did not equal tarWptr.GetRefPtr()", state); + + AssertEqual(static_cast(&(*origWptr)), static_cast(&(*tarWptr)), + "&(*testOrigWptrObject) did not equal &(*tarWptr)", state); + + AssertEqual(tarWptr->GetWptrRefCount(), origWptr->GetWptrRefCount(), + "tarWptr->GetWptrRefCount() did not equal testOrigWptrObject->GetWptrRefCount()", state); + + AssertEqual(tarWptr.GetWeakRefCount(), origWptr.GetWeakRefCount(), + "tarWptr.GetWeakRefCount() did not equal testOrigWptrObject.GetWeakRefCount()", state); + + AssertEqual(tarWptr->GetWptrRefCount(), ONE_REF_COUNT, + "tarWptr->GetWptrRefCount() did not equal ONE_REF_COUNT", state); + + if (value == TWO_REF_COUNT) { + AssertEqual(tarWptr.GetWeakRefCount(), TWO_REF_COUNT, + "tarWptr.GetWeakRefCount() did not equal TWO_REF_COUNT", state); + } + + if (value == THREE_REF_COUNT) { + AssertEqual(tarWptr.GetWeakRefCount(), THREE_REF_COUNT, + "tarWptr.GetWeakRefCount() did not equal THREE_REF_COUNT", state); + } +} + +template +void CompOrigSptrAndTarWptr002(const sptr &origSptr, const wptr &tarWptr, int value, benchmark::State& state) +{ + AssertEqual(static_cast(origSptr.GetRefPtr()), static_cast(tarWptr.GetRefPtr()), + "origSptr.GetRefPtr() did not equal tarWptr.GetRefPtr()", state); + + AssertEqual(static_cast(&(*origSptr)), static_cast(&(*tarWptr)), + "&(*origSptr) did not equal &(*tarWptr)", state); + + AssertEqual(tarWptr->GetSptrRefCount(), origSptr->GetSptrRefCount(), + "tarWptr->GetSptrRefCount() did not equal origSptr->GetSptrRefCount()", state); + + AssertEqual(tarWptr->GetWptrRefCount(), origSptr->GetWptrRefCount(), + "tarWptr->GetWptrRefCount() did not equal origSptr->GetWptrRefCount()", state); + + AssertEqual(tarWptr->GetSptrRefCount(), ONE_REF_COUNT, + "tarWptr->GetSptrRefCount() did not equal ONE_REF_COUNT", state); + + if (value == TWO_REF_COUNT) { + AssertEqual(tarWptr->GetWptrRefCount(), TWO_REF_COUNT, + "tarWptr->GetWptrRefCount() did not equal TWO_REF_COUNT", state); + } + + if (value == THREE_REF_COUNT) { + AssertEqual(tarWptr->GetWptrRefCount(), THREE_REF_COUNT, + "tarWptr->GetWptrRefCount() did not equal THREE_REF_COUNT", state); + } + + AssertEqual(tarWptr.GetWeakRefCount(), ONE_REF_COUNT, + "tarWptr.GetWeakRefCount() did not equal ONE_REF_COUNT", state); +} + +/* + * @tc.name: testWptrefbase001 + * @tc.desc: Copy constructor with same managed class type. + */ +BENCHMARK_F(BenchmarkRefbaseTest, testWptrefbase001)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testWptrefbase001 start."); + while (state.KeepRunning()) { + // test wptr::wptr(const wptr&) + wptr testOrigWptrObject(new WptrTest()); + AssertEqual(testOrigWptrObject->GetWptrRefCount(), EXPECTED_REF_COUNT_ONE, + "testOrigWptrObject->GetWptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + + wptr testTargetWptrObject1(testOrigWptrObject); + CompOrigWptrAndTarWptr001(testOrigWptrObject, testTargetWptrObject1, EXPECTED_REF_COUNT_TWO, state); + + // test wptr::operator=(const wptr&) + wptr testTargetWptrObject2(new WptrTest()); + AssertEqual(testTargetWptrObject2->GetWptrRefCount(), EXPECTED_REF_COUNT_ONE, + "testTargetWptrObject2->GetWptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + + testTargetWptrObject2 = testOrigWptrObject; + CompOrigWptrAndTarWptr001(testOrigWptrObject, testTargetWptrObject2, EXPECTED_REF_COUNT_THREE, state); + + // test wptr::wptr(const sptr&) + sptr testOrigSptrObject(new WptrTest()); + AssertEqual(testOrigSptrObject->GetSptrRefCount(), EXPECTED_REF_COUNT_ONE, + "testOrigSptrObject->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + + wptr testTargetWptrObject3(testOrigSptrObject); + CompOrigSptrAndTarWptr002(testOrigSptrObject, testTargetWptrObject3, EXPECTED_REF_COUNT_TWO, state); + + // test wptr::operator=(const sptr&) + wptr testTargetWptrObject4(new WptrTest()); + AssertEqual(testTargetWptrObject4->GetWptrRefCount(), EXPECTED_REF_COUNT_ONE, + "testTargetWptrObject4->GetWptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + + testTargetWptrObject4 = testOrigSptrObject; + CompOrigSptrAndTarWptr002(testOrigSptrObject, testTargetWptrObject4, EXPECTED_REF_COUNT_THREE, state); + } + BENCHMARK_LOGD("RefbaseTest testWptrefbase001 end."); +} + +/* + * @tc.name: testWptrefbase002 + * @tc.desc: Copy constructor with different managed class type. + */ +BENCHMARK_F(BenchmarkRefbaseTest, testWptrefbase002)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testWptrefbase002 start."); + while (state.KeepRunning()) { + // test wptr::wptr(const wptr&) + wptr testOrigWptrObject(new WptrTest2()); + AssertEqual(testOrigWptrObject->GetWptrRefCount(), EXPECTED_REF_COUNT_ONE, + "testOrigWptrObject->GetWptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + + wptr testTargetWptrObject1(testOrigWptrObject); + CompOrigWptrAndTarWptr001(testOrigWptrObject, testTargetWptrObject1, EXPECTED_REF_COUNT_TWO, state); + + // test wptr::operator=(const wptr&) + wptr testTargetWptrObject2(new WptrTest()); + AssertEqual(testTargetWptrObject2->GetWptrRefCount(), EXPECTED_REF_COUNT_ONE, + "testTargetWptrObject2->GetWptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + + testTargetWptrObject2 = testOrigWptrObject; + CompOrigWptrAndTarWptr001(testOrigWptrObject, testTargetWptrObject2, EXPECTED_REF_COUNT_THREE, state); + + // test wptr::wptr(const sptr&) + sptr testOrigSptrObject(new WptrTest2()); + AssertEqual(testOrigSptrObject->GetSptrRefCount(), EXPECTED_REF_COUNT_ONE, + "testOrigSptrObject->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + + wptr testTargetWptrObject3(testOrigSptrObject); + CompOrigSptrAndTarWptr002(testOrigSptrObject, testTargetWptrObject3, EXPECTED_REF_COUNT_TWO, state); + + // test wptr::operator=(const sptr&) + wptr testTargetWptrObject4(new WptrTest()); + AssertEqual(testTargetWptrObject4->GetWptrRefCount(), EXPECTED_REF_COUNT_ONE, + "testTargetWptrObject4->GetWptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + + testTargetWptrObject4 = testOrigSptrObject; + CompOrigSptrAndTarWptr002(testOrigSptrObject, testTargetWptrObject4, EXPECTED_REF_COUNT_THREE, state); + } + BENCHMARK_LOGD("RefbaseTest testWptrefbase002 end."); +} + +/* + * @tc.name: testWptrefbase003 + * @tc.desc: Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testWptrefbase003)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testWptrefbase003 start."); + while (state.KeepRunning()) { + const wptr &testObject1(new WptrTest()); + wptr testObject2(testObject1); + AssertEqual(testObject1.GetRefPtr(), testObject2.GetRefPtr(), + "testObject1.GetRefPtr() did not equal testObject2.GetRefPtr()", state); + AssertEqual(testObject1->GetWptrRefCount(), EXPECTED_REF_COUNT_ONE, + "testObject1->GetWptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + AssertEqual(testObject2->GetWptrRefCount(), EXPECTED_REF_COUNT_ONE, + "testObject2->GetWptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + AssertEqual(testObject1.GetRefPtr(), testObject2.GetRefPtr(), + "testObject1.GetRefPtr() did not equal testObject2.GetRefPtr()", state); + } + BENCHMARK_LOGD("RefbaseTest testWptrefbase003 end."); +} + +/* + * @tc.name: testWptrefbase004 + * @tc.desc: Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testWptrefbase004)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testWptrefbase004 start."); + while (state.KeepRunning()) { + const sptr &testObject1(new WptrTest2()); + AssertUnequal(testObject1, nullptr, "testObject1 was not different from nullptr", state); + wptr testObject2 = testObject1; + AssertEqual(testObject1->GetWptrRefCount(), 2, "testObject1->GetWptrRefCount() did not equal 2", state); + } + BENCHMARK_LOGD("RefbaseTest testWptrefbase004 end."); +} + +/* + * @tc.name: testWptrefbase005 + * @tc.desc: wptr without managed object + */ +BENCHMARK_F(BenchmarkRefbaseTest, testWptrefbase005)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testWptrefbase005 start."); + while (state.KeepRunning()) { + wptr testObject3; + AssertEqual(testObject3.GetRefPtr(), nullptr, "testObject3.GetRefPtr() did not equal nullptr", state); + } + BENCHMARK_LOGD("RefbaseTest testWptrefbase005 end."); +} + +/* + * @tc.name: testWptrefbase006 + * @tc.desc: Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testWptrefbase006)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testWptrefbase006 start."); + while (state.KeepRunning()) { + wptr testObject1 = new WptrTest(); + wptr &testObject2 = testObject1; + AssertEqual(testObject2->GetWptrRefCount(), EXPECTED_REF_COUNT_ONE, + "testObject2->GetWptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + } + BENCHMARK_LOGD("RefbaseTest testWptrefbase006 end."); +} + +/* + * @tc.name: testWptrefbase007 + * @tc.desc: Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testWptrefbase007)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testWptrefbase007 start."); + while (state.KeepRunning()) { + wptr testObject1 = new WptrTest2(); + wptr testObject2 = testObject1.GetRefPtr(); + AssertEqual(testObject1->GetWptrRefCount(), EXPECTED_REF_COUNT_TWO, + "testObject1->GetWptrRefCount() did not equal EXPECTED_REF_COUNT_TWO", state); + } + BENCHMARK_LOGD("RefbaseTest testWptrefbase007 end."); +} + +/* + * @tc.name: testWptrefbase008 + * @tc.desc: Refbase + */ +BENCHMARK_F(BenchmarkRefbaseTest, testWptrefbase008)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testWptrefbase008 start."); + while (state.KeepRunning()) { + wptr testObject1 = new WptrTest(); + wptr testObject2; + testObject2 = testObject1.GetRefPtr(); + AssertEqual(testObject1->GetWptrRefCount(), EXPECTED_REF_COUNT_TWO, + "testObject1->GetWptrRefCount() did not equal EXPECTED_REF_COUNT_TWO", state); + } + BENCHMARK_LOGD("RefbaseTest testWptrefbase008 end."); +} + +/* + * @tc.name: testWptrefbase009 + * @tc.desc: test Equal-to operator between two wptrs + */ +BENCHMARK_F(BenchmarkRefbaseTest, testWptrefbase009)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testWptrefbase009 start."); + while (state.KeepRunning()) { + wptr testObject0(new RefBase()); + wptr testObject1(new RefBase()); + AssertUnequal(testObject0, testObject1, "testObject0 did not unequal testObject1", state); + } + BENCHMARK_LOGD("RefbaseTest testWptrefbase009 end."); +} + +/* + * @tc.name: testWptrefbase010 + * @tc.desc: test Not-equal-to operator between two wptrs + */ +BENCHMARK_F(BenchmarkRefbaseTest, testWptrefbase010)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testWptrefbase010 start."); + while (state.KeepRunning()) { + wptr testObject0(new RefBase()); + wptr testObject1(new RefBase()); + AssertUnequal(testObject0, testObject1, "testObject0 did not unequal testObject1", state); + } + BENCHMARK_LOGD("RefbaseTest testWptrefbase010 end."); +} + +/* + * @tc.name: testWptrefbase011 + * @tc.desc: test Equal-to operator between the wptr and input sptr object + */ +BENCHMARK_F(BenchmarkRefbaseTest, testWptrefbase011)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testWptrefbase011 start."); + while (state.KeepRunning()) { + wptr testObject0(new RefBase()); + sptr testObject1(new RefBase()); + AssertUnequal(testObject0, testObject1, "testObject0 did not unequal testObject1", state); + AssertEqual(testObject1->GetSptrRefCount(), EXPECTED_REF_COUNT_ONE, + "GetSptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + } + BENCHMARK_LOGD("RefbaseTest testWptrefbase011 end."); +} + +/* + * @tc.name: testWptrefbase012 + * @tc.desc: test Not-equal-to operator between the wptr and input sptr object + */ +BENCHMARK_F(BenchmarkRefbaseTest, testWptrefbase012)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testWptrefbase012 start."); + while (state.KeepRunning()) { + wptr testObject0(new RefBase()); + sptr testObject1(new RefBase()); + AssertUnequal(testObject0, testObject1, "testObject0 did not unequal testObject1", state); + AssertEqual(testObject1->GetSptrRefCount(), EXPECTED_REF_COUNT_ONE, + "GetSptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + } + BENCHMARK_LOGD("RefbaseTest testWptrefbase012 end."); +} + +/* + * @tc.name: testWptrefbase013 + * @tc.desc: test AttemptIncStrongRef of wptr + */ +BENCHMARK_F(BenchmarkRefbaseTest, testWptrefbase013)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testWptrefbase013 start."); + while (state.KeepRunning()) { + RefBase *baseObject = new RefBase(); + wptr testObject(baseObject); + testObject.AttemptIncStrongRef(this); + AssertEqual(baseObject->GetSptrRefCount(), EXPECTED_REF_COUNT_ONE, + "baseObject->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + } + BENCHMARK_LOGD("RefbaseTest testWptrefbase013 end."); +} + +/* + * @tc.name: testSptrWptrefbase001 + * @tc.desc: test interaction between sptr and wptr. + */ +BENCHMARK_F(BenchmarkRefbaseTest, testSptrWptrefbase001)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testSptrWptrefbase001 start."); + while (state.KeepRunning()) { + wptr testObject1(new RefBase()); + AssertEqual(testObject1->GetWptrRefCount(), EXPECTED_REF_COUNT_ONE, + "testObject1->GetWptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + { + sptr testObject2{}; + testObject2 = testObject1; + AssertEqual(testObject2->GetSptrRefCount(), EXPECTED_REF_COUNT_ONE, + "testObject2->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + AssertEqual(testObject2->GetWptrRefCount(), EXPECTED_REF_COUNT_TWO, + "testObject2->GetWptrRefCount() did not equal EXPECTED_REF_COUNT_TWO", state); + + sptr testObject3 = testObject1.promote(); + AssertEqual(testObject2->GetSptrRefCount(), EXPECTED_REF_COUNT_TWO, + "testObject2->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_TWO", state); + AssertEqual(testObject2->GetWptrRefCount(), EXPECTED_REF_COUNT_THREE, + "testObject2->GetWptrRefCount() did not equal EXPECTED_REF_COUNT_THREE", state); + testObject2->ExtendObjectLifetime(); + } + AssertEqual(testObject1->GetWptrRefCount(), EXPECTED_REF_COUNT_ONE, + "testObject1->GetWptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + } + BENCHMARK_LOGD("RefbaseTest testSptrWptrefbase001 end."); +} + +/* + * @tc.name: testRefbaseDebug001 + * @tc.desc: Test for single thread. Tracker can be enabled after construction + * of sptr. + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefbaseDebug001)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefbaseDebug001 start."); + while (state.KeepRunning()) { + sptr testObject1(new RefBase()); + testObject1->EnableTracker(); + sptr testObject2(testObject1); + AssertEqual(testObject2->GetSptrRefCount(), EXPECTED_REF_COUNT_TWO, + "testObject2->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_TWO", state); + wptr testObject3(testObject2); + wptr testObject4(testObject3); + AssertEqual(testObject4->GetWptrRefCount(), EXPECTED_REF_COUNT_THREE, + "testObject4->GetWptrRefCount() did not equal EXPECTED_REF_COUNT_THREE", state); + } + BENCHMARK_LOGD("RefbaseTest testRefbaseDebug001 end."); +} + +/* + * @tc.name: testRefbaseDebug002 + * @tc.desc: Test for single thread. Tracker can be enabled after construction + * of wptr. + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefbaseDebug002)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefbaseDebug002 start."); + while (state.KeepRunning()) { + wptr testObject1(new RefBase()); + testObject1->EnableTracker(); + sptr testObject2 = testObject1.promote(); + AssertEqual(testObject2->GetSptrRefCount(), EXPECTED_REF_COUNT_ONE, + "testObject2->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + wptr testObject3(testObject2); + wptr testObject4(testObject3); + AssertEqual(testObject4->GetWptrRefCount(), EXPECTED_REF_COUNT_THREE, + "testObject4->GetWptrRefCount() did not equal EXPECTED_REF_COUNT_THREE", state); + } + BENCHMARK_LOGD("RefbaseTest testRefbaseDebug002 end."); +} + +/* + * @tc.name: testRefbaseDebug003 + * @tc.desc: Test for single thread. Tracker can be enabled with construction + * of sptr. + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefbaseDebug003)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefbaseDebug003 start."); + while (state.KeepRunning()) { + sptr testObject1(new TestDebug()); + sptr testObject2(testObject1); + sptr testObject3; + AssertEqual(testObject2->GetSptrRefCount(), EXPECTED_REF_COUNT_TWO, + "testObject2->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_TWO", state); + testObject3 = testObject2; + wptr testObject4(testObject3); + AssertEqual(testObject4->GetWptrRefCount(), EXPECTED_REF_COUNT_FOUR, + "testObject4->GetWptrRefCount() did not equal EXPECTED_REF_COUNT_FOUR", state); + } + BENCHMARK_LOGD("RefbaseTest testRefbaseDebug003 end."); +} + +/* + * @tc.name: testRefbaseDebug004 + * @tc.desc: Test for mult-thread. + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefbaseDebug004)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefbaseDebug004 start."); + while (state.KeepRunning()) { + sptr testObject1(new TestDebug()); + std::thread subThread {[&testObject1, &state]() { + sptr subTestObject1(testObject1); + AssertEqual(testObject1->GetSptrRefCount(), EXPECTED_REF_COUNT_TWO, + "testObject1->GetSptrRefCount() did not equal EXPECTED_REF_COUNT_TWO", state); + wptr subTestObject2(subTestObject1); + wptr subTestObject3(subTestObject2); + }}; + wptr testObject2(testObject1); + wptr testObject3(testObject2); + subThread.join(); + AssertEqual(testObject3->GetWptrRefCount(), EXPECTED_REF_COUNT_TWO, + "testObject3->GetWptrRefCount() did not equal EXPECTED_REF_COUNT_TWO", state); + } + BENCHMARK_LOGD("RefbaseTest testRefbaseDebug004 end."); +} + +/* + * @tc.name: testWeakRefCounter001 + * @tc.desc: test CreateWeakRef of Refbase, + * and GetRefPtr, IncWeakRefCount, DecWeakRefCount, GetWeakRefCount, AttemptIncStrongRef of WeakRefCounter. + */ +BENCHMARK_F(BenchmarkRefbaseTest, testWeakRefCounter001)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testWeakRefCounter001 start."); + while (state.KeepRunning()) { + RefBase *baseObject1 = new RefBase(); + RefBase *newRefbase = new RefBase(); + WeakRefCounter *newWeakRef = baseObject1->CreateWeakRef(newRefbase); + AssertEqual(newWeakRef->GetRefPtr(), newRefbase, + "WeakRefCounter->GetRefPtr() did not equal RefBase object", state); + newWeakRef->IncWeakRefCount(this); + newWeakRef->IncWeakRefCount(this); + AssertEqual(newWeakRef->GetWeakRefCount(), 2, "WeakRefCounter->GetWeakRefCount() did not equal 2", state); + newWeakRef->AttemptIncStrongRef(this); + AssertEqual(baseObject1->GetRefCounter()->GetStrongRefCount(), EXPECTED_REF_COUNT_ONE, + "RefCounter->GetStrongRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + newWeakRef->DecWeakRefCount(this); + AssertEqual(newWeakRef->GetWeakRefCount(), EXPECTED_REF_COUNT_ONE, + "WeakRefCounter->GetWeakRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + newWeakRef->DecWeakRefCount(this); + delete newRefbase; + delete baseObject1; + } + BENCHMARK_LOGD("RefbaseTest testWeakRefCounter001 end."); +} + +/* + * @tc.name: testRefCounter001 + * @tc.desc: Test for IncRefCount, DecRefCount and GetRefCount + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefCounter001)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefCounter001 start."); + while (state.KeepRunning()) { + RefCounter *refs = new RefCounter(); + refs->IncRefCount(); + refs->IncRefCount(); + AssertEqual(refs->GetRefCount(), EXPECTED_REF_COUNT_TWO, + "refs->GetRefCount() did not equal EXPECTED_REF_COUNT_TWO", state); + refs->DecRefCount(); + AssertEqual(refs->GetRefCount(), EXPECTED_REF_COUNT_ONE, + "refs->GetRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + refs->DecRefCount(); + } + BENCHMARK_LOGD("RefbaseTest testRefCounter001 end."); +} + +/* +@tc.name: testRefCounter002 +@tc.desc: Test for SetCallback, RemoveCallback and IsRefPtrValid +*/ +BENCHMARK_F(BenchmarkRefbaseTest, testRefCounter002)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefCounter002 start."); + while (state.KeepRunning()) { + RefCounter *refs = new RefCounter(); + int externalVariable = 0; + + // Use the SetCallback method to set a lambda function as a + // callback that sets the value of externalVariable to 42 (an arbitrary value) + refs->SetCallback([&externalVariable]() { externalVariable = 42; }); + AssertTrue(refs->IsRefPtrValid(), "refs->IsRefPtrValid() did not return true", state); + refs->ExtendObjectLifetime(); + refs->IncWeakRefCount(this); + refs->DecWeakRefCount(this); + AssertEqual(externalVariable, 42, "externalVariable did not equal 42", state); + refs->RemoveCallback(); + AssertFalse(refs->IsRefPtrValid(), "refs->IsRefPtrValid() did not return false", state); + delete refs; + } + BENCHMARK_LOGD("RefbaseTest testRefCounter002 end."); +} + +/* + * @tc.name: testRefCounter003 + * @tc.desc: Test for IncStrongRefCount, DecStrongRefCount and GetStrongRefCount + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefCounter003)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefCounter003 start."); + while (state.KeepRunning()) { + RefCounter *refs = new RefCounter(); + refs->IncStrongRefCount(this); + int strongCnt = refs->IncStrongRefCount(this); + AssertEqual(strongCnt, EXPECTED_REF_COUNT_ONE, + "Before IncStrongRefCount, strong count was not EXPECTED_REF_COUNT_ONE", state); + AssertEqual(refs->GetStrongRefCount(), EXPECTED_REF_COUNT_TWO, + "After increments, refs->GetStrongRefCount() did not equal EXPECTED_REF_COUNT_TWO", state); + refs->DecStrongRefCount(this); + AssertEqual(refs->GetStrongRefCount(), EXPECTED_REF_COUNT_ONE, + "After decrement, refs->GetStrongRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + strongCnt = refs->DecStrongRefCount(this); + AssertEqual(strongCnt, EXPECTED_REF_COUNT_ONE, + "Before DecStrongRefCount, strong count was not EXPECTED_REF_COUNT_ONE", state); + AssertEqual(refs->GetStrongRefCount(), EXPECTED_REF_COUNT_ZERO, + "At the end, refs->GetStrongRefCount() did not equal EXPECTED_REF_COUNT_ZERO", state); + delete refs; + } + BENCHMARK_LOGD("RefbaseTest testRefCounter003 end."); +} + +/* + * @tc.name: testRefCounter004 + * @tc.desc: Test for IncWeakRefCount, DecWeakRefCount and GetWeakRefCount + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefCounter004)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefCounter004 start."); + while (state.KeepRunning()) { + RefCounter *refs = new RefCounter(); + refs->IncWeakRefCount(this); + int count = refs->IncWeakRefCount(this); + AssertEqual(count, EXPECTED_REF_COUNT_ONE, + "Before IncWeakRefCount, weak count was not EXPECTED_REF_COUNT_ONE", state); + AssertEqual(refs->GetWeakRefCount(), EXPECTED_REF_COUNT_TWO, + "refs->GetWeakRefCount() did not equal EXPECTED_REF_COUNT_TWO", state); + refs->DecWeakRefCount(this); + count = refs->DecWeakRefCount(this); + AssertEqual(count, EXPECTED_REF_COUNT_ONE, + "Before DecWeakRefCount, weak count was not EXPECTED_REF_COUNT_ONE", state); + AssertEqual(refs->GetWeakRefCount(), EXPECTED_REF_COUNT_ZERO, + "At the end, refs->GetWeakRefCount() did not equal EXPECTED_REF_COUNT_ZERO", state); + delete refs; + } + BENCHMARK_LOGD("RefbaseTest testRefCounter004 end."); +} + +/* + * @tc.name: testRefCounter005 + * @tc.desc: Test for SetAttemptAcquire, IsAttemptAcquireSet and ClearAttemptAcquire + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefCounter005)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefCounter005 start."); + while (state.KeepRunning()) { + RefCounter *refs = new RefCounter(); + refs->SetAttemptAcquire(); + AssertTrue(refs->IsAttemptAcquireSet(), "refs->IsAttemptAcquireSet() did not return true", state); + refs->ClearAttemptAcquire(); + AssertFalse(refs->IsAttemptAcquireSet(), "refs->IsAttemptAcquireSet() did not return false", state); + delete refs; + } + BENCHMARK_LOGD("RefbaseTest testRefCounter005 end."); +} + +/* + * @tc.name: testRefCounter006 + * @tc.desc: Test for AttemptIncStrongRef + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefCounter006)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefCounter006 start."); + while (state.KeepRunning()) { + RefCounter *refs = new RefCounter(); + int count = 0; + bool result = refs->AttemptIncStrongRef(this, count); + AssertTrue(result, "refs->AttemptIncStrongRef() did not return true", state); + AssertEqual(count, INITIAL_PRIMARY_VALUE, "outCount did not equal INITIAL_PRIMARY_VALUE", state); + AssertEqual(refs->GetStrongRefCount(), EXPECTED_REF_COUNT_ONE, + "refs->GetStrongRefCount() did not equal EXPECTED_REF_COUNT_ONE", state); + refs->DecStrongRefCount(this); + result = refs->AttemptIncStrongRef(this, count); + AssertFalse(result, "refs->AttemptIncStrongRef() did not return false", state); + AssertEqual(refs->GetStrongRefCount(), EXPECTED_REF_COUNT_ZERO, + "refs->GetStrongRefCount() did not equal EXPECTED_REF_COUNT_ZERO", state); + refs->IncStrongRefCount(this); + result = refs->AttemptIncStrongRef(this, count); + AssertTrue(result, "refs->AttemptIncStrongRef() did not return true", state); + AssertEqual(refs->GetStrongRefCount(), EXPECTED_REF_COUNT_TWO, + "refs->GetStrongRefCount() did not equal EXPECTED_REF_COUNT_TWO", state); + delete refs; + } + BENCHMARK_LOGD("RefbaseTest testRefCounter006 end."); +} + +/* + * @tc.name: testRefCounter007 + * @tc.desc: Test for AttemptIncStrong + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefCounter007)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefCounter007 start."); + constexpr int incrementByOne = 1; + constexpr int incrementByThree = 3; + while (state.KeepRunning()) { + RefCounter *refs = new RefCounter(); + bool result = refs->AttemptIncStrong(this); + AssertTrue(result, "refs->AttemptIncStrong() did not return true", state); + AssertEqual(refs->GetStrongRefCount(), INITIAL_PRIMARY_VALUE + incrementByOne, + "refs->GetStrongRefCount() did not equal INITIAL_PRIMARY_VALUE + incrementByOne", state); + refs->DecStrongRefCount(this); + result = refs->AttemptIncStrong(this); + AssertTrue(result, "refs->AttemptIncStrong() did not return true", state); + AssertEqual(refs->GetStrongRefCount(), INITIAL_PRIMARY_VALUE + incrementByOne, + "refs->GetStrongRefCount() did not equal INITIAL_PRIMARY_VALUE + incrementByOne", state); + refs->IncStrongRefCount(this); + result = refs->AttemptIncStrong(this); + AssertTrue(result, "refs->AttemptIncStrong() did not return true", state); + AssertEqual(refs->GetStrongRefCount(), INITIAL_PRIMARY_VALUE + incrementByThree, + "refs->GetStrongRefCount() did not equal INITIAL_PRIMARY_VALUE + incrementByThree", state); + delete refs; + } + BENCHMARK_LOGD("RefbaseTest testRefCounter007 end."); +} + +/* + * @tc.name: testRefCounter008 + * @tc.desc: Test for IsLifeTimeExtended, ExtendObjectLifetime + */ +BENCHMARK_F(BenchmarkRefbaseTest, testRefCounter008)(benchmark::State& state) +{ + BENCHMARK_LOGD("RefbaseTest testRefCounter008 start."); + while (state.KeepRunning()) { + RefCounter *refs = new RefCounter(); + AssertFalse(refs->IsLifeTimeExtended(), "refs->IsLifeTimeExtended() did not return false", state); + refs->ExtendObjectLifetime(); + AssertTrue(refs->IsLifeTimeExtended(), "refs->IsLifeTimeExtended did not return true", state); + delete refs; + } + BENCHMARK_LOGD("RefbaseTest testRefCounter008 end."); +} +} // namespace +} // namespace OHOS +// Run the benchmark +BENCHMARK_MAIN(); diff --git a/base/test/benchmarktest/timer_benchmark_test/BUILD.gn b/base/test/benchmarktest/timer_benchmark_test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..982755276bd1d09afc6660c7b515af5fda98c3fa --- /dev/null +++ b/base/test/benchmarktest/timer_benchmark_test/BUILD.gn @@ -0,0 +1,35 @@ +# Copyright (c) 2023 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") + +module_output_path = "commonlibrary_c_utils/timer" + +ohos_benchmarktest("TimerTest") { + module_out_path = module_output_path + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + sources = [ "timer_benchmark_test.cpp" ] + + deps = [ "//third_party/benchmark:benchmark" ] + + external_deps = [ + "c_utils:utils", + "hilog:libhilog_base", + ] +} diff --git a/base/test/benchmarktest/timer_benchmark_test/timer_benchmark_test.cpp b/base/test/benchmarktest/timer_benchmark_test/timer_benchmark_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..64b8b3f3aa7740ba6fbd9ff5ce39ed3d2340ebaa --- /dev/null +++ b/base/test/benchmarktest/timer_benchmark_test/timer_benchmark_test.cpp @@ -0,0 +1,408 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "timer.h" +#include "common_timer_errors.h" +#include +#include +#include +#include +#include +#include "../log.h" +#include "../assert.h" +using namespace std; + +namespace OHOS { +namespace { + +const int MICROSECONDS_IN_ONE_SECOND = 1000000; +const int MICROSECONDS_IN_ONE_MILLISECOND = 1000; + +int64_t CurMs() +{ + struct timeval tpend; + gettimeofday(&tpend, nullptr); + return (tpend.tv_sec * MICROSECONDS_IN_ONE_SECOND + tpend.tv_usec) / MICROSECONDS_IN_ONE_MILLISECOND; +} + +class BenchmarkTimerTest : public benchmark::Fixture { +public: + BenchmarkTimerTest() + { + Iterations(iterations); + Repetitions(repetitions); + ReportAggregatesOnly(); + } + + ~BenchmarkTimerTest() override = default; + void SetUp(const ::benchmark::State& state) override + { + } + + void TearDown(const ::benchmark::State& state) override + { + } + +protected: + const int32_t repetitions = 3; + const int32_t iterations = 50; +}; + +std::atomic g_data1(0); +void TimeOutCallback1() +{ + g_data1 += 1; +} + +std::atomic g_data2(0); +void TimeOutCallback2() +{ + g_data2 += 1; +} + +/* + * @tc.name: testTimer002 + * @tc.desc: timer unit test + */ +BENCHMARK_F(BenchmarkTimerTest, testTimer002)(benchmark::State& state) +{ + BENCHMARK_LOGD("TimerTest testTimer002 start."); + while (state.KeepRunning()) { + BENCHMARK_LOGD("TimerTest testTimer002 in."); + g_data1 = 0; + Utils::Timer timer("test_timer"); + uint32_t ret = timer.Setup(); + AssertEqual(Utils::TIMER_ERR_OK, ret, "Utils::TIMER_ERR_OK did not equal ret as expected.", state); + timer.Register(TimeOutCallback1, 1, true); + std::this_thread::sleep_for(std::chrono::milliseconds(15)); + timer.Shutdown(); + AssertEqual(1, g_data1, "1 did not equal g_data1 as expected.", state); + } + BENCHMARK_LOGD("TimerTest testTimer002 end."); +} + +/* + * @tc.name: testTimer003 + * @tc.desc: timer unit test + */ +BENCHMARK_F(BenchmarkTimerTest, testTimer003)(benchmark::State& state) +{ + BENCHMARK_LOGD("TimerTest testTimer003 start."); + while (state.KeepRunning()) { + g_data1 = 0; + g_data2 = 0; + Utils::Timer timer("test_timer"); + uint32_t ret = timer.Setup(); + AssertEqual(Utils::TIMER_ERR_OK, ret, "Utils::TIMER_ERR_OK did not equal ret as expected.", state); + timer.Register(TimeOutCallback1, 1); + timer.Register(TimeOutCallback2, 50); + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + timer.Shutdown(); + AssertGreaterThanOrEqual(g_data1, 8, "g_data1 was not greater than or equal to 8 as expected.", state); + AssertGreaterThanOrEqual(g_data2, 2, "g_data2 was not greater than or equal to 2 as expected.", state); + } + BENCHMARK_LOGD("TimerTest testTimer003 end."); +} + +/* + * @tc.name: testTimer004 + * @tc.desc: timer unit test + */ +BENCHMARK_F(BenchmarkTimerTest, testTimer004)(benchmark::State& state) +{ + BENCHMARK_LOGD("TimerTest testTimer004 start."); + while (state.KeepRunning()) { + g_data1 = 0; + Utils::Timer timer("test_timer"); + uint32_t ret = timer.Setup(); + AssertEqual(Utils::TIMER_ERR_OK, ret, "Utils::TIMER_ERR_OK did not equal ret as expected.", state); + timer.Register(TimeOutCallback1, 1); + timer.Register(TimeOutCallback1, 2); + std::this_thread::sleep_for(std::chrono::milliseconds(30)); + timer.Shutdown(); + AssertGreaterThanOrEqual(g_data1, 5, "g_data1 was not greater than or equal to 5 as expected.", state); + } + BENCHMARK_LOGD("TimerTest testTimer004 end."); +} + +class A { +public: + explicit A(int data) : data_(data), timer_("ATimer") {} + ~A() = default; + bool Init(); + bool StartTimer(int milliseconds, bool once); + void StopTimer(); + int GetData() const {return data_;} +private: + void TimeOutProc() + { + BENCHMARK_LOGD("TimerTest void TimeOutProc is called."); + data_ -= 1; + } + int data_; + Utils::Timer timer_; +}; + +bool A::Init() +{ + BENCHMARK_LOGD("TimerTest bool A::Init is called."); + return timer_.Setup() == Utils::TIMER_ERR_OK; +} + +bool A::StartTimer(int milliseconds, bool once) +{ + BENCHMARK_LOGD("TimerTest bool A::StartTimer is called."); + uint32_t timerId = timer_.Register(std::bind(&A::TimeOutProc, this), milliseconds, once); + return timerId != Utils::TIMER_ERR_DEAL_FAILED; +} + +void A::StopTimer() +{ + BENCHMARK_LOGD("TimerTest void A::StopTimer is called."); + timer_.Shutdown(); +} + +/* + * @tc.name: testTimer006 + * @tc.desc: timer unit test + */ +BENCHMARK_F(BenchmarkTimerTest, testTimer006)(benchmark::State& state) +{ + BENCHMARK_LOGD("testTimer006 start."); + while (state.KeepRunning()) { + A a(10); + AssertTrue(a.Init(), "a.Init() did not equal true as expected.", state); + AssertTrue(a.StartTimer(1, true), "a.StartTimer(1, true) did not equal true as expected.", state); + std::this_thread::sleep_for(std::chrono::milliseconds(20)); + a.StopTimer(); + AssertEqual(9, a.GetData(), "9 did not equal a.GetData() as expected.", state); + } + BENCHMARK_LOGD("testTimer006 end."); +} + +/* + * @tc.name: testTimer007 + * @tc.desc: abnormal case + */ +BENCHMARK_F(BenchmarkTimerTest, testTimer007)(benchmark::State& state) +{ + BENCHMARK_LOGD("testTimer007 start."); + while (state.KeepRunning()) { + g_data1 = 0; + Utils::Timer timer("test_timer", -1); + uint32_t ret = timer.Setup(); + AssertEqual(Utils::TIMER_ERR_OK, ret, "Utils::TIMER_ERR_OK did not equal ret as expected.", state); + + uint32_t timerId = 0; + for (uint32_t i = 0; i < 10; i++) { + timerId = timer.Register(TimeOutCallback1, 7, true); + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + } + timer.Unregister(timerId); + timer.Shutdown(false); + BENCHMARK_LOGD("testTimer007 g_data1:%{public}d", (int)g_data1); + AssertGreaterThanOrEqual(g_data1, 5, "g_data1 was not greater than or equal to 5 as expected.", state); + } + BENCHMARK_LOGD("testTimer007 end."); +} + +/* + * @tc.name: testTimer008 + * @tc.desc: timer sleep test for ivi + */ +BENCHMARK_F(BenchmarkTimerTest, testTimer008)(benchmark::State& state) +{ + BENCHMARK_LOGD("TimerTest testTimer008 start."); + while (state.KeepRunning()) { + g_data1 = 0; + Utils::Timer timer("test_timer"); + uint32_t ret = timer.Setup(); + AssertEqual(Utils::TIMER_ERR_OK, ret, "Utils::TIMER_ERR_OK did not equal ret as expected.", state); + timer.Register(TimeOutCallback1, 10); + + for (int i = 0; i < 11; i++) { + int64_t pre = CurMs(); + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + int64_t cur = CurMs(); + AssertGreaterThanOrEqual(cur - pre, 10, + "(cur - pre) was not greater than or equal to 10 as expected.", state); + } + timer.Shutdown(); + AssertGreaterThanOrEqual(g_data1, 10, "g_data1 was not greater than or equal to 10 as expected.", state); + } + BENCHMARK_LOGD("TimerTest testTimer008 end."); +} + +const int MAX_COUNT = 9; +const int TIMER_DELAY = 10; + +/* + * @tc.name: testTimer009 + * @tc.desc: recursive test + */ +void DoFunc(Utils::Timer &timer, int &count) +{ + BENCHMARK_LOGD("TimerTest void DoFunc is called."); + (void)timer.Register( + [&timer, &count]() { + count += 1; + if (count > MAX_COUNT) { + return; + } + DoFunc(timer, count); + }, + TIMER_DELAY, + true); + g_data1++; +} + +void DoFunc2(Utils::Timer &timer, int &count) +{ + BENCHMARK_LOGD("TimerTest void DoFunc2 is called."); + (void)timer.Register( + [&timer, &count]() { + count += 1; + if (count > MAX_COUNT) { + return; + } + DoFunc2(timer, count); + }, + TIMER_DELAY, + true); + g_data1++; +} + +BENCHMARK_F(BenchmarkTimerTest, testTimer009)(benchmark::State& state) +{ + BENCHMARK_LOGD("TimerTest testTimer009 start."); + while (state.KeepRunning()) { + g_data1 = 0; + Utils::Timer timer("test_timer"); + uint32_t ret = timer.Setup(); + AssertEqual(Utils::TIMER_ERR_OK, ret, "Utils::TIMER_ERR_OK did not equal ret as expected.", state); + + int cnt = 0, cnt1 = 0; + DoFunc(timer, cnt); + DoFunc2(timer, cnt1); + std::this_thread::sleep_for(std::chrono::milliseconds(50)); + AssertGreaterThanOrEqual(g_data1, 5, "g_data1 was not greater than or equal to 5 as expected.", state); + AssertGreaterThanOrEqual(14, g_data1, "g_data1 was not less than or equal to 14 as expected.", state); + std::this_thread::sleep_for(std::chrono::milliseconds(50)); + timer.Shutdown(); + AssertGreaterThanOrEqual(g_data1, 10, "g_data1 was not greater than or equal to 10 as expected.", state); + } + BENCHMARK_LOGD("TimerTest testTimer009 end."); +} + +/* + * @tc.name: testTimer010 + * @tc.desc: once timer register + */ +BENCHMARK_F(BenchmarkTimerTest, testTimer010)(benchmark::State& state) +{ + BENCHMARK_LOGD("TimerTest testTimer010 start."); + while (state.KeepRunning()) { + g_data1 = 0; + Utils::Timer timer("test_timer"); + uint32_t ret = timer.Setup(); + AssertEqual(Utils::TIMER_ERR_OK, ret, "Utils::TIMER_ERR_OK did not equal ret as expected.", state); + timer.Register(TimeOutCallback1, 10, true); + timer.Register(TimeOutCallback1, 10); + timer.Register(TimeOutCallback1, 10, true); + timer.Register(TimeOutCallback1, 10); + std::this_thread::sleep_for(std::chrono::milliseconds(52)); + timer.Shutdown(); + AssertGreaterThanOrEqual(g_data1, 8, "g_data1 was not greater than or equal to 8 as expected.", state); + } + BENCHMARK_LOGD("TimerTest testTimer010 end."); +} + +/* + * @tc.name: testTimer011 + * @tc.desc: once timer register + */ +BENCHMARK_F(BenchmarkTimerTest, testTimer011)(benchmark::State& state) +{ + BENCHMARK_LOGD("TimerTest testTimer011 start."); + while (state.KeepRunning()) { + g_data1 = 0; + Utils::Timer timer("test_timer"); + uint32_t ret = timer.Setup(); + AssertEqual(Utils::TIMER_ERR_OK, ret, "Utils::TIMER_ERR_OK did not equal ret as expected.", state); + timer.Register(TimeOutCallback1, 10); + timer.Register(TimeOutCallback1, 10, true); + timer.Register(TimeOutCallback1, 10); + timer.Register(TimeOutCallback1, 10, true); + std::this_thread::sleep_for(std::chrono::milliseconds(52)); + timer.Shutdown(); + AssertGreaterThanOrEqual(g_data1, 8, "g_data1 was not greater than or equal to 8 as expected.", state); + } + BENCHMARK_LOGD("TimerTest testTimer011 end."); +} + +/* + * @tc.name: testTimer012 + * @tc.desc: Test double setup. + */ +BENCHMARK_F(BenchmarkTimerTest, testTimer012)(benchmark::State& state) +{ + BENCHMARK_LOGD("TimerTest testTimer012 start."); + while (state.KeepRunning()) { + g_data1 = 0; + Utils::Timer timer("test_timer"); + uint32_t ret = timer.Setup(); + AssertEqual(Utils::TIMER_ERR_OK, ret, "Utils::TIMER_ERR_OK did not equal ret as expected.", state); + ret = timer.Setup(); + AssertEqual(Utils::TIMER_ERR_INVALID_VALUE, ret, + "Utils::TIMER_ERR_INVALID_VALUE did not equal ret as expected.", state); + + timer.Shutdown(); + } + BENCHMARK_LOGD("TimerTest testTimer012 end."); +} + +/* + * @tc.name: testTimer013 + * @tc.desc: Test uncommon operations. + */ +BENCHMARK_F(BenchmarkTimerTest, testTimer013)(benchmark::State& state) +{ + BENCHMARK_LOGD("TimerTest testTimer013 start."); + while (state.KeepRunning()) { + g_data1 = 0; + Utils::Timer timer("test_timer", -1); + uint32_t ret = timer.Setup(); + BENCHMARK_LOGD("TimerTest testTimer013 Setup."); + AssertEqual(Utils::TIMER_ERR_OK, ret, "Utils::TIMER_ERR_OK did not equal ret as expected.", state); + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + timer.Shutdown(false); + + BENCHMARK_LOGD("TimerTest testTimer013 Shutdown."); + + Utils::Timer timer1("test_timer_1"); + ret = timer1.Setup(); + BENCHMARK_LOGD("TimerTest testTimer013 Setup1."); + AssertEqual(Utils::TIMER_ERR_OK, ret, "Utils::TIMER_ERR_OK did not equal ret as expected.", state); + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + timer1.Shutdown(); + BENCHMARK_LOGD("TimerTest testTimer013 Shutdown false."); + } + BENCHMARK_LOGD("TimerTest testTimer013 end."); +} +} // namespace +} // namespace OHOS +// Run the benchmark +BENCHMARK_MAIN(); \ No newline at end of file diff --git a/bundle.json b/bundle.json index 4366b17f3a2b7b01632d8a22924cd58e4428e730..9f72ca3afacca48e8767b637c79e547f0596d893 100644 --- a/bundle.json +++ b/bundle.json @@ -110,7 +110,8 @@ } ], "test": [ - "//commonlibrary/c_utils/base/test:unittest" + "//commonlibrary/c_utils/base/test:unittest", + "//commonlibrary/c_utils/base/test/benchmarktest:benchmarktest" ] } }