1 /* 2 * Copyright (c) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "stats_service_stub_test.h" 17 #include "stats_log.h" 18 19 #include <message_parcel.h> 20 21 #include "stats_errors.h" 22 #include "stats_log.h" 23 #include "ibattery_stats.h" 24 #include "battery_stats_proxy.h" 25 #include "battery_stats_service.h" 26 #include "battery_stats_stub.h" 27 #include "battery_stats_info.h" 28 29 using namespace OHOS; 30 using namespace OHOS::PowerMgr; 31 using namespace std; 32 using namespace testing::ext; 33 34 namespace { 35 /** 36 * @tc.name: StatsServiceStubTest_001 37 * @tc.desc: test BatteryStatsStub 38 * @tc.type: FUNC 39 * @tc.require: issueI663DX 40 */ 41 HWTEST_F (StatsServiceStubTest, StatsServiceStubTest_001, TestSize.Level0) 42 { 43 STATS_HILOGI(LABEL_TEST, "StatsServiceStubTest_001 start"); 44 sptr<BatteryStatsService> statsService = BatteryStatsService::GetInstance(); 45 sptr<BatteryStatsStub> statsStub = static_cast<sptr<BatteryStatsStub>>(statsService); 46 47 MessageParcel data; 48 MessageParcel reply; 49 MessageOption option; 50 51 int ret = statsStub->OnRemoteRequest( 52 static_cast<uint32_t>(PowerMgr::IBatteryStatsIpcCode::COMMAND_GET_BATTERY_STATS_IPC), 53 data, reply, option); 54 EXPECT_EQ(ret, ERR_TRANSACTION_FAILED); 55 STATS_HILOGI(LABEL_TEST, "StatsServiceStubTest_001 end"); 56 } 57 58 /** 59 * @tc.name: StatsServiceStubTest_002 60 * @tc.desc: test BatteryStatsStub 61 * @tc.type: FUNC 62 * @tc.require: issueI663DX 63 */ 64 HWTEST_F (StatsServiceStubTest, StatsServiceStubTest_002, TestSize.Level0) 65 { 66 STATS_HILOGI(LABEL_TEST, "StatsServiceStubTest_002 start"); 67 sptr<BatteryStatsService> statsService = BatteryStatsService::GetInstance(); 68 sptr<BatteryStatsStub> statsStub = static_cast<sptr<BatteryStatsStub>>(statsService); 69 70 MessageParcel data; 71 MessageParcel reply; 72 MessageOption option; 73 data.WriteInterfaceToken(BatteryStatsProxy::GetDescriptor()); 74 75 uint32_t invalidCode = 76 static_cast<uint32_t>(PowerMgr::IBatteryStatsIpcCode::COMMAND_GET_BATTERY_STATS_IPC) + 100; 77 int ret = statsStub->OnRemoteRequest(invalidCode, data, reply, option); 78 EXPECT_NE(ret, ERR_OK); 79 STATS_HILOGI(LABEL_TEST, "StatsServiceStubTest_002 end"); 80 } 81 82 /** 83 * @tc.name: StatsServiceStubTest_003 84 * @tc.desc: test size of ShellDumpStub param exceed Max limit 85 * @tc.type: FUNC 86 * @tc.require: issueI6ARNA 87 */ 88 HWTEST_F (StatsServiceStubTest, StatsServiceStubTest_003, TestSize.Level0) 89 { 90 STATS_HILOGI(LABEL_TEST, "StatsServiceStubTest_003 start."); 91 MessageParcel data; 92 MessageParcel reply; 93 MessageOption option; 94 sptr<BatteryStatsService> statsService = BatteryStatsService::GetInstance(); 95 sptr<BatteryStatsStub> statsStub = static_cast<sptr<BatteryStatsStub>>(statsService); 96 97 data.WriteInterfaceToken(BatteryStatsProxy::GetDescriptor()); 98 const int32_t PARAM_MAX_NUM = 1024000; 99 data.WriteUint32(PARAM_MAX_NUM); 100 uint32_t code = static_cast<uint32_t>(PowerMgr::IBatteryStatsIpcCode::COMMAND_SHELL_DUMP_IPC); 101 int32_t ret = statsStub->OnRemoteRequest(code, data, reply, option); 102 EXPECT_EQ(ret, ERR_INVALID_DATA) << " ret:" << ret; 103 104 STATS_HILOGI(LABEL_TEST, "StatsServiceStubTest_003 end."); 105 } 106 107 /** 108 * @tc.name: StatsServiceStubTest_004 109 * @tc.desc: test GetBatteryStats 110 * @tc.type: FUNC 111 * @tc.require: issueI6ARNA 112 */ 113 HWTEST_F (StatsServiceStubTest, StatsServiceStubTest_004, TestSize.Level0) 114 { 115 STATS_HILOGI(LABEL_TEST, "StatsServiceStubTest_004 start."); 116 MessageParcel data; 117 MessageParcel reply; 118 MessageOption option; 119 sptr<BatteryStatsService> statsService = BatteryStatsService::GetInstance(); 120 sptr<BatteryStatsStub> statsStub = static_cast<sptr<BatteryStatsStub>>(statsService); 121 122 data.WriteInterfaceToken(BatteryStatsProxy::GetDescriptor()); 123 ParcelableBatteryStatsList batteryStats; 124 batteryStats.statsList_.push_back(nullptr); 125 bool ret = reply.WriteParcelable(&batteryStats); 126 EXPECT_TRUE(ret); 127 128 STATS_HILOGI(LABEL_TEST, "StatsServiceStubTest_004 end."); 129 } 130 131 /** 132 * @tc.name: StatsServiceStubTest_005 133 * @tc.desc: test GetBatteryStats 134 * @tc.type: FUNC 135 * @tc.require: issueI6ARNA 136 */ 137 HWTEST_F (StatsServiceStubTest, StatsServiceStubTest_005, TestSize.Level0) 138 { 139 STATS_HILOGI(LABEL_TEST, "StatsServiceStubTest_005 start."); 140 MessageParcel data; 141 Parcel reply; 142 MessageOption option; 143 sptr<BatteryStatsService> statsService = BatteryStatsService::GetInstance(); 144 sptr<BatteryStatsStub> statsStub = static_cast<sptr<BatteryStatsStub>>(statsService); 145 146 data.WriteInterfaceToken(BatteryStatsProxy::GetDescriptor()); 147 const int32_t PARAM_MAX_NUM = 1024000; 148 reply.WriteInt32(PARAM_MAX_NUM); 149 ParcelableBatteryStatsList* result = ParcelableBatteryStatsList::Unmarshalling(reply); 150 EXPECT_EQ(result, nullptr); 151 152 STATS_HILOGI(LABEL_TEST, "StatsServiceStubTest_005 end."); 153 } 154 155 /** 156 * @tc.name: StatsServiceStubTest_006 157 * @tc.desc: test GetBatteryStats 158 * @tc.type: FUNC 159 * @tc.require: issueI6ARNA 160 */ 161 HWTEST_F (StatsServiceStubTest, StatsServiceStubTest_006, TestSize.Level0) 162 { 163 STATS_HILOGI(LABEL_TEST, "StatsServiceStubTest_006 start."); 164 MessageParcel data; 165 Parcel reply; 166 MessageOption option; 167 sptr<BatteryStatsService> statsService = BatteryStatsService::GetInstance(); 168 sptr<BatteryStatsStub> statsStub = static_cast<sptr<BatteryStatsStub>>(statsService); 169 data.WriteInterfaceToken(BatteryStatsProxy::GetDescriptor()); 170 const int32_t PARAM_ZERO = 0; 171 reply.WriteInt32(PARAM_ZERO); 172 ParcelableBatteryStatsList* result = ParcelableBatteryStatsList::Unmarshalling(reply); 173 EXPECT_NE(result, nullptr); 174 STATS_HILOGI(LABEL_TEST, "StatsServiceStubTest_006 end."); 175 } 176 177 /** 178 * @tc.name: StatsServiceStubTest_007 179 * @tc.desc: test GetBatteryStats 180 * @tc.type: FUNC 181 * @tc.require: issueI6ARNA 182 */ 183 HWTEST_F (StatsServiceStubTest, StatsServiceStubTest_007, TestSize.Level0) 184 { 185 STATS_HILOGI(LABEL_TEST, "StatsServiceStubTest_007 start."); 186 MessageParcel data; 187 Parcel reply; 188 MessageOption option; 189 sptr<BatteryStatsService> statsService = BatteryStatsService::GetInstance(); 190 sptr<BatteryStatsStub> statsStub = static_cast<sptr<BatteryStatsStub>>(statsService); 191 data.WriteInterfaceToken(BatteryStatsProxy::GetDescriptor()); 192 const int32_t PARAM_MINUS_ONE = -1; 193 reply.WriteInt32(PARAM_MINUS_ONE); 194 ParcelableBatteryStatsList* result = ParcelableBatteryStatsList::Unmarshalling(reply); 195 EXPECT_EQ(result, nullptr); 196 STATS_HILOGI(LABEL_TEST, "StatsServiceStubTest_007 end."); 197 } 198 }