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 "battery_stats_ipc_interface_code.h" 24 #include "battery_stats_proxy.h" 25 #include "battery_stats_service.h" 26 #include "battery_stats_stub.h" 27 28 using namespace OHOS; 29 using namespace OHOS::PowerMgr; 30 using namespace std; 31 using namespace testing::ext; 32 33 namespace { 34 /** 35 * @tc.name: StatsServiceStubTest_001 36 * @tc.desc: test BatteryStatsStub 37 * @tc.type: FUNC 38 * @tc.require: issueI663DX 39 */ 40 HWTEST_F (StatsServiceStubTest, StatsServiceStubTest_001, TestSize.Level0) 41 { 42 STATS_HILOGI(LABEL_TEST, "StatsServiceStubTest_001 start"); 43 sptr<BatteryStatsService> statsService = BatteryStatsService::GetInstance(); 44 sptr<BatteryStatsStub> statsStub = static_cast<sptr<BatteryStatsStub>>(statsService); 45 46 MessageParcel data; 47 MessageParcel reply; 48 MessageOption option; 49 50 int ret = statsStub->OnRemoteRequest( 51 static_cast<uint32_t>(PowerMgr::BatteryStatsInterfaceCode::BATTERY_STATS_GET), 52 data, reply, option); 53 EXPECT_EQ(ret, E_STATS_GET_SERVICE_FAILED); 54 STATS_HILOGI(LABEL_TEST, "StatsServiceStubTest_001 end"); 55 } 56 57 /** 58 * @tc.name: StatsServiceStubTest_002 59 * @tc.desc: test BatteryStatsStub 60 * @tc.type: FUNC 61 * @tc.require: issueI663DX 62 */ 63 HWTEST_F (StatsServiceStubTest, StatsServiceStubTest_002, TestSize.Level0) 64 { 65 STATS_HILOGI(LABEL_TEST, "StatsServiceStubTest_002 start"); 66 sptr<BatteryStatsService> statsService = BatteryStatsService::GetInstance(); 67 sptr<BatteryStatsStub> statsStub = static_cast<sptr<BatteryStatsStub>>(statsService); 68 69 MessageParcel data; 70 MessageParcel reply; 71 MessageOption option; 72 data.WriteInterfaceToken(BatteryStatsProxy::GetDescriptor()); 73 74 uint32_t invalidCode = 75 static_cast<uint32_t>(PowerMgr::BatteryStatsInterfaceCode::BATTERY_STATS_GET) + 100; 76 int ret = statsStub->OnRemoteRequest(invalidCode, data, reply, option); 77 EXPECT_NE(ret, ERR_OK); 78 STATS_HILOGI(LABEL_TEST, "StatsServiceStubTest_002 end"); 79 } 80 81 /** 82 * @tc.name: StatsServiceStubTest_003 83 * @tc.desc: test size of ShellDumpStub param exceed Max limit 84 * @tc.type: FUNC 85 * @tc.require: issueI6ARNA 86 */ 87 HWTEST_F (StatsServiceStubTest, StatsServiceStubTest_003, TestSize.Level0) 88 { 89 STATS_HILOGI(LABEL_TEST, "StatsServiceStubTest_003 start."); 90 MessageParcel data; 91 MessageParcel reply; 92 MessageOption option; 93 sptr<BatteryStatsService> statsService = BatteryStatsService::GetInstance(); 94 sptr<BatteryStatsStub> statsStub = static_cast<sptr<BatteryStatsStub>>(statsService); 95 96 data.WriteInterfaceToken(BatteryStatsProxy::GetDescriptor()); 97 const int32_t PARAM_MAX_NUM = 100; 98 data.WriteUint32(PARAM_MAX_NUM); 99 uint32_t code = static_cast<uint32_t>(PowerMgr::BatteryStatsInterfaceCode::BATTERY_STATS_DUMP); 100 int32_t ret = statsStub->OnRemoteRequest(code, data, reply, option); 101 EXPECT_EQ(ret, E_STATS_EXCEED_PARAM_LIMIT) << " ret:" << ret; 102 103 data.WriteInterfaceToken(BatteryStatsProxy::GetDescriptor()); 104 data.WriteUint32(1); 105 data.WriteString(""); 106 ret = statsStub->OnRemoteRequest(code, data, reply, option); 107 EXPECT_EQ(ret, E_STATS_READ_PARCEL_ERROR) << " ret:" << ret; 108 STATS_HILOGI(LABEL_TEST, "StatsServiceStubTest_003 end."); 109 } 110 }