1 /*
2 * Copyright (c) 2025 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 <gtest/gtest.h>
17 #include <gmock/gmock.h>
18
19 #define private public
20 #include "appcapture_perf.h"
21 #include "main_thread.h"
22 #undef private
23 #include "cpp/mutex.h"
24 #include "lperf.h"
25
26 using namespace testing;
27 using namespace testing::ext;
28 using namespace OHOS;
29 using namespace OHOS::AppExecFwk;
30
31 namespace OHOS {
32 namespace AppExecFwk {
33 class AppCapturePerfTest : public testing::Test {
34 public:
AppCapturePerfTest()35 AppCapturePerfTest()
36 {}
~AppCapturePerfTest()37 ~AppCapturePerfTest()
38 {}
39 static void SetUpTestCase(void);
40 static void TearDownTestCase(void);
41 void SetUp();
42 void TearDown();
43 sptr<MainThread> mainThread_ = nullptr;
44 };
45
SetUpTestCase(void)46 void AppCapturePerfTest::SetUpTestCase(void)
47 {}
48
TearDownTestCase(void)49 void AppCapturePerfTest::TearDownTestCase(void)
50 {}
51
SetUp(void)52 void AppCapturePerfTest::SetUp(void)
53 {
54 mainThread_ = sptr<MainThread>(new (std::nothrow) MainThread());
55 }
56
TearDown(void)57 void AppCapturePerfTest::TearDown(void)
58 {}
59
60 /**
61 * @tc.number: AppCapturePerfTest001
62 * @tc.desc: add testcase codecoverage
63 * @tc.type: FUNC
64 */
65 HWTEST_F(AppCapturePerfTest, AppCapturePerfTest001, TestSize.Level0)
66 {
67 GTEST_LOG_(INFO) << "test AppCapturePerfTest001.\n";
68 FaultData faultData;
69 faultData.errorObject.name = "testapp";
70 faultData.errorObject.message = "test";
71 faultData.errorObject.stack = "";
72 int32_t ret = AppCapturePerf::GetInstance().CapturePerf(faultData);
73 EXPECT_EQ(ret, -1);
74 }
75
76 /**
77 * @tc.number: AppCapturePerfTest002
78 * @tc.desc: add testcase codecoverage
79 * @tc.type: FUNC
80 */
81 HWTEST_F(AppCapturePerfTest, AppCapturePerfTest002, TestSize.Level0)
82 {
83 GTEST_LOG_(INFO) << "test AppCapturePerfTest002.\n";
84 FaultData faultData;
85 faultData.errorObject.name = "testapp";
86 faultData.errorObject.message = "test";
87 faultData.errorObject.stack = "123,,1478";
88 faultData.timeoutMarkers = "123456";
89 int32_t ret = AppCapturePerf::GetInstance().CapturePerf(faultData);
90 EXPECT_EQ(ret, 0);
91 }
92
93 /**
94 * @tc.number: AppCapturePerfTest004
95 * @tc.desc: add testcase codecoverage
96 * @tc.type: FUNC
97 */
98 HWTEST_F(AppCapturePerfTest, AppCapturePerfTest004, TestSize.Level0)
99 {
100 GTEST_LOG_(INFO) << "test AppCapturePerfTest004.\n";
101 std::string input = "";
102 char delimiter = ',';
103 std::vector<std::string> result = AppCapturePerf::GetInstance().SplitStr(input, delimiter);
104 EXPECT_TRUE(result.empty());
105 }
106
107 /**
108 * @tc.number: AppCapturePerfTest005
109 * @tc.desc: add testcase codecoverage
110 * @tc.type: FUNC
111 */
112 HWTEST_F(AppCapturePerfTest, AppCapturePerfTest005, TestSize.Level0)
113 {
114 GTEST_LOG_(INFO) << "test AppCapturePerfTest005.\n";
115 std::string input = "single";
116 char delimiter = ',';
117 std::vector<std::string> result = AppCapturePerf::GetInstance().SplitStr(input, delimiter);
118 ASSERT_EQ(result.size(), 1);
119 EXPECT_EQ(result[0], "single");
120 }
121
122 /**
123 * @tc.number: AppCapturePerfTest006
124 * @tc.desc: add testcase codecoverage
125 * @tc.type: FUNC
126 */
127 HWTEST_F(AppCapturePerfTest, AppCapturePerfTest006, TestSize.Level0)
128 {
129 GTEST_LOG_(INFO) << "test AppCapturePerfTest006.\n";
130 std::string input = "apple,banana,cherry";
131 char delimiter = ',';
132 std::vector<std::string> result = AppCapturePerf::GetInstance().SplitStr(input, delimiter);
133 ASSERT_EQ(result.size(), 3);
134 EXPECT_EQ(result[0], "apple");
135 EXPECT_EQ(result[1], "banana");
136 EXPECT_EQ(result[2], "cherry");
137 }
138
139 /**
140 * @tc.name: ScheduleNotifyAppFault_0101
141 * @tc.desc: Schedule notify app Fault.
142 * @tc.type: FUNC
143 * @tc.require: issueI79RY8
144 */
145 HWTEST_F(AppCapturePerfTest, ScheduleNotifyAppFault_0101, TestSize.Level1)
146 {
147 FaultData faultData;
148 faultData.faultType = FaultDataType::CPU_LOAD;
149 faultData.errorObject.message = "msgContent";
150 faultData.errorObject.stack = "stack";
151 faultData.errorObject.name = "eventType";
152 const std::shared_ptr<EventRunner> runner;
153 const sptr<MainThread> thread;
154 mainThread_->mainHandler_ = std::make_shared<MainThread::MainHandler>(runner, thread);
155 auto ret = mainThread_->ScheduleNotifyAppFault(faultData);
156 EXPECT_EQ(ret, -1);
157 }
158
159 /**
160 * @tc.name: ScheduleNotifyAppFault_0102
161 * @tc.desc: Schedule notify app Fault.
162 * @tc.type: FUNC
163 * @tc.require: issueI79RY8
164 */
165 HWTEST_F(AppCapturePerfTest, ScheduleNotifyAppFault_0102, TestSize.Level1)
166 {
167 FaultData faultData;
168 faultData.faultType = FaultDataType::RESOURCE_CONTROL;
169 faultData.errorObject.message = "msgContent";
170 faultData.errorObject.stack = "stack";
171 faultData.errorObject.name = "eventType";
172 const std::shared_ptr<EventRunner> runner;
173 const sptr<MainThread> thread;
174 mainThread_->mainHandler_ = std::make_shared<MainThread::MainHandler>(runner, thread);
175 auto ret = mainThread_->ScheduleNotifyAppFault(faultData);
176 EXPECT_EQ(ret, NO_ERROR);
177 }
178 } // namespace AppExecFwk
179 } // namespace OHOS